// for the first and second chambers in the station, respectively
ClassImp(AliMUON)
-//___________________________________________
+//__________________________________________________________________
AliMUON::AliMUON()
{
// Default Constructor
fNCh = 0;
fNTrackingCh = 0;
fIshunt = 0;
- fPadHits = 0;
- fNPadHits = 0;
fChambers = 0;
- fDchambers = 0;
- fTriggerCircuits = 0;
- fNdch = 0;
- fRawClusters = 0;
- fNrawch = 0;
- fGlobalTrigger = 0;
- fNLocalTrigger = 0;
- fLocalTrigger = 0;
- fNLocalTrigger = 0;
+ fTriggerCircuits = 0;
fAccMin = 0.;
fAccMax = 0.;
fAccCut = kFALSE;
fMerger = 0;
fFileName = 0;
}
-
-//___________________________________________
+//__________________________________________________________________
AliMUON::AliMUON(const char *name, const char *title)
- : AliDetector(name,title)
+ : AliDetector(name,title)
{
//Begin_Html
/*
<img src="gif/alimuon.gif">
*/
//End_Html
+ fMUONData = 0x0;
+ fIshunt = 0;
- fHits = new TClonesArray("AliMUONHit",1000);
- gAlice->AddHitList(fHits);
- fPadHits = new TClonesArray("AliMUONPadHit",10000);
- fNPadHits = 0;
- fIshunt = 0;
-
- fNCh = AliMUONConstants::NCh();
- fNTrackingCh = AliMUONConstants::NTrackingCh();
- fNdch = new Int_t[fNCh];
-
- fDchambers = new TObjArray(AliMUONConstants::NCh());
-
- Int_t i;
-
- for (i=0; i<AliMUONConstants::NCh() ;i++) {
- fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i);
- fNdch[i]=0;
- }
-
- fNrawch = new Int_t[fNTrackingCh];
-
- fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
+ fNCh = AliMUONConstants::NCh();
+ fNTrackingCh = AliMUONConstants::NTrackingCh();
- for (i=0; i<AliMUONConstants::NTrackingCh();i++) {
- fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
- fNrawch[i]=0;
- }
-
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
- fNGlobalTrigger = 0;
- fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
- fNLocalTrigger = 0;
-
- SetMarkerColor(kRed);
-//
+ SetMarkerColor(kRed);//
//
-//
-//
-
+// Creating List of Chambers
Int_t ch;
-
fChambers = new TObjArray(AliMUONConstants::NCh());
-
// Loop over stations
for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
// Loop over 2 chambers in the station
- for (Int_t stCH = 0; stCH < 2; stCH++) {
-//
-//
-// Default Parameters for Muon Tracking Stations
-
-
- ch = 2 * st + stCH;
-//
- if (ch < AliMUONConstants::NTrackingCh()) {
- fChambers->AddAt(new AliMUONChamber(ch),ch);
- } else {
- fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
- }
-
- //PH AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
- AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
-
- chamber->SetGid(0);
- // Default values for Z of chambers
- chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
-//
- chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
-// Set chamber inner and outer radius to default
- chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
- chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
-//
- } // Chamber stCH (0, 1) in
+ for (Int_t stCH = 0; stCH < 2; stCH++) {
+ //
+ //
+ // Default Parameters for Muon Tracking Stations
+ ch = 2 * st + stCH;
+ if (ch < AliMUONConstants::NTrackingCh()) {
+ fChambers->AddAt(new AliMUONChamber(ch),ch);
+ } else {
+ fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
+ }
+ AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
+ chamber->SetGid(0);
+ // Default values for Z of chambers
+ chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
+ //
+ chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
+ // Set chamber inner and outer radius to default
+ chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
+ chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
+ //
+ } // Chamber stCH (0, 1) in
} // Station st (0...)
-// fChambers->SetLast(AliMUONConstants::NCh());
+
fMaxStepGas=0.01;
fMaxStepAlu=0.1;
fMaxDestepGas=-1;
fMaxDestepAlu=-1;
-//
- fMaxIterPad = 0;
- fCurIterPad = 0;
-//
- fAccMin = 0.;
- fAccMax = 0.;
- fAccCut = kFALSE;
-
- // cp new design of AliMUONTriggerDecision
- fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
- for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
- fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);
-
- }
- fMerger = 0;
+
+ fMaxIterPad = 0;
+ fCurIterPad = 0;
+
+ fAccMin = 0.;
+ fAccMax = 0.;
+ fAccCut = kFALSE;
+
+ // cp new design of AliMUONTriggerDecision
+ fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
+ for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
+ fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);
+ }
+ fMerger = 0;
}
-
-//___________________________________________
+//____________________________________________________________________
AliMUON::AliMUON(const AliMUON& rMUON):AliDetector(rMUON)
{
// Dummy copy constructor
;
}
-
+//____________________________________________________________________
AliMUON::~AliMUON()
{
// Destructor
- if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
-
- fIshunt = 0;
-
- // Delete TObjArrays
-
- if (fChambers){
- fChambers->Delete();
- delete fChambers;
- }
-
- if (fTriggerCircuits){
- fTriggerCircuits->Delete();
- delete fTriggerCircuits;
- }
-
- if (fDchambers){
- fDchambers->Delete();
- delete fDchambers;
- }
-
- if (fRawClusters){
- fRawClusters->Delete();
- delete fRawClusters;
- }
-
- if (fNrawch) delete [] fNrawch;
-
- // Delete TClonesArrays
-
- if (fPadHits){
- fPadHits->Delete();
- delete fPadHits;
- }
-
- if (fGlobalTrigger){
- fGlobalTrigger->Delete();
- delete fGlobalTrigger;
- }
- fNGlobalTrigger = 0;
-
- if (fLocalTrigger){
- fLocalTrigger->Delete();
- delete fLocalTrigger;
- }
- fNLocalTrigger = 0;
-
- if (fHits) {
- fHits->Delete();
- delete fHits;
- }
-
- if (fMerger) delete fMerger;
- if (fNdch) delete [] fNdch;
-
-}
-
-//___________________________________________
-void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
-{
- TClonesArray &lhits = *fHits;
- new(lhits[fNhits++]) AliMUONHit(fIshunt,track,vol,hits);
-}
-//___________________________________________
-void AliMUON::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)
-{
- TClonesArray &lhits = *fHits;
- new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber,
- idpart, X, Y, Z,
- tof, momentum, theta,
- phi, length, destep);
-}
-//___________________________________________
-void AliMUON::AddPadHit(Int_t *clhits) // To be removed
-{
- TClonesArray &lclusters = *fPadHits;
- new(lclusters[fNPadHits++]) AliMUONPadHit(clhits);
-}
-//_____________________________________________________________________________
-void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
-{
- //
- // Add a MUON digit to the list
- //
-
- //PH TClonesArray &ldigits = * ((TClonesArray*)(*fDchambers)[id]);
- TClonesArray &ldigits = * ( (TClonesArray*) fDchambers->At(id) );
- new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
-}
-
-//_____________________________________________________________________________
-void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
-{
- //
- // Add a MUON digit to the list
- //
-
- //PH TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
- TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
- new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
+ if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
+ fIshunt = 0;
+ if (fMerger) delete fMerger;
}
-
-//___________________________________________
-void AliMUON::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 AliMUON::AddLocalTrigger(Int_t *localtr)
-{
-// add a MUON Local Trigger to the list
- TClonesArray &localTrigger = *fLocalTrigger;
- new(localTrigger[fNLocalTrigger++]) AliMUONLocalTrigger(localtr);
-}
-
-//___________________________________________
+//____________________________________________________________________
void AliMUON::BuildGeometry()
{
// Geometry for event display
}
}
}
-
-//___________________________________________
+//___________________________________________________________________
Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
{
- return 9999;
-}
-
-//___________________________________________
-void AliMUON::MakeBranch(Option_t* option)
-{
- //
- // Create Tree branches for the MUON.
- //
- const Int_t kBufferSize = 4000;
- char branchname[30];
- sprintf(branchname,"%sCluster",GetName());
-
-
- const char *cD = strstr(option,"D");
- const char *cR = strstr(option,"R");
- const char *cH = strstr(option,"H");
-
- if (TreeH() && cH)
- {
- if (fPadHits == 0x0) fPadHits = new TClonesArray("AliMUONPadHit",10000);
- MakeBranchInTree(TreeH(), branchname, &fPadHits, kBufferSize, 0);
- if (fHits == 0x0) fHits = new TClonesArray("AliMUONHit",1000);
- }
- //it must be under fHits creation
- AliDetector::MakeBranch(option);
-
- if (cD && fLoader->TreeD()) {
- //
- // one branch for digits per chamber
- //
- Int_t i;
- if (fDchambers == 0x0)
- {
- fDchambers = new TObjArray(AliMUONConstants::NCh());
- for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
- fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i);
- }
- }
-
- for (i=0; i<AliMUONConstants::NCh() ;i++)
- {
- sprintf(branchname,"%sDigits%d",GetName(),i+1);
- MakeBranchInTree(fLoader->TreeD(), branchname, &((*fDchambers)[i]), kBufferSize, 0);
- printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
- }
- }
-
- if (cR && fLoader->TreeR()) {
- //
- // one branch for raw clusters per chamber
- //
- printf("Make Branch - TreeR address %p\n",fLoader->TreeR());
-
- Int_t i;
- if (fRawClusters == 0x0)
- {
- fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
- for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
- fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
- }
- }
-
- for (i=0; i<AliMUONConstants::NTrackingCh() ;i++)
- {
- sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
- MakeBranchInTree(fLoader->TreeR(), branchname, &((*fRawClusters)[i]), kBufferSize, 0);
- printf("Making Branch %s for raw clusters in chamber %d\n",branchname,i+1);
- }
- //
- // one branch for global trigger
- //
- sprintf(branchname,"%sGlobalTrigger",GetName());
-
- if (fGlobalTrigger == 0x0) {
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
- }
- MakeBranchInTree(fLoader->TreeR(), branchname, &fGlobalTrigger, kBufferSize, 0);
- printf("Making Branch %s for Global Trigger\n",branchname);
- //
- // one branch for local trigger
- //
- sprintf(branchname,"%sLocalTrigger",GetName());
-
- if (fLocalTrigger == 0x0) {
- fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
- }
-
- MakeBranchInTree(fLoader->TreeR(), branchname, &fLocalTrigger, kBufferSize, 0);
- printf("Making Branch %s for Local Trigger\n",branchname);
- }
-}
-
-//___________________________________________
-void AliMUON::SetTreeAddress()
-{
- // Set branch address for the Hits and Digits Tree.
- char branchname[30];
-
- TBranch *branch;
- TTree *treeH = fLoader->TreeH();
- TTree *treeD = fLoader->TreeD();
- TTree *treeR = fLoader->TreeR();
-
- if (treeH) {
- if (fPadHits == 0x0) fPadHits = new TClonesArray("AliMUONPadHit",10000);
- if (fPadHits) {
- branch = treeH->GetBranch("MUONCluster");
- if (branch) branch->SetAddress(&fPadHits);
- }
- if (fHits == 0x0) fHits = new TClonesArray("AliMUONHit",1000);
- }
- //it must be under fHits creation
- AliDetector::SetTreeAddress();
-
- if (treeD) {
- if (fDchambers == 0x0)
- {
- fDchambers = new TObjArray(AliMUONConstants::NCh());
- for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
- fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i);
- }
- }
- for (int i=0; i<AliMUONConstants::NCh(); i++) {
- sprintf(branchname,"%sDigits%d",GetName(),i+1);
-
- if (fDchambers) {
- branch = treeD->GetBranch(branchname);
- if (branch) branch->SetAddress(&((*fDchambers)[i]));
- }
- }
- }
-
- // printf("SetTreeAddress --- treeR address %p \n",treeR);
-
- if (treeR) {
- if (fRawClusters == 0x0)
- {
- fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
- for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
- fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
- }
- }
-
- for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
- sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
- if (fRawClusters) {
- branch = treeR->GetBranch(branchname);
- if (branch) branch->SetAddress(&((*fRawClusters)[i]));
- }
- }
-
- if (fLocalTrigger == 0x0) {
- fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
- }
-
- if (fLocalTrigger) {
- branch = treeR->GetBranch("MUONLocalTrigger");
- if (branch) branch->SetAddress(&fLocalTrigger);
- }
-
- if (fGlobalTrigger == 0x0) {
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
- }
-
- if (fGlobalTrigger) {
- branch = treeR->GetBranch("MUONGlobalTrigger");
- if (branch) branch->SetAddress(&fGlobalTrigger);
- }
- }
-}
-//___________________________________________
-void AliMUON::ResetHits()
-{
- // Reset number of clusters and the cluster array for this detector
- AliDetector::ResetHits();
- fNPadHits = 0;
- if (fPadHits) fPadHits->Clear();
+ return 9999;
}
-
-//____________________________________________
-void AliMUON::ResetDigits()
-{
- //
- // Reset number of digits and the digits array for this detector
- //
- if (fDchambers == 0x0) return;
- for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
- //PH if ((*fDchambers)[i]) ((TClonesArray*)(*fDchambers)[i])->Clear();
- if ((*fDchambers)[i]) ((TClonesArray*)fDchambers->At(i))->Clear();
- if (fNdch) fNdch[i]=0;
- }
-}
-//____________________________________________
-void AliMUON::ResetRawClusters()
-{
- //
- // Reset number of raw clusters and the raw clust array for this detector
- //
- for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
- //PH if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear();
- if ((*fRawClusters)[i]) ((TClonesArray*)fRawClusters->At(i))->Clear();
- if (fNrawch) fNrawch[i]=0;
- }
-}
-
-//____________________________________________
-void AliMUON::ResetTrigger()
+//__________________________________________________________________
+void AliMUON::SetTreeAddress()
{
- // Reset Local and Global Trigger
- fNGlobalTrigger = 0;
- if (fGlobalTrigger) fGlobalTrigger->Clear();
- fNLocalTrigger = 0;
- if (fLocalTrigger) fLocalTrigger->Clear();
+ GetMUONData()->SetLoader(fLoader);
+ GetMUONData()->SetTreeAddress("H,D,RC");
}
-//____________________________________________
+//____________________________________________________________________
void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
{
// Set the pad size for chamber id and cathode isec
Int_t i=2*(id-1);
- //PH ((AliMUONChamber*) (*fChambers)[i]) ->SetPadSize(isec,p1,p2);
- //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
((AliMUONChamber*) fChambers->At(i)) ->SetPadSize(isec,p1,p2);
((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
}
// Set Z values for all chambers (tracking and trigger)
// from the array pointed to by "Z"
for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
- //PH ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
return;
}
-
-//___________________________________________
+//_________________________________________________________________
void AliMUON::SetChambersZToDefault()
{
// Set Z values for all chambers (tracking and trigger)
SetChambersZ(AliMUONConstants::DefaultChamberZ());
return;
}
-
-//___________________________________________
+//_________________________________________________________________
void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
{
// Set the inverse charge slope for chamber id
- Int_t i=2*(id-1);
- //PH ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
- //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
+ Int_t i=2*(id-1); //PH ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
}
-
-//___________________________________________
+//__________________________________________________________________
void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
{
// Set sigma of charge spread for chamber id
Int_t i=2*(id-1);
- //PH ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
- //PH ((AliMUONChamber*) fChambers->Ati+1])->SetChargeSpread(p1,p2);
((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
}
-
-//___________________________________________
+//___________________________________________________________________
void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
{
// Set integration limits for charge spread
Int_t i=2*(id-1);
- //PH ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
- //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
}
-//___________________________________________
+//__________________________________________________________________
void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
{
// Set maximum number for ADCcounts (saturation)
Int_t i=2*(id-1);
- //PH ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
- //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
}
-
-//___________________________________________
+//__________________________________________________________________
void AliMUON::SetMaxStepGas(Float_t p1)
{
// Set stepsize in gas
- fMaxStepGas=p1;
+ fMaxStepGas=p1;
}
-
-//___________________________________________
+//__________________________________________________________________
void AliMUON::SetMaxStepAlu(Float_t p1)
{
// Set step size in Alu
fMaxStepAlu=p1;
}
-
-//___________________________________________
+//__________________________________________________________________
void AliMUON::SetMaxDestepGas(Float_t p1)
{
// Set maximum step size in Gas
fMaxDestepGas=p1;
}
-
-//___________________________________________
+//__________________________________________________________________
void AliMUON::SetMaxDestepAlu(Float_t p1)
{
// Set maximum step size in Alu
- fMaxDestepAlu=p1;
+ fMaxDestepAlu=p1;
}
-//___________________________________________
+//___________________________________________________________________
void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
{
// Set acceptance cuts
- fAccCut=acc;
- fAccMin=angmin*TMath::Pi()/180;
- fAccMax=angmax*TMath::Pi()/180;
- Int_t ch;
- if (acc) {
- for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
- // Loop over 2 chambers in the station
- for (Int_t stCH = 0; stCH < 2; stCH++) {
- ch = 2 * st + stCH;
-// Set chamber inner and outer radius according to acceptance cuts
- Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
- Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
- } // chamber loop
- } // station loop
- }
+ fAccCut=acc;
+ fAccMin=angmin*TMath::Pi()/180;
+ fAccMax=angmax*TMath::Pi()/180;
+ Int_t ch;
+ if (acc) {
+ for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
+ // Loop over 2 chambers in the station
+ for (Int_t stCH = 0; stCH < 2; stCH++) {
+ ch = 2 * st + stCH;
+ // Set chamber inner and outer radius according to acceptance cuts
+ Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
+ Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
+ } // chamber loop
+ } // station loop
+ }
}
-//___________________________________________
+//____________________________________________________________________
void AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
{
// Set the segmentation for chamber id cathode isec
- //PH ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
}
-//___________________________________________
+//____________________________________________________________________
void AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
{
// Set the response for chamber id
- //PH ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
}
-
+//____________________________________________________________________
void AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
{
// Set ClusterFinder for chamber id
- //PH ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
}
-
+//____________________________________________________________________
void AliMUON::SetNsec(Int_t id, Int_t nsec)
{
// Set number of segmented cathods for chamber id
- //PH ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
}
-
-//___________________________________________
+//_____________________________________________________________________
void AliMUON::SDigits2Digits()
{
fLoader->TreeD()->Reset();
}
-
-//__________________________________________________________________________
+//_______________________________________________________________________
AliLoader* AliMUON::MakeLoader(const char* topfoldername)
{
//builds standard getter (AliLoader type)
"Creating standard getter for detector %s. Top folder is %s.",
GetName(),topfoldername);
- fLoader = new AliMUONLoader(GetName(),topfoldername);
+ fLoader = new AliLoader(GetName(),topfoldername);
+ fMUONData = new AliMUONData(fLoader,GetName(),GetName());
return fLoader;
}
-//__________________________________________________________________________
-// To be removed
-void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
- Float_t eloss, Float_t tof, Int_t idvol)
-{
-//
-// Calls the charge disintegration method of the current chamber and adds
-// the simulated cluster to the root treee
-//
- Int_t clhits[7];
- Float_t newclust[6][500];
- Int_t nnew;
-
-
-//
-// Integrated pulse height on chamber
-
-
- clhits[0]=fNhits+1;
-//
-//
-// if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
-
-
- //PH ((AliMUONChamber*) (*fChambers)[idvol])
- ((AliMUONChamber*) fChambers->At(idvol))
- ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
- Int_t ic=0;
-// if (idvol == 6) printf("\n nnew %d \n", nnew);
-//
-// Add new clusters
- for (Int_t i=0; i<nnew; i++) {
- if (Int_t(newclust[3][i]) > 0) {
- ic++;
-// Cathode plane
- clhits[1] = Int_t(newclust[5][i]);
-// Cluster Charge
- clhits[2] = Int_t(newclust[0][i]);
-// Pad: ix
- clhits[3] = Int_t(newclust[1][i]);
-// Pad: iy
- clhits[4] = Int_t(newclust[2][i]);
-// Pad: charge
- clhits[5] = Int_t(newclust[3][i]);
-// Pad: chamber sector
- clhits[6] = Int_t(newclust[4][i]);
-
- AddPadHit(clhits);
- }
- }
-}
-//___________________________________________
+//_______________________________________________________________________
void AliMUON::Trigger(Int_t nev){
// call the Trigger Algorithm and fill TreeR
Int_t singleUndef[3] = {0,0,0};
Int_t pairUnlike[3] = {0,0,0};
Int_t pairLike[3] = {0,0,0};
-
+
ResetTrigger();
AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
decision->Trigger();
decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
pairUnlike, pairLike);
-
-// add a local trigger in the list
- AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
+
+ // add a local trigger in the list
+ GetMUONData()->AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
Int_t i;
for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) {
- if(decision->GetITrigger(icirc)==1) {
- Int_t localtr[7]={0,0,0,0,0,0,0};
- Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
- decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
- localtr[0] = icirc;
- localtr[1] = decision->GetStripX11(icirc);
- localtr[2] = decision->GetDev(icirc);
- localtr[3] = decision->GetStripY11(icirc);
- for (i=0; i<2; i++) { // convert the Lut output in 1 digit
- localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
- localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
- localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
- }
- AddLocalTrigger(localtr); // add a local trigger in the list
+ if(decision->GetITrigger(icirc)==1) {
+ Int_t localtr[7]={0,0,0,0,0,0,0};
+ Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
+ decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
+ localtr[0] = icirc;
+ localtr[1] = decision->GetStripX11(icirc);
+ localtr[2] = decision->GetDev(icirc);
+ localtr[3] = decision->GetStripY11(icirc);
+ for (i=0; i<2; i++) { // convert the Lut output in 1 digit
+ localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
+ localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
+ localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
}
+ GetMUONData()->AddLocalTrigger(localtr); // add a local trigger in the list
+ }
}
-
+
delete decision;
-
+
fLoader->TreeR()->Fill();
-// char hname[30];
-// sprintf(hname,"TreeR%d",nev);
-// fLoader->TreeR()->Write(hname,TObject::kOverwrite);
-// fLoader->TreeR()->Reset();
+ // char hname[30];
+ // sprintf(hname,"TreeR%d",nev);
+ // fLoader->TreeR()->Write(hname,TObject::kOverwrite);
+ // fLoader->TreeR()->Reset();
fLoader->WriteRecPoints("OVERWRITE");
ResetTrigger();
printf("\n End of trigger for event %d", nev);
}
-
-//____________________________________________
+//____________________________________________________________________
void AliMUON::Digits2Reco()
{
FindClusters();
//fLoader->TreeR()->Write(hname);
//fLoader->TreeR()->Reset();
fLoader->WriteRecPoints("OVERWRITE");
- ResetRawClusters();
+ GetMUONData()->ResetRawClusters();
printf("\n End of cluster finding for event %d", nev);
}
-
+//____________________________________________________________________
void AliMUON::FindClusters()
{
//
ResetDigits();
fLoader->TreeD()->GetEvent(0);
//TClonesArray *
- muonDigits = (TClonesArray *) Dchambers()->At(ich);
+ muonDigits = GetMUONData()->Digits(ich,0); // cathode plane not yet operational
ndig=muonDigits->GetEntriesFast();
printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
TClonesArray &lhits1 = *dig1;
ResetDigits();
fLoader->TreeD()->GetEvent(1);
//muonDigits = this->DigitsAddress(ich);
- muonDigits = (TClonesArray *) Dchambers()->At(ich);
+ muonDigits = GetMUONData()->Digits(ich,1); // cathode plane not yet operational
ndig=muonDigits->GetEntriesFast();
printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
TClonesArray &lhits2 = *dig2;
delete dig1;
delete dig2;
}
-
+//______________________________________________________________________
#ifdef never
-void AliMUON::Streamer(TBuffer &R__b)
+void AliMUON::Streamer(TBuffer &R__b)_
{
// Stream an object of class AliMUON.
AliMUONChamber *iChamber;
}
}
#endif
-
+//_______________________________________________________________________
AliMUONPadHit* AliMUON::FirstPad(AliMUONHit* hit, TClonesArray *clusters)
{
// to be removed
return 0;
}
}
-
+//_______________________________________________________________________
AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
{
// To be removed
return 0;
}
}
-
+//_______________________________________________________________________
AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
{
//
// Return rawcluster (icluster) for chamber ichamber and cathode icathod
// Obsolete ??
- TClonesArray *muonRawCluster = RawClustAddress(ichamber);
+ TClonesArray *muonRawCluster = GetMUONData()->RawClusters(ichamber);
ResetRawClusters();
TTree *treeR = fLoader->TreeR();
Int_t nent=(Int_t)treeR->GetEntries();
return mRaw;
}
-
+//________________________________________________________________________
void AliMUON::SetMerger(AliMUONMerger* merger)
{
// Set pointer to merger
fMerger = merger;
}
-
+//________________________________________________________________________
AliMUONMerger* AliMUON::Merger()
{
// Return pointer to merger
return fMerger;
}
-
-
-
+//________________________________________________________________________
AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
{
// copy operator
return *this;
}
-////////////////////////////////////////////////////////////////////////
-void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file)
-{
- //
- // Create TreeD branches for the MUON.
- //
-
- const Int_t kBufferSize = 4000;
- char branchname[30];
-
- if (fDchambers == 0x0) {
- fDchambers = new TObjArray(AliMUONConstants::NCh());
- for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
- fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i);
- }
- }
- //
- // one branch for digits per chamber
- //
- for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
- sprintf(branchname,"%sDigits%d",GetName(),i+1);
- if (fDchambers && treeD) {
- MakeBranchInTree(treeD,
- branchname, &((*fDchambers)[i]), kBufferSize, file);
-// printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
- }
- }
-}
-
-//___________________________________________
-
// AliDetector Class for MUON subsystem //
////////////////////////////////////////////////
#include "AliDetector.h"
+#include "AliMUONData.h"
+#include "AliMUONChamber.h"
class AliLoader;
-class AliMUONChamber;
class AliMUONLocalTrigger;
class AliMUONGlobalTrigger;
class AliMUONTriggerCircuit;
AliMUON(const char *name, const char *title);
AliMUON(const AliMUON& rMUON);
virtual ~AliMUON();
- virtual void AddHit(Int_t track , Int_t *vol, Float_t *hits);
- virtual void 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);
- virtual void AddPadHit(Int_t* clhits); // To be removed !
- virtual void AddDigits(Int_t id, Int_t* tracks, Int_t* charges,
- Int_t* digits);
- virtual void AddRawCluster(Int_t id, const AliMUONRawCluster& clust);
+
virtual void BuildGeometry();
- void AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
- Int_t *singleUndef, Int_t *pairUnlike,
- Int_t *pairLike);
- void AddLocalTrigger(Int_t* ltrigger);
Int_t DistancetoPrimitive(Int_t px, Int_t py);
- virtual Int_t IsVersion() const {return 0;}
- TClonesArray *PadHits() {return fPadHits;}
- TClonesArray *LocalTrigger() {return fLocalTrigger;}
- TClonesArray *GlobalTrigger() {return fGlobalTrigger;}
+ AliMUONData* GetMUONData() {return fMUONData;}
+ virtual Int_t IsVersion() const {return 0;}
+ // MUONLoader definition
virtual AliLoader* MakeLoader(const char* topfoldername); //builds standard getter (AliLoader type)
-
- virtual void MakeBranch(Option_t *opt=" ");
- virtual void MakeBranchInTreeD(TTree *treeD, const char *file=0);
+ // Interface with AliMUONData
+ virtual void MakeBranch(Option_t *opt=" ") {GetMUONData()->MakeBranch(opt);}
void SetTreeAddress();
- virtual void ResetHits();
- virtual void ResetDigits();
- virtual void ResetTrigger();
- virtual void ResetRawClusters();
+ virtual void ResetHits() {GetMUONData()->ResetHits();}
+ virtual void ResetDigits() {GetMUONData()->ResetDigits();}
+ virtual void ResetTrigger() {GetMUONData()->ResetTrigger();};
+ virtual void ResetRawClusters() {GetMUONData()->ResetRawClusters();};
// Cluster Finding
virtual void Digits2Reco();
virtual void FindClusters();
// Digitisation
virtual void SDigits2Digits();
-// Configuration Methods (per station id)
-//
-// Set Chamber Segmentation Parameters
-// id refers to the station and isec to the cathode plane
-// Set Z values for all chambers
+ // Configuration Methods (per station id)
+ //
+ // Set Chamber Segmentation Parameters
+ // id refers to the station and isec to the cathode plane
+ // Set Z values for all chambers
virtual void SetChambersZ(const Float_t *Z);
virtual void SetChambersZToDefault(void);
virtual void SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2);
-// Set Signal Generation Parameters
+ // Set Signal Generation Parameters
virtual void SetSigmaIntegration(Int_t id, Float_t p1);
virtual void SetChargeSlope(Int_t id, Float_t p1);
virtual void SetChargeSpread(Int_t id, Float_t p1, Float_t p2);
virtual void SetMaxAdc(Int_t id, Int_t p1);
-// Set Segmentation and Response Model
+ // Set Segmentation and Response Model
virtual void SetSegmentationModel(Int_t id, Int_t isec,
AliSegmentation *segmentation);
virtual void SetResponseModel(Int_t id, AliMUONResponse *response);
virtual void SetNsec(Int_t id, Int_t nsec);
-// Set Reconstruction Model
+ // Set Reconstruction Model
virtual void SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconstruction);
-// Set Merger/Digitizer
+ // Set Merger/Digitizer
virtual void SetMerger(AliMUONMerger* merger);
virtual AliMUONMerger* Merger();
-// Set Stepping Parameters
+ // Set Stepping Parameters
virtual void SetMaxStepGas(Float_t p1);
virtual void SetMaxStepAlu(Float_t p1);
virtual void SetMaxDestepGas(Float_t p1);
virtual void SetMaxDestepAlu(Float_t p1);
virtual void SetAcceptance(Bool_t acc=0, Float_t angmin=2, Float_t angmax=9);
-// Response Simulation
- virtual void MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
- Float_t eloss, Float_t tof, Int_t id);
-// get Trigger answer
+
+ // get Trigger answer
void Trigger(Int_t nev);
-// Return reference to Chamber #id
+ // Return reference to Chamber #id
virtual AliMUONChamber& Chamber(Int_t id)
- {return *((AliMUONChamber *) (*fChambers)[id]);}
-// Return reference to Circuit #id
+ {return *((AliMUONChamber *) (*fChambers)[id]);}
+ // Return reference to Circuit #id
virtual AliMUONTriggerCircuit& TriggerCircuit(Int_t id)
{return *((AliMUONTriggerCircuit *) (*fTriggerCircuits)[id]);}
-// Retrieve pad hits for a given Hit
+ // Retrieve pad hits for a given Hit
virtual AliMUONPadHit* FirstPad(AliMUONHit *hit, TClonesArray *padHits);
virtual AliMUONPadHit* NextPad(TClonesArray *padHits);
-// Return pointers to digits
- TObjArray *Dchambers() {return fDchambers;}
- Int_t *Ndch() {return fNdch;}
- virtual TClonesArray *DigitsAddress(Int_t id)
- {return ((TClonesArray *) (*fDchambers)[id]);}
-// Return pointers to reconstructed clusters
- TObjArray *RawClusters() {return fRawClusters;}
- Int_t *Nrawch() {return fNrawch;}
- virtual TClonesArray *RawClustAddress(Int_t id)
- {return ((TClonesArray *) (*fRawClusters)[id]);}
-
+ // Return pointers to digits
AliMUONRawCluster *RawCluster(Int_t ichamber, Int_t icathod,
Int_t icluster);
-// Copy Operator
+ // Copy Operator
AliMUON& operator = (const AliMUON& rhs);
-
+
protected:
Int_t fNCh; // Number of chambers
- Int_t fNTrackingCh; // Number of tracking chambers
- TObjArray *fChambers; // List of Tracking Chambers
- TObjArray *fTriggerCircuits; // List of Trigger Circuits
- Int_t fNPadHits; // Number of pad hits
- TClonesArray *fPadHits; //! List of pad hits
- TObjArray *fDchambers; //! List of digits
- Int_t *fNdch; // [fNCh] Number of digits per chamber
- TObjArray *fRawClusters; //! List of raw clusters
- Int_t *fNrawch; // [fNTrackingCh] Number of raw clusters per chamber
- Int_t fNLocalTrigger; // Number of Local Trigger
- TClonesArray *fLocalTrigger; //! List of Local Trigger
- Int_t fNGlobalTrigger; // Number of Global Trigger
- TClonesArray *fGlobalTrigger; //! List of Global Trigger
-
-//
+ Int_t fNTrackingCh; // Number of tracking chambers*
+ AliMUONData* fMUONData; // Data container for MUON subsystem
+ TObjArray* fChambers; // List of Tracking Chambers
+ TObjArray* fTriggerCircuits; // List of Trigger Circuits
+
+ //
Bool_t fAccCut; //Transport acceptance cut
Float_t fAccMin; //Minimum acceptance cut used during transport
Float_t fAccMax; //Minimum acceptance cut used during transport
-//
-
-// Stepping Parameters
- Float_t fMaxStepGas; // Maximum step size inside the chamber gas
- Float_t fMaxStepAlu; // Maximum step size inside the chamber aluminum
- Float_t fMaxDestepGas; // Maximum relative energy loss in gas
- Float_t fMaxDestepAlu; // Maximum relative energy loss in aluminum
-
-
-
-// Pad Iterator
- Int_t fMaxIterPad; // Maximum pad index
- Int_t fCurIterPad; // Current pad index
-// Background eent for event mixing
- Text_t *fFileName; // ! File with background hits
- AliMUONMerger *fMerger; // ! pointer to merger
-
- ClassDef(AliMUON,3) // MUON Detector base class
+ //
+ // Stepping Parameters
+ Float_t fMaxStepGas; // Maximum step size inside the chamber gas
+ Float_t fMaxStepAlu; // Maximum step size inside the chamber aluminum
+ Float_t fMaxDestepGas; // Maximum relative energy loss in gas
+ Float_t fMaxDestepAlu; // Maximum relative energy loss in aluminum
+
+ // Pad Iterator
+ Int_t fMaxIterPad; // Maximum pad index
+ Int_t fCurIterPad; // Current pad index
+ // Background eent for event mixing
+ Text_t *fFileName; // ! File with background hits
+ AliMUONMerger *fMerger; // ! pointer to merger
+
+ ClassDef(AliMUON,3) // MUON Detector base class
};
#endif
newchamber:
if (ch > 9) {if (fReco) return; nev++; ch = 0; goto newev;}
//gAlice->ResetDigits();
- fMuonDigits = MUON->DigitsAddress(ch);
+ fMuonDigits = MUON->GetMUONData()->Digits(ch,0);
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->DigitsAddress(ch);
+ fMuonDigits = MUON->GetMUONData()->Digits(ch,0);
ndigits[cath] = fMuonDigits->GetEntriesFast();
if (!ndigits[0] && !ndigits[1]) {if (fReco) return; ch++; goto newchamber;}
} // for (Int_t i=0; i<ntracks;
// Draw reconstructed coordinates
- MUONrawclust = MUON->RawClustAddress(ch);
+ MUONrawclust = MUON->GetMUONData()->RawClusters(ch);
TR->GetEvent(ch);
//cout << MUONrawclust << " " << MUONrawclust->GetEntries() << endl;
AliMUONRawCluster *mRaw;
*/
}
//cnew.fClusterType=cnew.PhysicsContribution();
- pMUON->AddRawCluster(AliMUONClusterInput::Instance()->Chamber(),cnew);
+ pMUON->GetMUONData()->AddRawCluster(AliMUONClusterInput::Instance()->Chamber(),cnew);
//fNPeaks++;
}
// Add a raw cluster copy to the list
//
AliMUON *pMUON=(AliMUON*)gAlice->GetModule("MUON");
- pMUON->AddRawCluster(fInput->Chamber(),c);
+ pMUON->GetMUONData()->AddRawCluster(fInput->Chamber(),c);
fNRawClusters++;
// if (fDebugLevel)
fprintf(stderr,"\nfNRawClusters %d\n",fNRawClusters);
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
//
// Add a MUON digit to the list of Digits of the detection plane id
//
- TClonesArray &ldigits = * ( (TClonesArray*) fDigits->At(id) );
+ TClonesArray &ldigits = * Digits(id,0) ;
new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
}
//_____________________________________________________________________________
TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
}
-//_____________________________________________________________________________
-
-//___________________________________________
+//____________________________________________________________________________
void AliMUONData::MakeBranch(Option_t* option)
{
//
if (TreeD() && cD ) {
// one branch for digits per chamber
if (fDigits == 0x0) {
- fDigits = new TObjArray(AliMUONConstants::NCh());
- fNdigits = new Int_t[AliMUONConstants::NCh()];
+ fDigits = new TObjArray(AliMUONConstants::NCh());
for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),iDetectionPlane);
+ }
+ }
+ if (fNdigits == 0x0) {
+ fNdigits = new Int_t[AliMUONConstants::NCh()];
+ for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
fNdigits[iDetectionPlane]=0;
}
}
Info("MakeBranch","Branch %s is already in tree.",GetName());
return;
}
- branch = TreeD()->Branch(branchname, &((*fDigits)[iDetectionPlane]),kBufferSize);
+ TClonesArray * digits = Digits(iDetectionPlane,0);
+ branch = TreeD()->Branch(branchname, &digits, kBufferSize);
Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
}
}
Int_t i;
if (fRawClusters == 0x0) {
fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
- fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
+ }
+ }
+
+ if (fNrawclusters == 0x0) {
+ fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
+ for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
fNrawclusters[i]=0;
}
}
if (fLocalTrigger) fLocalTrigger->Clear();
}
//_____________________________________________________________________________
-void AliMUONData::SetTreeAddress()
+void AliMUONData::SetTreeAddress(Option_t* option)
{
+ 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
+
// Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
char branchname[30];
TBranch * branch = 0x0;
//
// Branch address for hit tree
- if ( TreeH() ) {
+ if ( TreeH() && cH ) {
if (fHits == 0x0) fHits = new TClonesArray("AliMUONHit",1000);
fNhits =0;
}
- if (TreeH() && fHits) {
+ if (TreeH() && fHits && cH) {
sprintf(branchname,"%sHits",GetName());
branch = TreeH()->GetBranch(branchname);
if (branch) {
//
// Branch address for digit tree
- if ( TreeD() ) {
+ if ( TreeD() && cD) {
if (fDigits == 0x0) {
fDigits = new TObjArray(AliMUONConstants::NCh());
fNdigits= new Int_t[AliMUONConstants::NCh()];
}
}
- if (TreeD() && fDigits) {
+ if (TreeD() && fDigits && cD) {
for (int i=0; i<AliMUONConstants::NCh(); i++) {
sprintf(branchname,"%sDigits%d",GetName(),i+1);
branch = TreeD()->GetBranch(branchname);
- if (branch) branch->SetAddress(&((*fDigits)[i]));
+ TClonesArray * digits = Digits(i,0);
+ if (branch) branch->SetAddress( &digits );
else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
}
}
//
// Branch address for rawclusters, globaltrigger and local trigger tree
if (TreeR() ) {
- if (fRawClusters == 0x0) {
+ if (fRawClusters == 0x0 && cRC) {
fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
fNrawclusters[i]=0;
}
}
- if (fLocalTrigger == 0x0) {
+ if (fLocalTrigger == 0x0 && cGLT) {
fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
}
- if (fGlobalTrigger== 0x0) {
+ if (fGlobalTrigger== 0x0 && cGLT) {
fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
}
}
- if ( TreeR() && fRawClusters ) {
+ if ( TreeR() && fRawClusters && cRC) {
for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
if (fRawClusters) {
}
}
}
- if ( TreeR() && fLocalTrigger ) {
+ if ( TreeR() && fLocalTrigger && cGLT) {
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());
}
- if ( TreeR() && fGlobalTrigger) {
+ if ( TreeR() && fGlobalTrigger && cGLT) {
sprintf(branchname,"%sGlobalTrigger",GetName());
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress(&fGlobalTrigger);
}
}
//_____________________________________________________________________________
-
-
TClonesArray* GlobalTrigger() {return fGlobalTrigger;}
TClonesArray* RawClusters(Int_t DetectionPlane)
{return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );}
-
+
+ virtual AliLoader* GetLoader() {return fLoader;}
+ virtual void SetLoader(AliLoader * loader) {fLoader=loader;}
+
virtual void MakeBranch(Option_t *opt=" ");
- virtual void SetTreeAddress();
+ virtual void SetTreeAddress(Option_t *opt=" ");
virtual void ResetHits();
virtual void ResetDigits();
//------------------------------------------------------------------------
Bool_t AliMUONDigitizer::Init()
{
-// Initialization
-
+// Initialization
fHits = new TClonesArray("AliMUONHit",1000);
fPadHits = new TClonesArray("AliMUONPadHit",1000);
return kTRUE;
//------------------------------------------------------------------------
//void AliMUONDigitizer::Digitize()
-void AliMUONDigitizer::Exec(Option_t* option)
+void AliMUONDigitizer::Exec(Option_t* /*option*/)
{
-
- TString optionString = option;
- if (optionString.Data() == "deb") {
- cout<<"AliMUONDigitizer::Exec: called with option deb "<<endl;
- fDebug = 3;
- }
- AliMUONChamber* iChamber;
- AliSegmentation* segmentation;
-
- if (GetDebug()>2) cerr<<" AliMUONDigitizer::Digitize() starts"<<endl;
- fTDList = new TObjArray;
-
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- if (!pMUON) {
- cerr<<"AliMUONDigitizer::Digitize Error:"
- <<" module MUON not found in the input file"<<endl;
- return;
- }
+ // Obsolet sep 2003 Gines MARTINEZ
+
+// TString optionString = option;
+// if (optionString.Data() == "deb") {
+// cout<<"AliMUONDigitizer::Exec: called with option deb "<<endl;
+// fDebug = 3;
+// }
+// AliMUONChamber* iChamber;
+// AliSegmentation* segmentation;
- AliRunLoader *rl, *orl;
- AliLoader *gime, *ogime;
- orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
- ogime = orl->GetLoader("MUONLoader");
-
- pMUON->MakeBranchInTreeD(ogime->TreeD());
+// if (GetDebug()>2) cerr<<" AliMUONDigitizer::Digitize() starts"<<endl;
+// fTDList = new TObjArray;
+
+// //Loaders (We assume input0 to be the output too)
+// AliRunLoader *rl, *orl;
+// AliLoader *gime, *ogime;
+// orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+// ogime = orl->GetLoader("MUONLoader");
+
+// runloader = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
+// if (runloader == 0x0) {
+// cerr<<"AliMUONDigitizerv1::Digitize() opening file "<<fManager->GetInputFileName(0,0)<<endl;
+// return; // RunDigitizer is not working.
+// }
+// gime = runloader->GetLoader("MUONLoader");
+// if (gime->TreeH()==0x0) {
+// Info("Digitize","TreeH is not loaded yet. Loading...");
+// gime->LoadHits("READ");
+// Info("Digitize","Now treeH is %#x. MUONLoader is %#x",gime->TreeH(),gime);
+// }
+
+// if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() loaders"<<endl;
+
+// if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+// gAlice = runloader->GetAliRun();
+
+// // Getting Module MUON
+// AliMUON *pMUON = (AliMUON *) gAlice->GetDetector("MUON");
+// if (!pMUON) {
+// cerr<<"AliMUONDigitizerv1::Digitize Error:"
+// <<" module MUON not found in the input file"<<endl;
+// return;
+// }
+// // Loading Event
+// Int_t currentevent = fManager->GetOutputEventNr();
- fHitMap= new AliMUONHitMapA1* [AliMUONConstants::NCh()];
-
- //
- // loop over cathodes
- //
-
- for (int icat = 0; icat < 2; icat++) {
- fCounter = 0;
- for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
- iChamber = &(pMUON->Chamber(i));
-// if (!(iChamber->Nsec() == 1 && icat == 1)) {
- segmentation = iChamber->SegmentationModel(icat+1);
- fHitMap[i] = new AliMUONHitMapA1(segmentation, fTDList);
+// if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() Event Number is "<<currentevent <<endl;
+// if ( (currentevent<10) ||
+// (Int_t(TMath::Log10(currentevent)) == TMath::Log10(currentevent) ) )
+// cout <<"ALiMUONDigitizerv1::Digitize() Event Number is "<< currentevent <<endl;
+
+// // Output file for digits
+// AliRunLoader * runloaderout = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+// AliLoader * gimeout = runloaderout->GetLoader("MUONLoader");
+// // New branch per chamber for MUON digit in the tree of digits
+// if (gimeout->TreeD() == 0x0) gimeout->MakeDigitsContainer();
+// TTree* treeD = gimeout->TreeD();
+// pMUON->GetMUONData()->SetLoader(gimeout);
+// pMUON->MakeBranch("D");
+
+// fHitMap= new AliMUONHitMapA1* [AliMUONConstants::NCh()];
+
+// //
+// // loop over cathodes
+// //
+
+// for (int icat = 0; icat < 2; icat++) {
+// fCounter = 0;
+// for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
+// iChamber = &(pMUON->Chamber(i));
+// // if (!(iChamber->Nsec() == 1 && icat == 1)) {
+// segmentation = iChamber->SegmentationModel(icat+1);
+// fHitMap[i] = new AliMUONHitMapA1(segmentation, fTDList);
+// // }
// }
- }
-// Loop over files to digitize
- fSignal = kTRUE;
- for (Int_t inputFile=0; inputFile<fManager->GetNinputs();
- inputFile++) {
-// Connect MUON branches
+// // Loop over files to digitize
+// fSignal = kTRUE;
+// for (Int_t inputFile=0; inputFile<fManager->GetNinputs();
+// inputFile++) {
+// // Connect MUON branches
- if (inputFile > 0 ) fSignal = kFALSE;
- TBranch *branchHits = 0;
- TBranch *branchPadHits = 0;
+// if (inputFile > 0 ) fSignal = kFALSE;
+// TBranch *branchHits = 0;
+// TBranch *branchPadHits = 0;
- rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
- gime = rl->GetLoader("MUONLoader");
+// rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
+// gime = rl->GetLoader("MUONLoader");
- TTree *treeH = gime->TreeH();
- if (GetDebug()>2) {
- cerr<<" inputFile , cathode = "<<inputFile<<" "
- <<icat<<endl;
- cerr<<" treeH, fHits "<<treeH<<" "<<fHits<<endl;
- }
- if (treeH && fHits) {
- branchHits = treeH->GetBranch("MUON");
- if (branchHits) {
- fHits->Clear();
- branchHits->SetAddress(&fHits);
- }
- else
- Error("Exec","branch MUON was not found");
- }
- if (GetDebug()>2) cerr<<" branchHits = "<<branchHits<<endl;
-
- if (treeH && fPadHits) {
- branchPadHits = treeH->GetBranch("MUONCluster");
- if (branchPadHits)
- branchPadHits->SetAddress(&fPadHits);
- else
- Error("Exec","branch MUONCluster was not found");
- }
- if (GetDebug()>2) cerr<<" branchPadHits = "<<branchPadHits<<endl;
-
-//
-// Loop over tracks
-//
-
- Int_t ntracks = (Int_t) treeH->GetEntries();
-
- for (fTrack = 0; fTrack < ntracks; fTrack++) {
- if (GetDebug()>2) cerr<<" fTrack = "<<fTrack<<endl;
- fHits->Clear();
- fPadHits->Clear();
- branchHits->GetEntry(fTrack);
- branchPadHits->GetEntry(fTrack);
+// TTree *treeH = gime->TreeH();
+// if (GetDebug()>2) {
+// cerr<<" inputFile , cathode = "<<inputFile<<" "
+// <<icat<<endl;
+// cerr<<" treeH, fHits "<<treeH<<" "<<fHits<<endl;
+// }
+// if (treeH && fHits) {
+// branchHits = treeH->GetBranch("MUON");
+// if (branchHits) {
+// fHits->Clear();
+// branchHits->SetAddress(&fHits);
+// }
+// else
+// Error("Exec","branch MUON was not found");
+// }
+// if (GetDebug()>2) cerr<<" branchHits = "<<branchHits<<endl;
+
+// if (treeH && fPadHits) {
+// branchPadHits = treeH->GetBranch("MUONCluster");
+// if (branchPadHits)
+// branchPadHits->SetAddress(&fPadHits);
+// else
+// Error("Exec","branch MUONCluster was not found");
+// }
+// if (GetDebug()>2) cerr<<" branchPadHits = "<<branchPadHits<<endl;
+
+// //
+// // Loop over tracks
+// //
+
+// Int_t ntracks = (Int_t) treeH->GetEntries();
+
+// for (fTrack = 0; fTrack < ntracks; fTrack++) {
+// if (GetDebug()>2) cerr<<" fTrack = "<<fTrack<<endl;
+// fHits->Clear();
+// fPadHits->Clear();
+// branchHits->GetEntry(fTrack);
+// branchPadHits->GetEntry(fTrack);
-//
-// Loop over hits
-
- AliMUONHit* mHit;
- for(Int_t i = 0; i < fHits->GetEntriesFast(); ++i) {
- mHit = static_cast<AliMUONHit*>(fHits->At(i));
- fNch = mHit->Chamber()-1; // chamber number
- if (fNch > AliMUONConstants::NCh()-1) {
- cerr<<"AliMUONDigitizer: ERROR: "
- <<"fNch > AliMUONConstants::NCh()-1, fNch, NCh(): "
- <<fNch<<", "<< AliMUONConstants::NCh()<<endl;
- return;
- }
- iChamber = &(pMUON->Chamber(fNch));
-//
-// Loop over pad hits
- for (AliMUONPadHit* mPad =
- (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHits);
- mPad;
- mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHits))
- {
- Int_t cathode = mPad->Cathode(); // cathode number
- Int_t ipx = mPad->PadX(); // pad number on X
- Int_t ipy = mPad->PadY(); // pad number on Y
- Int_t iqpad = Int_t(mPad->QPad()); // charge per pad
- if (cathode != (icat+1)) continue;
-
- fMask = fManager->GetMask(inputFile);
- fDigits[0] = ipx;
- fDigits[1] = ipy;
- fDigits[2] = icat;
- fDigits[3] = iqpad;
- if (inputFile == 0) {
- fDigits[4] = iqpad;
- } else {
- fDigits[4] = 0;
- }
- if (mHit->Particle() == kMuonPlus ||
- mHit->Particle() == kMuonMinus) {
- fDigits[5] = (mPad->HitNumber()) + fMask;
- } else fDigits[5] = -1;
-
- // build the list of fired pads and update the info,
- // fDigits is input for Update(mPad)
-
- if (!Exists(mPad)) {
- CreateNew(mPad);
- } else {
- Update(mPad);
- } // end if Exists(mPad)
- } //end loop over clusters
- } // hit loop
- } // track loop
- } // end file loop
- if (GetDebug()>2) cerr<<"END OF FILE LOOP"<<endl;
-
- Int_t tracks[kMAXTRACKS];
- Int_t charges[kMAXTRACKS];
- Int_t nentries = fTDList->GetEntriesFast();
+// //
+// // Loop over hits
+
+// AliMUONHit* mHit;
+// for(Int_t i = 0; i < fHits->GetEntriesFast(); ++i) {
+
// mHit = static_cast<AliMUONHit*>(fHits->At(i));
+// fNch = mHit->Chamber()-1; // chamber number
+// if (fNch > AliMUONConstants::NCh()-1) {
+// cerr<<"AliMUONDigitizer: ERROR: "
+// <<"fNch > AliMUONConstants::NCh()-1, fNch, NCh(): "
+// <<fNch<<", "<< AliMUONConstants::NCh()<<endl;
+// return;
+// }
+// iChamber = &(pMUON->Chamber(fNch));
+// //
+// // Loop over pad hits
+// for (AliMUONPadHit* mPad =
+// (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHits);
+// mPad;
+// mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHits))
+// {
+// Int_t cathode = mPad->Cathode(); // cathode number
+// Int_t ipx = mPad->PadX(); // pad number on X
+// Int_t ipy = mPad->PadY(); // pad number on Y
+// Int_t iqpad = Int_t(mPad->QPad()); // charge per pad
+// if (cathode != (icat+1)) continue;
+
+// fMask = fManager->GetMask(inputFile);
+// fDigits[0] = ipx;
+// fDigits[1] = ipy;
+// fDigits[2] = icat;
+// fDigits[3] = iqpad;
+// if (inputFile == 0) {
+// fDigits[4] = iqpad;
+// } else {
+// fDigits[4] = 0;
+// }
+// if (mHit->Particle() == kMuonPlus ||
+// mHit->Particle() == kMuonMinus) {
+// fDigits[5] = (mPad->HitNumber()) + fMask;
+// } else fDigits[5] = -1;
+
+// // build the list of fired pads and update the info,
+// // fDigits is input for Update(mPad)
+
+// if (!Exists(mPad)) {
+// CreateNew(mPad);
+// } else {
+// Update(mPad);
+// } // end if Exists(mPad)
+// } //end loop over clusters
+// } // hit loop
+// } // track loop
+// } // end file loop
+// if (GetDebug()>2) cerr<<"END OF FILE LOOP"<<endl;
+
+// Int_t tracks[kMAXTRACKS];
+// Int_t charges[kMAXTRACKS];
+// Int_t nentries = fTDList->GetEntriesFast();
- for (Int_t nent = 0; nent < nentries; nent++) {
- AliMUONTransientDigit *address = (AliMUONTransientDigit*)fTDList->At(nent);
- if (address == 0) continue;
- Int_t ich = address->Chamber();
- Int_t q = address->Signal();
- iChamber = &(pMUON->Chamber(ich));
-//
-// Digit Response (noise, threshold, saturation, ...)
- AliMUONResponse * response = iChamber->ResponseModel();
- q = response->DigitResponse(q,address);
+// for (Int_t nent = 0; nent < nentries; nent++) {
+// AliMUONTransientDigit *address = (AliMUONTransientDigit*)fTDList->At(nent);
+// if (address == 0) continue;
+// Int_t ich = address->Chamber();
+// Int_t q = address->Signal();
+// iChamber = &(pMUON->Chamber(ich));
+// //
+// // Digit Response (noise, threshold, saturation, ...)
+// AliMUONResponse * response = iChamber->ResponseModel();
+// q = response->DigitResponse(q,address);
- if (!q) continue;
+// if (!q) continue;
- fDigits[0] = address->PadX();
- fDigits[1] = address->PadY();
- fDigits[2] = address->Cathode();
- fDigits[3] = q;
- fDigits[4] = address->Physics();
- fDigits[5] = address->Hit();
+// fDigits[0] = address->PadX();
+// fDigits[1] = address->PadY();
+// fDigits[2] = address->Cathode();
+// fDigits[3] = q;
+// fDigits[4] = address->Physics();
+// fDigits[5] = address->Hit();
- Int_t nptracks = address->GetNTracks();
-
- if (nptracks > kMAXTRACKS) {
- if (GetDebug() >0) {
- cerr<<"AliMUONDigitizer: nptracks > 10 "<<nptracks;
- cerr<<"reset to max value "<<kMAXTRACKS<<endl;
- }
- nptracks = kMAXTRACKS;
- }
- if (nptracks > 2 && GetDebug() >2) {
- cerr<<"AliMUONDigitizer: nptracks > 2 "<<nptracks<<endl;
- printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
- }
- for (Int_t tr = 0; tr < nptracks; tr++) {
- tracks[tr] = address->GetTrack(tr);
- charges[tr] = address->GetCharge(tr);
- } //end loop over list of tracks for one pad
- // Sort list of tracks according to charge
- if (nptracks > 1) {
- SortTracks(tracks,charges,nptracks);
- }
- if (nptracks < kMAXTRACKS ) {
- for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
- tracks[i] = 0;
- charges[i] = 0;
- }
- }
+// Int_t nptracks = address->GetNTracks();
+
+// if (nptracks > kMAXTRACKS) {
+// if (GetDebug() >0) {
+// cerr<<"AliMUONDigitizer: nptracks > 10 "<<nptracks;
+// cerr<<"reset to max value "<<kMAXTRACKS<<endl;
+// }
+// nptracks = kMAXTRACKS;
+// }
+// if (nptracks > 2 && GetDebug() >2) {
+// cerr<<"AliMUONDigitizer: nptracks > 2 "<<nptracks<<endl;
+// printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
+// }
+// for (Int_t tr = 0; tr < nptracks; tr++) {
+// tracks[tr] = address->GetTrack(tr);
+// charges[tr] = address->GetCharge(tr);
+// } //end loop over list of tracks for one pad
+// // Sort list of tracks according to charge
+// if (nptracks > 1) {
+// SortTracks(tracks,charges,nptracks);
+// }
+// if (nptracks < kMAXTRACKS ) {
+// for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
+// tracks[i] = 0;
+// charges[i] = 0;
+// }
+// }
- // fill digits
- pMUON->AddDigits(ich,tracks,charges,fDigits);
- }
+// // fill digits
+// pMUON->AddDigits(ich,tracks,charges,fDigits);
+// }
-// fManager->GetTreeD()->Fill();
- ogime->TreeD()->Fill();
+// // fManager->GetTreeD()->Fill();
+// ogime->TreeD()->Fill();
- pMUON->ResetDigits(); //
- fTDList->Clear();
+// pMUON->ResetDigits(); //
+// fTDList->Clear();
- for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
- if (fHitMap[ii]) {
- delete fHitMap[ii];
- fHitMap[ii] = 0;
- }
- }
- } //end loop over cathodes
- if (GetDebug()>2)
- cerr<<"AliMUONDigitizer::Exec: writing the TreeD: "
- << ogime->TreeD()->GetName()<<endl;
+// for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
+// if (fHitMap[ii]) {
+// delete fHitMap[ii];
+// fHitMap[ii] = 0;
+// }
+// }
+// } //end loop over cathodes
+// if (GetDebug()>2)
+// cerr<<"AliMUONDigitizer::Exec: writing the TreeD: "
+// << ogime->TreeD()->GetName()<<endl;
- ogime->WriteDigits("OVERWRITE");
+// ogime->WriteDigits("OVERWRITE");
- delete [] fHitMap;
- delete fTDList;
+// delete [] fHitMap;
+// delete fTDList;
- if (fHits) fHits->Delete();
- if (fPadHits) fPadHits->Delete();
+// if (fHits) fHits->Delete();
+// if (fPadHits) fPadHits->Delete();
}
void SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr);
private:
- TClonesArray *fHits; //! List of hits for one track only
- TClonesArray *fPadHits; //! List of clusters for one track only
+ TClonesArray* fHits;
+ TClonesArray* fPadHits;
AliMUONHitMapA1 **fHitMap; //! pointer to array of pointers to hitmaps
Int_t fNch; //! chamber nr (loop variable)
Int_t fTrack; //! track nr (loop variable)
fHitMap = 0;
fTDList = 0;
fDebug = 0;
- fHits = new TClonesArray("AliMUONHit",1000);
+ // fHits = new TClonesArray("AliMUONHit",1000);
if (GetDebug()>2)
cerr<<"AliMUONDigitizerv1::AliMUONDigitizerv1"
<<"(AliRunDigitizer* manager) was processed"<<endl;
AliMUONDigitizerv1::~AliMUONDigitizerv1()
{
// Destructor
- delete fHits;
+ //delete fHits;
}
//------------------------------------------------------------------------
{
TString optionString = option;
if (optionString.Data() == "deb") {
- cout<<"AliMUONDigitizerv1::Exec: called with option deb "<<endl;
+ Info("Digitize","Called with option deb ");
fDebug = 3;
}
+
AliMUONChamber* chamber;
AliSegmentation* c1Segmentation; //Cathode plane c1 of the chamber
AliSegmentation* c2Segmentation; //Cathode place c2 of the chamber
- if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() starts"<<endl;
+ if (GetDebug()>2) Info("Digitize","AliMUONDigitizerv1::Digitize() starts");
fTDList = new TObjArray;
//Loaders (We assume input0 to be the output too)
AliRunLoader * runloader; // Input loader
AliLoader * gime;
+ // Getting runloader
runloader = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
if (runloader == 0x0) {
- cerr<<"AliMUONDigitizerv1::Digitize() opening file "<<fManager->GetInputFileName(0,0)<<endl;
+ Error("Digitize","RunLoader is not in input file 0");
return; // RunDigitizer is not working.
}
- gime = runloader->GetLoader("MUONLoader");
+ // Getting MUONloader
+ gime = runloader->GetLoader("MUONLoader");
if (gime->TreeH()==0x0) {
- Info("Digitize","TreeH is not loaded yet. Loading...");
+ if (GetDebug()>2) Info("Digitize","TreeH is not loaded yet. Loading...");
gime->LoadHits("READ");
- Info("Digitize","Now treeH is %#x. MUONLoader is %#x",gime->TreeH(),gime);
+ if (GetDebug()>2) Info("Digitize","Now treeH is %#x. MUONLoader is %#x",gime->TreeH(),gime);
}
- if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() loaders"<<endl;
+ if (GetDebug()>2) Info("Digitize","Loaders ready");
- if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+ if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
gAlice = runloader->GetAliRun();
// Getting Module MUON
AliMUON *pMUON = (AliMUON *) gAlice->GetDetector("MUON");
if (!pMUON) {
- cerr<<"AliMUONDigitizerv1::Digitize Error:"
- <<" module MUON not found in the input file"<<endl;
+ Error("Digitize","Module MUON not found in the input file");
return;
- }
+ }
+ // Getting Muon data
+ AliMUONData * muondata = pMUON->GetMUONData();
+ muondata->SetLoader(gime);
+ muondata->SetTreeAddress("H");
// Loading Event
Int_t currentevent = fManager->GetOutputEventNr();
(Int_t(TMath::Log10(currentevent)) == TMath::Log10(currentevent) ) )
cout <<"ALiMUONDigitizerv1::Digitize() Event Number is "<< currentevent <<endl;
- // Output file for digits
- AliRunLoader * runloaderout = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
- AliLoader * gimeout = runloaderout->GetLoader("MUONLoader");
+ // Output file for digits same as hits
+ // AliRunLoader * runloaderout = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+ //AliLoader * gimeout = runloaderout->GetLoader("MUONLoader");
// New branch per chamber for MUON digit in the tree of digits
- if (gime->TreeD() == 0x0) gimeout->MakeDigitsContainer();
- TTree* treeD = gimeout->TreeD();
- pMUON->MakeBranchInTreeD(treeD);
+ if (gime->TreeD() == 0x0) gime->MakeDigitsContainer();
+ TTree* treeD = gime->TreeD();
+ muondata->MakeBranch("D");
+ muondata->SetTreeAddress("D");
// Array of pointer of the AliMUONHitMapA1:
// two HitMaps per chamber, or one HitMap per cahtode plane
for (Int_t inputFile=0; inputFile<fManager->GetNinputs(); inputFile++) {
if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() Input File is "<<inputFile<<endl;
- // Hits Branch
- TBranch *branchHits = 0;
// Connect MUON Hit branch
if (inputFile > 0 ) {
}
gime = runloader->GetLoader("MUONLoader");
if (gime->TreeH() == 0x0) gime->LoadHits("READ");
+ muondata->SetLoader(gime);
+ muondata->SetTreeAddress("H");
}
- // Setting the address of fHits list
+ // Setting the address
TTree *treeH = gime->TreeH();
if (treeH == 0x0) {
Error("Digitize","Can not get TreeH from input %d",inputFile);
}
if (GetDebug()>2) {
cerr<<"AliMUONDigitizerv1::Exec inputFile is "<<inputFile<<" "<<endl;
- cerr<<"AliMUONDigitizerv1::Exec treeH, fHits "<<treeH<<" "<<fHits<<endl;
+ cerr<<"AliMUONDigitizerv1::Exec treeH" << treeH <<endl;
}
- if (treeH && fHits) {
- branchHits = treeH->GetBranch("MUON");
- if (branchHits) {
- fHits->Clear();
- branchHits->SetAddress(&fHits);
- }
- else
- Error("Exec","branch MUON was not found");
- }
- if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Exec branchHits = "<<branchHits<<endl;
-
+
+ if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Exec Setting tree addresses"<<endl;
fMask = fManager->GetMask(inputFile);
//
Int_t ntracks = (Int_t) treeH->GetEntries();
for (itrack = 0; itrack < ntracks; itrack++) {
if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Exec itrack = "<<itrack<<endl;
- fHits->Clear();
+ muondata->ResetHits();
treeH->GetEvent(itrack);
//
// Loop over hits
Int_t ihit, ichamber;
AliMUONHit* mHit;
- for(ihit = 0; ihit < fHits->GetEntriesFast(); ihit++) {
- mHit = static_cast<AliMUONHit*>(fHits->At(ihit));
+ TClonesArray* hits = muondata->Hits();
+ for(ihit = 0; ihit < hits->GetEntriesFast(); ihit++) {
+ mHit = static_cast<AliMUONHit*>(hits->At(ihit));
ichamber = mHit->Chamber()-1; // chamber number
if (ichamber > AliMUONConstants::NCh()-1) {
cerr<<"AliMUONDigitizer: ERROR: "
}
}
- // fill digits
+ // Add digits
if (GetDebug()>3) cerr<<"AliMUONDigitzerv1::Exex TransientDigit to Digit"<<endl;
- if ( digits[2] == icat ) pMUON->AddDigits(ich,tracks,charges,digits);
+ if ( digits[2] == icat ) muondata->AddDigit(ich,tracks,charges,digits);
}
// Filling list of digits per chamber for a given cathode.
treeD->Fill();
- pMUON->ResetDigits();
+ muondata->ResetDigits();
} // end loop cathode
fTDList->Delete();
cerr<<"AliMUONDigitizer::Exec: writing the TreeD: "
<<treeD->GetName()<<endl;
- gimeout->WriteDigits("OVERWRITE");
+ gime->WriteDigits("OVERWRITE");
delete [] fHitMap;
delete fTDList;
- if (fHits) fHits->Clear();
+ muondata->ResetHits();
}
//------------------------------------------------------------------------
void SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr);
private:
- TClonesArray * fHits; // List of Hits
AliMUONHitMapA1 **fHitMap; //! pointer to array of pointers to hitmaps
TObjArray *fTDList; //! list of AliMUONTransientDigits
Int_t fTDCounter; //! nr. of AliMUONTransientDigits
AliSegmentation* segmentation;
AliMUONResponse* response;
- TClonesArray *muonDigits = pMUON->DigitsAddress(chamber-1);
+ TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
if (muonDigits == 0) return;
// gAlice->ResetDigits();
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONChamber* iChamber;
- TClonesArray *muonRawClusters = pMUON->RawClustAddress(chamber-1);
+ TClonesArray *muonRawClusters = pMUON->GetMUONData()->RawClusters(chamber-1);
if (muonRawClusters == 0) return;
// pMUON->ResetRawClusters();
// index of first HitForRec for the chamber
if (ch == 0) fIndexOfFirstHitForRecPerChamber[ch] = 0;
else fIndexOfFirstHitForRecPerChamber[ch] = fNHitsForRec;
- rawclusters = pMUON->RawClustAddress(ch);
+ rawclusters = pMUON->GetMUONData()->RawClusters(ch);
// pMUON->ResetRawClusters();
// TR->GetEvent((Int_t) (TR->GetEntries()) - 1); // to be checked ????
nclus = (Int_t) (rawclusters->GetEntries());
// keep galice.root for signal and name differently the file for
// background when add! otherwise the track info for signal will be lost !
-
- AliMUONChamber* iChamber;
- AliSegmentation* segmentation;
-
- fList = new TObjArray;
-
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- fHitMap= new AliHitMap* [AliMUONConstants::NCh()];
- if (fMerge ) {
- fBgrFile->cd();
- //
- // Get Hits Tree header from file
- //if(fHitsBgr) fHitsBgr->Clear(); // Useless because line 327
- //if(fPadHitsBgr) fPadHitsBgr->Clear(); // Useless because line 328
- if(fTrH1) delete fTrH1;
- fTrH1 = 0;
+ // Obsolete sep 2003 Gines MARTINEZ
+ // AliMUONChamber* iChamber;
+// AliSegmentation* segmentation;
+
+// fList = new TObjArray;
+
+// AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
+// fHitMap= new AliHitMap* [AliMUONConstants::NCh()];
+// if (fMerge ) {
+// fBgrFile->cd();
+// //
+// // Get Hits Tree header from file
+// //if(fHitsBgr) fHitsBgr->Clear(); // Useless because line 327
+// //if(fPadHitsBgr) fPadHitsBgr->Clear(); // Useless because line 328
+// if(fTrH1) delete fTrH1;
+// fTrH1 = 0;
- char treeName[20];
- sprintf(treeName,"TreeH%d",fEvNrBgr);
- fTrH1 = (TTree*)gDirectory->Get(treeName);
- if (!fTrH1) {
- printf("ERROR: cannot find Hits Tree for event:%d\n",fEvNrBgr);
- }
- //
- // Set branch addresses
- TBranch *branch;
- char branchname[20];
- sprintf(branchname,"%s",pMUON->GetName());
- if (fTrH1 && fHitsBgr) {
- branch = fTrH1->GetBranch(branchname);
- if (branch) branch->SetAddress(&fHitsBgr);
- }
- if (fTrH1 && fPadHitsBgr) {
- branch = fTrH1->GetBranch("MUONCluster");
- if (branch) branch->SetAddress(&fPadHitsBgr);
- }
- }
- //
- // loop over cathodes
- //
- fSignal = kTRUE;
- for (int icat = 0; icat < 2; icat++) {
- fCounter = 0;
- for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
- iChamber = &(pMUON->Chamber(i));
- if (iChamber->Nsec() == 1 && icat == 1) {
- continue;
- } else {
- segmentation = iChamber->SegmentationModel(icat+1);
- }
- fHitMap[i] = new AliMUONHitMapA1(segmentation, fList);
- }
-
-//
-// Loop over tracks
-//
-
-/******************************************************************/
- TTree* treeH = pMUON->TreeH();
- if (treeH == 0x0)
- {
- cerr<<"AliMUONMerger::Exec: Can not get TreeH"<<endl;
- return;
- }
-/******************************************************************/
+// char treeName[20];
+// sprintf(treeName,"TreeH%d",fEvNrBgr);
+// fTrH1 = (TTree*)gDirectory->Get(treeName);
+// if (!fTrH1) {
+// printf("ERROR: cannot find Hits Tree for event:%d\n",fEvNrBgr);
+// }
+// //
+// // Set branch addresses
+// TBranch *branch;
+// char branchname[20];
+// sprintf(branchname,"%s",pMUON->GetName());
+// if (fTrH1 && fHitsBgr) {
+// branch = fTrH1->GetBranch(branchname);
+// if (branch) branch->SetAddress(&fHitsBgr);
+// }
+// if (fTrH1 && fPadHitsBgr) {
+// branch = fTrH1->GetBranch("MUONCluster");
+// if (branch) branch->SetAddress(&fPadHitsBgr);
+// }
+// }
+// //
+// // loop over cathodes
+// //
+// fSignal = kTRUE;
+// for (int icat = 0; icat < 2; icat++) {
+// fCounter = 0;
+// for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
+// iChamber = &(pMUON->Chamber(i));
+// if (iChamber->Nsec() == 1 && icat == 1) {
+// continue;
+// } else {
+// segmentation = iChamber->SegmentationModel(icat+1);
+// }
+// fHitMap[i] = new AliMUONHitMapA1(segmentation, fList);
+// }
+
+// //
+// // Loop over tracks
+// //
+
+// /******************************************************************/
+// TTree* treeH = pMUON->TreeH();
+// if (treeH == 0x0)
+// {
+// cerr<<"AliMUONMerger::Exec: Can not get TreeH"<<endl;
+// return;
+// }
+// /******************************************************************/
- Int_t ntracks = (Int_t) treeH->GetEntries();
- treeH->SetBranchStatus("*",0); // switch off all branches
- treeH->SetBranchStatus("MUON*",1); // switch on only MUON
-
- for (fTrack = 0; fTrack < ntracks; fTrack++) {
- gAlice->ResetHits();
- treeH->GetEntry(fTrack,0);
-//
-// Loop over hits
- for(AliMUONHit* mHit = (AliMUONHit*)pMUON->FirstHit(-1);
- mHit;
- mHit = (AliMUONHit*)pMUON->NextHit())
- {
- fNch = mHit->Chamber()-1; // chamber number
- if (fNch > AliMUONConstants::NCh()-1) continue;
- iChamber = &(pMUON->Chamber(fNch));
+// Int_t ntracks = (Int_t) treeH->GetEntries();
+// treeH->SetBranchStatus("*",0); // switch off all branches
+// treeH->SetBranchStatus("MUON*",1); // switch on only MUON
+
+// for (fTrack = 0; fTrack < ntracks; fTrack++) {
+// gAlice->ResetHits();
+// treeH->GetEntry(fTrack,0);
+// //
+// // Loop over hits
+// for(AliMUONHit* mHit = (AliMUONHit*)pMUON->FirstHit(-1);
+// mHit;
+// mHit = (AliMUONHit*)pMUON->NextHit())
+// {
+// fNch = mHit->Chamber()-1; // chamber number
+// if (fNch > AliMUONConstants::NCh()-1) continue;
+// iChamber = &(pMUON->Chamber(fNch));
-//
-// Loop over pad hits
- for (AliMUONPadHit* mPad =
- (AliMUONPadHit*)pMUON->FirstPad(mHit,pMUON->PadHits());
- mPad;
- mPad = (AliMUONPadHit*)pMUON->NextPad(pMUON->PadHits()))
- {
- Int_t cathode = mPad->Cathode(); // cathode number
- if (cathode != (icat+1)) continue;
- Int_t iqpad = Int_t(mPad->QPad()); // charge per pad
-// segmentation = iChamber->SegmentationModel(cathode);
- fDigits[0] = mPad->PadX();
- fDigits[1] = mPad->PadY();
- if (!(fHitMap[fNch]->ValidateHit(fDigits[0], fDigits[1]))) continue;
- fDigits[2] = icat;
- fDigits[3] = iqpad;
- fDigits[4] = iqpad;
- if (mHit->Particle() == kMuonPlus ||
- mHit->Particle() == kMuonMinus) {
- fDigits[5] = mPad->HitNumber();
- } else fDigits[5] = -1;
-
- // build the list of fired pads and update the info
-
- if (!Exists(mPad)) {
- CreateNew(mPad);
- } else {
- Update(mPad);
- } // end if pdigit
- } //end loop over clusters
- } // hit loop
- } // track loop
-
- // open the file with background
+// //
+// // Loop over pad hits
+// for (AliMUONPadHit* mPad =
+// (AliMUONPadHit*)pMUON->FirstPad(mHit,pMUON->PadHits());
+// mPad;
+// mPad = (AliMUONPadHit*)pMUON->NextPad(pMUON->PadHits()))
+// {
+// Int_t cathode = mPad->Cathode(); // cathode number
+// if (cathode != (icat+1)) continue;
+// Int_t iqpad = Int_t(mPad->QPad()); // charge per pad
+// // segmentation = iChamber->SegmentationModel(cathode);
+// fDigits[0] = mPad->PadX();
+// fDigits[1] = mPad->PadY();
+// if (!(fHitMap[fNch]->ValidateHit(fDigits[0], fDigits[1]))) continue;
+// fDigits[2] = icat;
+// fDigits[3] = iqpad;
+// fDigits[4] = iqpad;
+// if (mHit->Particle() == kMuonPlus ||
+// mHit->Particle() == kMuonMinus) {
+// fDigits[5] = mPad->HitNumber();
+// } else fDigits[5] = -1;
+
+// // build the list of fired pads and update the info
+
+// if (!Exists(mPad)) {
+// CreateNew(mPad);
+// } else {
+// Update(mPad);
+// } // end if pdigit
+// } //end loop over clusters
+// } // hit loop
+// } // track loop
+
+// // open the file with background
- if (fMerge) {
- fSignal = kFALSE;
- ntracks = (Int_t)fTrH1->GetEntries();
-//
-// Loop over tracks
-//
- for (fTrack = 0; fTrack < ntracks; fTrack++) {
-
- if (fHitsBgr) fHitsBgr->Clear();
- if (fPadHitsBgr) fPadHitsBgr->Clear();
-
- fTrH1->GetEvent(fTrack);
-//
-// Loop over hits
- AliMUONHit* mHit;
- for(Int_t i = 0; i < fHitsBgr->GetEntriesFast(); ++i)
- {
- mHit = (AliMUONHit*) (*fHitsBgr)[i];
- fNch = mHit->Chamber()-1; // chamber number
- iChamber = &(pMUON->Chamber(fNch));
-//
-// Loop over pad hits
- for (AliMUONPadHit* mPad =
- (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHitsBgr);
- mPad;
- mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHitsBgr))
- {
- Int_t cathode = mPad->Cathode(); // cathode number
- Int_t ipx = mPad->PadX(); // pad number on X
- Int_t ipy = mPad->PadY(); // pad number on Y
- Int_t iqpad = Int_t(mPad->QPad()); // charge per pad
- if (!(fHitMap[fNch]->ValidateHit(ipx, ipy))) continue;
-
- if (cathode != (icat+1)) continue;
- fDigits[0] = ipx;
- fDigits[1] = ipy;
- fDigits[2] = icat;
- fDigits[3] = iqpad;
- fDigits[4] = 0;
- fDigits[5] = -1;
+// if (fMerge) {
+// fSignal = kFALSE;
+// ntracks = (Int_t)fTrH1->GetEntries();
+// //
+// // Loop over tracks
+// //
+// for (fTrack = 0; fTrack < ntracks; fTrack++) {
+
+// if (fHitsBgr) fHitsBgr->Clear();
+// if (fPadHitsBgr) fPadHitsBgr->Clear();
+
+// fTrH1->GetEvent(fTrack);
+// //
+// // Loop over hits
+// AliMUONHit* mHit;
+// for(Int_t i = 0; i < fHitsBgr->GetEntriesFast(); ++i)
+// {
+// mHit = (AliMUONHit*) (*fHitsBgr)[i];
+// fNch = mHit->Chamber()-1; // chamber number
+// iChamber = &(pMUON->Chamber(fNch));
+// //
+// // Loop over pad hits
+// for (AliMUONPadHit* mPad =
+// (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHitsBgr);
+// mPad;
+// mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHitsBgr))
+// {
+// Int_t cathode = mPad->Cathode(); // cathode number
+// Int_t ipx = mPad->PadX(); // pad number on X
+// Int_t ipy = mPad->PadY(); // pad number on Y
+// Int_t iqpad = Int_t(mPad->QPad()); // charge per pad
+// if (!(fHitMap[fNch]->ValidateHit(ipx, ipy))) continue;
+
+// if (cathode != (icat+1)) continue;
+// fDigits[0] = ipx;
+// fDigits[1] = ipy;
+// fDigits[2] = icat;
+// fDigits[3] = iqpad;
+// fDigits[4] = 0;
+// fDigits[5] = -1;
- // build the list of fired pads and update the info
- if (!Exists(mPad)) {
- CreateNew(mPad);
- } else {
- Update(mPad);
- } // end if !Exists
- } //end loop over clusters
- } // hit loop
- } // track loop
-
- TTree *treeK = gAlice->TreeK();
- TFile *file = NULL;
+// // build the list of fired pads and update the info
+// if (!Exists(mPad)) {
+// CreateNew(mPad);
+// } else {
+// Update(mPad);
+// } // end if !Exists
+// } //end loop over clusters
+// } // hit loop
+// } // track loop
+
+// TTree *treeK = gAlice->TreeK();
+// TFile *file = NULL;
- if (treeK) file = treeK->GetCurrentFile();
- file->cd();
- } // if fMerge
+// if (treeK) file = treeK->GetCurrentFile();
+// file->cd();
+// } // if fMerge
- Int_t tracks[kMAXTRACKS];
- Int_t charges[kMAXTRACKS];
- Int_t nentries = fList->GetEntriesFast();
+// Int_t tracks[kMAXTRACKS];
+// Int_t charges[kMAXTRACKS];
+// Int_t nentries = fList->GetEntriesFast();
- for (Int_t nent = 0; nent < nentries; nent++) {
- AliMUONTransientDigit *address = (AliMUONTransientDigit*)fList->At(nent);
- if (address == 0) continue;
- Int_t ich = address->Chamber();
- Int_t q = address->Signal();
- iChamber = &(pMUON->Chamber(ich));
-//
-// Digit Response (noise, threshold, saturation, ...)
- AliMUONResponse * response = iChamber->ResponseModel();
- q = response->DigitResponse(q,address);
+// for (Int_t nent = 0; nent < nentries; nent++) {
+// AliMUONTransientDigit *address = (AliMUONTransientDigit*)fList->At(nent);
+// if (address == 0) continue;
+// Int_t ich = address->Chamber();
+// Int_t q = address->Signal();
+// iChamber = &(pMUON->Chamber(ich));
+// //
+// // Digit Response (noise, threshold, saturation, ...)
+// AliMUONResponse * response = iChamber->ResponseModel();
+// q = response->DigitResponse(q,address);
- if (!q) continue;
+// if (!q) continue;
- fDigits[0] = address->PadX();
- fDigits[1] = address->PadY();
- fDigits[2] = address->Cathode();
- fDigits[3] = q;
- fDigits[4] = address->Physics();
- fDigits[5] = address->Hit();
+// fDigits[0] = address->PadX();
+// fDigits[1] = address->PadY();
+// fDigits[2] = address->Cathode();
+// fDigits[3] = q;
+// fDigits[4] = address->Physics();
+// fDigits[5] = address->Hit();
- Int_t nptracks = address->GetNTracks();
-
- if (nptracks > kMAXTRACKS) {
- if (fDebug>0)
- printf("\n Attention - nptracks > kMAXTRACKS %d \n", nptracks);
- nptracks = kMAXTRACKS;
- }
- if (nptracks > 2) {
- if (fDebug>0) {
- printf("Attention - nptracks > 2 %d \n",nptracks);
- printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
- }
- }
- for (Int_t tr = 0; tr < nptracks; tr++) {
- tracks[tr] = address->GetTrack(tr);
- charges[tr] = address->GetCharge(tr);
- } //end loop over list of tracks for one pad
- // Sort list of tracks according to charge
- if (nptracks > 1) {
- SortTracks(tracks,charges,nptracks);
- }
- if (nptracks < kMAXTRACKS ) {
- for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
- tracks[i] = 0;
- charges[i] = 0;
- }
- }
+// Int_t nptracks = address->GetNTracks();
+
+// if (nptracks > kMAXTRACKS) {
+// if (fDebug>0)
+// printf("\n Attention - nptracks > kMAXTRACKS %d \n", nptracks);
+// nptracks = kMAXTRACKS;
+// }
+// if (nptracks > 2) {
+// if (fDebug>0) {
+// printf("Attention - nptracks > 2 %d \n",nptracks);
+// printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
+// }
+// }
+// for (Int_t tr = 0; tr < nptracks; tr++) {
+// tracks[tr] = address->GetTrack(tr);
+// charges[tr] = address->GetCharge(tr);
+// } //end loop over list of tracks for one pad
+// // Sort list of tracks according to charge
+// if (nptracks > 1) {
+// SortTracks(tracks,charges,nptracks);
+// }
+// if (nptracks < kMAXTRACKS ) {
+// for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
+// tracks[i] = 0;
+// charges[i] = 0;
+// }
+// }
- // fill digits
- pMUON->AddDigits(ich,tracks,charges,fDigits);
- }
- gAlice->TreeD()->Fill();
- pMUON->ResetDigits();
- fList->Delete();
+// // fill digits
+// pMUON->AddDigits(ich,tracks,charges,fDigits);
+// }
+// gAlice->TreeD()->Fill();
+// pMUON->ResetDigits();
+// fList->Delete();
- for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
- if (fHitMap[ii]) {
- delete fHitMap[ii];
- fHitMap[ii] = 0;
- }
- }
- } //end loop over cathodes
- delete [] fHitMap;
- delete fList;
+// for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
+// if (fHitMap[ii]) {
+// delete fHitMap[ii];
+// fHitMap[ii] = 0;
+// }
+// }
+// } //end loop over cathodes
+// delete [] fHitMap;
+// delete fList;
// no need to delete ... and it makes a crash also
// if (fHitsBgr) fHitsBgr->Delete();
Int_t cathode=display->GetCathode();
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
- TClonesArray *muonDigits = pMUON->DigitsAddress(chamber-1);
+ TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
gAlice->TreeD()->GetEvent(nent-2+cathode-1);
//gAlice->TreeD()->GetEvent(cathode);
}
-Float_t AliMUONSegmentationSlatModuleN::Dpx(Int_t isec) const
+Float_t AliMUONSegmentationSlatModuleN::Dpx(Int_t /*isec*/) const
{
//
// Returns x-pad size for given sector isec
// from raw clusters
for (Int_t i=0; i<2; i++) {
hit1 = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i]);
- rawclusters = fgMUON->RawClustAddress(hit1->GetChamberNumber());
+ rawclusters = fgMUON->GetMUONData()->RawClusters(hit1->GetChamberNumber());
clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit1->GetHitNumber());
cout << clus->fTracks[1]-1;
if (clus->fTracks[2] != 0) cout << " " << clus->fTracks[2]-1;
// from raw clusters
for (Int_t i1=0; i1<fNTrackHits; i1++) {
hit = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
- rawclusters = fgMUON->RawClustAddress(hit->GetChamberNumber());
+ rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
printf ("%4d", clus->fTracks[1] - 1);
//cout << clus->fTracks[1] - 1 << " ";
cout << endl;
for (Int_t i1=0; i1<fNTrackHits; i1++) {
hit = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
- rawclusters = fgMUON->RawClustAddress(hit->GetChamberNumber());
+ rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
if (clus->fTracks[2] != 0) printf ("%4d", clus->fTracks[2] - 1);
else printf ("%4s", " ");
AliMUONChamber* iChamber = &(pMUON->Chamber(chamber-1));
AliSegmentation* segmentation;
gime->TreeD()->GetEvent(cathode-1);
- TClonesArray *muonDigits = pMUON->DigitsAddress(chamber-1);
+ TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
Int_t ndigits = muonDigits->GetEntriesFast();
// printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
// if (ndigits == 0) return;
destep = gMC->Edep();
step = gMC->TrackStep();
//new hit
- AddHit(fIshunt, gAlice->GetCurrentTrackNumber(), iChamber, ipart,
- pos.X(), pos.Y(), pos.Z(), tof, mom.P(),
- theta, phi, step, destep);
+
+ GetMUONData()->AddHit(fIshunt, gAlice->GetCurrentTrackNumber(), iChamber, ipart,
+ pos.X(), pos.Y(), pos.Z(), tof, mom.P(),
+ theta, phi, step, destep);
}
// Track left chamber ...
if( gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared()){
hits[3] = pos[2]+s*tz; // Z-position for hit
hits[4] = theta; // theta angle of incidence
hits[5] = phi; // phi angle of incidence
- hits[8] = (Float_t) fNPadHits; // first padhit
+ hits[8] = 0;//PadHits does not exist anymore (Float_t) fNPadHits; // first padhit
hits[9] = -1; // last pad hit
hits[10] = mom[3]; // hit momentum P
hits[11] = mom[0]; // Px
}
- if (eloss >0) MakePadHits(x0,y0,z0,eloss,tof,idvol);
+ // if (eloss >0) MakePadHits(x0,y0,z0,eloss,tof,idvol);
hits[6] = tlength; // track length
hits[7] = eloss2; // de/dx energy loss
- if (fNPadHits > (Int_t)hits[8]) {
- hits[8] = hits[8]+1;
- hits[9] = (Float_t) fNPadHits;
- }
+ // if (fNPadHits > (Int_t)hits[8]) {
+ // hits[8] = hits[8]+1;
+ // hits[9] = 0: // PadHits does not exist anymore (Float_t) fNPadHits;
+ //}
//
// new hit
eloss += destep;
- if (eloss > 0 && idvol < AliMUONConstants::NTrackingCh())
- MakePadHits(0.5*(xhit+pos[0]),0.5*(yhit+pos[1]),pos[2],eloss,tof,idvol);
+ // if (eloss > 0 && idvol < AliMUONConstants::NTrackingCh())
+ // MakePadHits(0.5*(xhit+pos[0]),0.5*(yhit+pos[1]),pos[2],eloss,tof,idvol);
xhit = pos[0];
yhit = pos[1];
zhit = pos[2];
// MUON includes
#include "AliMUON.h"
+#include "AliMUONData.h"
#include "AliMUONHit.h"
#include "AliMUONConstants.h"
#include "AliMUONDigit.h"
void MUONhits(char * filename="galice.root")
{
- // List of Hits per event and per track
- TClonesArray * ListOfHits = new TClonesArray("AliMUONHit",1000);
-
// Creating Run Loader and openning file containing Hits
AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
if (RunLoader ==0x0) {
// Loading MUON subsystem
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
MUONLoader->LoadHits("READ");
+ // Creating MUON data container
+ AliMUONData muondata(MUONLoader,"MUON","MUON");
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
// Getting event ievent
RunLoader->GetEvent(ievent);
- MUONLoader->TreeH()->GetBranch("MUON")->SetAddress(&ListOfHits);
-
+ muondata.SetTreeAddress("H");
+
Int_t itrack, ntracks;
ntracks = (Int_t) (MUONLoader->TreeH())->GetEntries();
for (itrack=0; itrack<ntracks; itrack++) { // Track loop
(MUONLoader->TreeH())->GetEvent(itrack);
Int_t ihit, nhits;
- nhits = (Int_t) ListOfHits->GetEntriesFast();
+ nhits = (Int_t) muondata.Hits()->GetEntriesFast();
printf(">>> Number of hits %d \n",nhits);
AliMUONHit* mHit;
for(ihit=0; ihit<nhits; ihit++) {
- mHit = static_cast<AliMUONHit*>(ListOfHits->At(ihit));
+ mHit = static_cast<AliMUONHit*>(muondata.Hits()->At(ihit));
Int_t Nch = mHit->Chamber(); // chamber number
Int_t hittrack = mHit->Track();
Float_t x = mHit->X();
printf(">>> Hit %2d Chamber %2d Track %4d x %6.3f y %6.3f z %7.3f elos %g theta %6.3f phi %5.3f momentum %5.3f\n",
ihit, Nch,hittrack,x,y,z,elos,theta,phi, momentum);
}
- ListOfHits->Clear();
+ muondata.ResetHits();
} // end track loop
} // end event loop
MUONLoader->UnloadHits();
void MUONdigits(char * filename="galice.root")
{
- TClonesArray * ListOfDigits;
-
// Creating Run Loader and openning file containing Hits
AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
if (RunLoader ==0x0) {
printf(">>> Error : Error Opening %s file \n",filename);
return;
}
-
- // Loading AliRun master
- RunLoader->LoadgAlice();
- gAlice = RunLoader->GetAliRun();
- // Getting Module MUON
- AliMUON *pMUON = (AliMUON *) gAlice->GetDetector("MUON");
-
+ // 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();
// Addressing
Int_t ichamber, nchambers;
nchambers = AliMUONConstants::NCh(); ;
- pMUON->SetTreeAddress();
+ muondata.SetTreeAddress("D");
char branchname[30];
- //for( ichamber=0; ichamber<nchambers; ichamber++) {
- // sprintf(branchname,"MUONDigits%d",ichamber+1);
- //(MUONLoader->TreeD()->GetBranch(branchname))->SetAddress(&((*pMUON->Dchambers())[ichamber]));
- //}
-
-
+
Int_t icathode, ncathodes;
ncathodes=2;
//Loop on cathodes
printf(">>> Chamber %d\n",ichamber);
// sprintf(branchname,"MUONDigits%d",ichamber+1);
//printf(">>> branchname %s\n",branchname);
- ListOfDigits = (TClonesArray *) pMUON->Dchambers()->At(ichamber);
Int_t idigit, ndigits;
- ndigits = (Int_t) ListOfDigits->GetEntriesFast();
+ ndigits = (Int_t) muondata.Digits(ichamber,0)->GetEntriesFast();
for(idigit=0; idigit<ndigits; idigit++) {
- mDigit = static_cast<AliMUONDigit*>(ListOfDigits->At(idigit));
+ mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber,0)->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
printf(">>> Digit %4d cathode %1d hit %4d PadX %3d PadY %3d Signal %4d Track0 %4d Track1 %'d Track2 %4d \n",idigit, Cathode,Hit, PadX, PadY, Signal, Track0, Track1, Track2);
} // end digit loop
} // end chamber loop
+ muondata.ResetDigits();
} // end cathode loop
} // end event loop
MUONLoader->UnloadDigits();
void MUONrecpoints(char * filename="galice.root") {
- TClonesArray * ListOfRecPoints;
-
// Creating Run Loader and openning file containing Hits
AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
if (RunLoader ==0x0) {
printf(">>> Error : Error Opening %s file \n",filename);
return;
}
-
- // Loading AliRun master
- RunLoader->LoadgAlice();
- gAlice = RunLoader->GetAliRun();
- // Getting Module MUON
- AliMUON *pMUON = (AliMUON *) gAlice->GetDetector("MUON");
-
+ // Getting MUONloader
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
MUONLoader->LoadRecPoints("READ");
+ // Creating MUON data container
+ AliMUONData muondata(MUONLoader,"MUON","MUON");
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();
- pMUON->SetTreeAddress();
+ muondata.SetTreeAddress("RC");
char branchname[30];
-
MUONLoader->TreeR()->GetEvent(0);
// Loop on chambers
for( ichamber=0; ichamber<nchambers; ichamber++) {
printf(">>> Chamber %d\n",ichamber);
sprintf(branchname,"MUONRawClusters%d",ichamber+1);
//printf(">>> branchname %s\n",branchname);
- ListOfRecPoints = (TClonesArray *) pMUON->RawClusters()->At(ichamber);
-
+
Int_t irecpoint, nrecpoints;
- nrecpoints = (Int_t) ListOfRecPoints->GetEntriesFast();
+ nrecpoints = (Int_t) muondata.RawClusters(ichamber)->GetEntriesFast();
for(irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
- mRecPoint = static_cast<AliMUONRawCluster*>(ListOfRecPoints->At(irecpoint));
+ mRecPoint = static_cast<AliMUONRawCluster*>(muondata.RawClusters(ichamber)->At(irecpoint));
// Int_t fTracks[3]; //labels of overlapped tracks
// Int_t fQ[2] ; // Q of cluster (in ADC counts)
// Float_t fX[2] ; // X of cluster
irecpoint, x0, x1, y0, y1, z0, z1, Q0, Q1, Track0, Track1, Track2, chi2_0, chi2_1);
} // end recpoint loop
} // end chamber loop
+ muondata.ResetRawClusters();
} // end event loop
MUONLoader->UnloadRecPoints();
}
return;
}
- // Loading AliRun master
- RunLoader->LoadgAlice();
- gAlice = RunLoader->GetAliRun();
- // Getting Module MUON
- AliMUON *pMUON = (AliMUON *) gAlice->GetDetector("MUON");
-
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
MUONLoader->LoadRecPoints("READ");
+ // Creating MUON data container
+ AliMUONData muondata(MUONLoader,"MUON","MUON");
+
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
for (ievent=0; ievent<nevents; ievent++) {
RunLoader->GetEvent(ievent);
- pMUON->SetTreeAddress();
+ muondata.SetTreeAddress("GLT");
MUONLoader->TreeR()->GetEvent(0);
- globalTrigger = (TClonesArray *) pMUON->GlobalTrigger();
- localTrigger = (TClonesArray *) pMUON->LocalTrigger();
+ globalTrigger = muondata.GlobalTrigger();
+ localTrigger = muondata.LocalTrigger();
Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
Int_t nlocals = (Int_t) localTrigger->GetEntriesFast(); // up to 234
<< locTrg->LoApt() << "\n";
} // end of loop on Local Trigger
+ muondata.ResetTrigger();
} // end loop on event
}
#pragma link C++ class AliMUON+;
#pragma link C++ class AliMUONv0+;
#pragma link C++ class AliMUONv1+;
+#pragma link C++ class AliMUONData+;
#pragma link C++ class AliMUONLoader+;
#pragma link C++ class AliMUONHit+;
#pragma link C++ class AliMUONPadHit+;
// Loading MUON subsystem
AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
+ AliMUONData * muondata = MUON->GetMUONData();
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
RunLoader->GetEvent(ievent);
MUONLoader->LoadDigits("read");
if (MUONLoader->TreeR() == 0x0) MUONLoader->MakeTree("R");
- MUON->MakeBranch("R");
- MUON->SetTreeAddress();
+ muondata->MakeBranch("RC");
+ muondata->SetTreeAddress("D,RC");
MUON->Digits2Reco();
MUONLoader->UnloadDigits();
MUONLoader->UnloadRecPoints();
AliMUONRecoEvent.cxx AliMUONRecoDisplay.cxx \
AliMUONMerger.cxx AliMUONFactory.cxx AliMUONDigitizer.cxx AliMUONDigitizerv1.cxx \
AliMUONTrackK.cxx AliMUONClusterFinderAZ.cxx AliMUONPixel.cxx \
- AliMUONLoader.cxx
+ AliMUONLoader.cxx AliMUONData.cxx
SRCS += AliMUONv2.cxx AliMUONSt1Segmentation.cxx AliMUONSt1Response.cxx \
AliMUONSt1ElectronicElement.cxx AliMUONSt1SpecialMotif.cxx \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff