Xref,Yref,Zref, true);
}
//____________________________________________________________________________
-void AliMUONData::AddLocalTrigger(Int_t *localtr)
+void AliMUONData::AddLocalTrigger(const Int_t *localtr, const TArrayI& digits)
{
// add a MUON Local Trigger to the list
TClonesArray &localTrigger = *fLocalTrigger;
- new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(localtr);
+ new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(localtr, digits);
}
//____________________________________________________________________________
void AliMUONData::AddLocalTrigger(const AliMUONLocalTrigger& trigger)
//
#include <TNamed.h>
+#include <TArrayI.h>
#include "AliLoader.h"
Int_t *pairLike);
virtual void AddGlobalTrigger(const AliMUONGlobalTrigger& trigger); // use copy constructor
- virtual void AddLocalTrigger(Int_t* ltrigger);
+ virtual void AddLocalTrigger(const Int_t* ltrigger, const TArrayI& digits);
virtual void AddLocalTrigger(const AliMUONLocalTrigger& trigger); // use copy constructor
virtual void AddRawCluster(Int_t id, const AliMUONRawCluster& clust);
if ( ! FetchLoaders(filename, foldername) ) return -1;
if ( ! FetchEvent(event) ) return -1;
- if ( ! FetchTreeR() ) return -1;
+ if ( ! FetchTreeD() ) return -1;
if ( ! fTriggerAddressSet )
{
- // If the local trigger address in TreeR is not set yet then set it now.
+ // If the local trigger address in TreeD is not set yet then set it now.
fData.SetTreeAddress("GLT");
fData.ResetTrigger();
- fData.GetTrigger();
+ fData.GetTriggerD();
fTriggerAddressSet = kTRUE;
}
return fData.LocalTrigger()->GetEntriesFast();
if ( ! FetchLoaders(filename, foldername) ) return NULL;
if ( ! FetchEvent(event) ) return NULL;
- if ( ! FetchTreeR() ) return NULL;
+ if ( ! FetchTreeD() ) return NULL;
if ( ! fTriggerAddressSet )
{
- // If the local trigger address in TreeR is not set yet then set it now.
+ // If the local trigger address in TreeD is not set yet then set it now.
fData.SetTreeAddress("GLT");
fData.ResetTrigger();
- fData.GetTrigger();
+ fData.GetTriggerD();
fTriggerAddressSet = kTRUE;
}
return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
return -1;
}
- if ( ! FetchTreeR() ) return -1;
+ if ( ! FetchTreeD() ) return -1;
if ( ! fTriggerAddressSet )
{
fData.SetTreeAddress("GLT");
fData.ResetTrigger();
- fData.GetTrigger();
+ fData.GetTriggerD();
fTriggerAddressSet = kTRUE;
}
return fData.LocalTrigger()->GetEntriesFast();
return NULL;
}
- if ( ! FetchTreeR() ) return NULL;
+ if ( ! FetchTreeD() ) return NULL;
if ( ! fTriggerAddressSet )
{
fData.SetTreeAddress("GLT");
fData.ResetTrigger();
- fData.GetTrigger();
+ fData.GetTriggerD();
fTriggerAddressSet = kTRUE;
}
return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
/* $Id$ */
+#include <assert.h>
+
#include "AliRun.h"
#include "AliRunDigitizer.h"
#include "AliRunLoader.h"
AliDebug(2, "Creating digits...");
for (Int_t icat = 0; icat < 2; icat++) {
+ Int_t digitindex[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
//
// Filling Digit List
Int_t nentries = fTDList->GetEntriesFast();
AliDebug(3,Form( "Creating digit from transient digit 0x%X", (void*)td));
Int_t q = GetSignalFrom(td);
- if (q > 0) AddDigit(td, q);
+ assert( 0 <= td->Chamber() && td->Chamber() <= 13 );
+ if (q > 0) AddDigit(td, q, digitindex[td->Chamber()]++);
}
FillOutputData();
}
}
//------------------------------------------------------------------------
-void AliMUONDigitizer::AddDigit(AliMUONTransientDigit* td, Int_t responseCharge)
+void AliMUONDigitizer::AddDigit(
+ AliMUONTransientDigit* td, Int_t responseCharge,
+ const Int_t digitindex
+ )
{
// Prepares the digits, track and charge arrays in preparation for a call to
// AddDigit(Int_t, Int_t[kMAXTRACKS], Int_t[kMAXTRACKS], Int_t[6])
OnWriteTransientDigit(td);
AddDigit(td->Chamber(), tracks, charges, digits);
- AddDigitTrigger(td->Chamber(), tracks, charges, digits);
+ AddDigitTrigger(td->Chamber(), tracks, charges, digits, digitindex);
}
//------------------------------------------------------------------------
virtual void OnWriteTransientDigit(AliMUONTransientDigit* digit);
// Wrapper method for AddDigit(Int_t, Int_t[kMAXTRACKS], Int_t[kMAXTRACKS], Int_t[6])
- void AddDigit(AliMUONTransientDigit* td, Int_t responseCharge);
+ void AddDigit(AliMUONTransientDigit* td, Int_t responseCharge, const Int_t digitindex);
// Creates a new fTDList object, and creates and fills the fHitMap arrays.
// Note: this method assumes the array pointers are NULL when calling this method.
virtual void CreateTrigger() = 0;
virtual void CleanupTriggerArrays() = 0;
virtual void FillTriggerOutput() = 0;
- virtual void AddDigitTrigger(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6]) = 0;
+ virtual void AddDigitTrigger(
+ Int_t chamber, Int_t tracks[kMAXTRACKS],
+ Int_t charges[kMAXTRACKS], Int_t digits[6],
+ const Int_t digitindex
+ ) = 0;
virtual Int_t GetSegmentation();
AliRunLoader* fRunLoader; //! Global run loader.
}
//------------------------------------------------------------------------
-void AliMUONDigitizerv2::AddDigitTrigger(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7])
+void AliMUONDigitizerv2::AddDigitTrigger(
+ Int_t chamber, Int_t tracks[kMAXTRACKS],
+ Int_t charges[kMAXTRACKS], Int_t digits[7],
+ const Int_t digitindex
+ )
{
// Derived to add digits to TreeD for trigger.
- fTrigDec->AddDigit(chamber, tracks, charges, digits);
+ fTrigDec->AddDigit(chamber, tracks, charges, digits, digitindex);
}
//------------------------------------------------------------------------
// for trigger purpose
virtual void CreateTrigger();
virtual void CleanupTriggerArrays();
- virtual void AddDigitTrigger(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[7]);
+ virtual void AddDigitTrigger(
+ Int_t chamber, Int_t tracks[kMAXTRACKS],
+ Int_t charges[kMAXTRACKS], Int_t digits[7],
+ const Int_t digitindex
+ );
virtual void FillTriggerOutput();
ClassDef(AliMUONDigitizerv2, 0)
/* $Id$ */
#include "AliMUONLocalTrigger.h"
+#include <assert.h>
+#include "AliLog.h"
ClassImp(AliMUONLocalTrigger)
//----------------------------------------------------------------------
AliMUONLocalTrigger::AliMUONLocalTrigger()
- : TObject()
+ : TObject(), fDigits(0)
{
// constructor
fLoCircuit = 0;
fY4Pattern = 0;
fLoDecision = 0;
-
}
//----------------------------------------------------------------------
AliMUONLocalTrigger::AliMUONLocalTrigger(const AliMUONLocalTrigger& theMUONLocalTrig)
fY4Pattern = theMUONLocalTrig.fY4Pattern;
fLoDecision = theMUONLocalTrig.fLoDecision;
+
+ fDigits = theMUONLocalTrig.fDigits;
}
//----------------------------------------------------------------------
AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& theMUONLocalTrig)
fLoDecision = theMUONLocalTrig.fLoDecision;
+ fDigits = theMUONLocalTrig.fDigits;
+
return *this;
}
//----------------------------------------------------------------------
-AliMUONLocalTrigger::AliMUONLocalTrigger(Int_t* localtr)
+AliMUONLocalTrigger::AliMUONLocalTrigger(const Int_t* localtr, const TArrayI& digits)
{
// add a local trigger object
fLoCircuit = localtr[0];
fY2Pattern = (UShort_t)localtr[12];
fY3Pattern = (UShort_t)localtr[13];
fY4Pattern = (UShort_t)localtr[14];
+
+ fDigits = digits;
}
//----------------------------------------------------------------------
Char_t AliMUONLocalTrigger::GetLoDecision()
return fLoDecision;
}
+
+//----------------------------------------------------------------------
+void AliMUONLocalTrigger::GetDigit(
+ const Int_t i, Int_t& chamber, Int_t& cathode, Int_t& digit
+ ) const
+{
+// Returns the i'th digit that fired this circuit.
+// The number of digits can be found with NumberOfDigits(), that is
+// i is valid in the range [ 0 , NumberOfDigits() - 1 ]
+
+ Int_t digitnumber = fDigits[i];
+ DecodeDigitNumber(digitnumber, chamber, cathode, digit);
+};
+
+//----------------------------------------------------------------------
+Int_t AliMUONLocalTrigger::EncodeDigitNumber(
+ const Int_t chamber, const Int_t cathode, const Int_t digit
+ )
+{
+// Encodes a 32-bit digit number from digit information to be stored
+// in internal integer arrays. Note that the value of the digit parameter
+// can not be larger than 0x07FFFFFF.
+
+ assert( 0 <= cathode && cathode <= 1 );
+ assert( 0 <= chamber && chamber <= 13 );
+
+ if ((digit & 0xF8000000) != 0)
+ {
+ AliErrorGeneral("AliMUONLocalTrigger", Form(
+ "Digit index value is to large: 0x%8.8X. Maximum supported value is 0x07FFFFFF.",
+ cathode, chamber, digit
+ ));
+ return -1;
+ };
+
+ return ((cathode & 0x1) << 31) | ((chamber & 0xF) << 27) | digit;
+};
+
+//----------------------------------------------------------------------
+void AliMUONLocalTrigger::DecodeDigitNumber(
+ const Int_t digitnumber,
+ Int_t& chamber, Int_t& cathode, Int_t& digit
+ )
+{
+// Decodes a digit number into information about the digit.
+// One can subsequently fetch the digit with
+// AliMUONDataInterface::Digit(chamber, cathode, digit)
+
+ cathode = (digitnumber >> 31) & 0x1;
+ chamber = (digitnumber >> 27) & 0xF;
+ digit = digitnumber & 0x7FFFFFF;
+};
+
// Revision of includes 07/05/2004
#include <TObject.h>
+#include <TArrayI.h>
class AliMUONLocalTrigger : public TObject {
public:
AliMUONLocalTrigger();
AliMUONLocalTrigger(const AliMUONLocalTrigger& rhs); // copy constructor !
- AliMUONLocalTrigger(Int_t* localtr);
+ AliMUONLocalTrigger(const Int_t* localtr, const TArrayI& digits);
virtual ~AliMUONLocalTrigger(){;}
AliMUONLocalTrigger& operator=(const AliMUONLocalTrigger& rhs);
Char_t GetLoDecision();
+ Int_t NumberOfDigits() const { return fDigits.GetSize(); };
+ Int_t GetDigitNumber(const Int_t i) const { return fDigits[i]; };
+ void GetDigit(const Int_t i, Int_t& chamber, Int_t& cathode, Int_t& digit) const;
+
+ static Int_t EncodeDigitNumber(const Int_t chamber, const Int_t cathode, const Int_t digit);
+ static void DecodeDigitNumber(const Int_t digitnumber, Int_t& chamber, Int_t& cathode, Int_t& digit);
+
ClassDef(AliMUONLocalTrigger,2) // reconstructed Local Trigger object
private:
UShort_t fY4Pattern;
Char_t fLoDecision; // local decision word (4 bits)
+
+ TArrayI fDigits; // List of digit numbers from which this object was created.
};
#endif
void CleanupTriggerArrays(){return;}
void FillTriggerOutput(){return;}
void AddDigitTrigger(Int_t /*chamber*/, Int_t* /*tracks[kMAXTRACKS]*/,
- Int_t* /*charges[kMAXTRACKS]*/, Int_t* /*digits[6]*/){return;}
+ Int_t* /*charges[kMAXTRACKS]*/, Int_t* /*digits[6]*/,
+ const Int_t /*digitindex*/
+ ) {return;}
ClassDef(AliMUONSDigitizerv1, 0)
};
fDigits = new TObjArray(AliMUONConstants::NCh()); //NTriggerCh
for (Int_t i=0; i<AliMUONConstants::NCh() ;i++)
fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
+ fDigitIndices = new TArrayI[AliMUONConstants::NCh()];
}
//----------------------------------------------------------------------
fMUON(0)
{
// Default constructor
+ fDigitIndices = NULL;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
void AliMUONTriggerDecision::ClearDigits()
{
- for ( int i=0;i<AliMUONConstants::NCh();i++ )
+ for ( int i=0;i<AliMUONConstants::NCh();i++ )
+ {
if ((*fDigits)[i]) ((TClonesArray*)fDigits->At(i))->Clear();
+ fDigitIndices[i].Set(0);
+ };
}
//----------------------------------------------------------------------
}
//_____________________________________________________________________________
-void AliMUONTriggerDecision::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
+void AliMUONTriggerDecision::AddDigit(
+ Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits,
+ const Int_t digitindex
+ )
{
//
// Add a MUON digit to the list of Digits of the detection plane id
+ // Also adds the digit index to the corresponding fDigitIndices arrays.
//
TClonesArray &ldigits = *Digits(id);
new(ldigits[ldigits.GetEntriesFast()]) AliMUONDigit(tracks,charges,digits);
+
+ TArrayI& indices = fDigitIndices[id];
+ indices.Set(indices.GetSize() + 1);
+ indices[indices.GetSize() - 1] = digitindex;
}
//----------------------------------------------------------------------
delete fDigits;
}
+ if (fDigitIndices)
+ delete [] fDigitIndices;
}
//----------------------------------------------------------------------
AliMUONTriggerCircuit* triggerCircuit;
for (Int_t chamber = 11; chamber < 15; chamber++){
- // for (Int_t cathode=1; cathode<3; cathode++){
- // fMUONData->GetCathode(cathode-1);
TClonesArray *muonDigits = Digits(chamber-1);
Int_t ndigits = muonDigits->GetEntriesFast();
Int_t istrip;
Int_t nStrip;
+ // If I want to fetch the digits as in MUONCheck.C then I need to
+ // know the correct digit index. These were stored in fDigitIndices
+ // by the digitizer so we just need to fetch the correct value.
+ Int_t digitindex = fDigitIndices[chamber-1][digit];
+
if (cathode==1) {
switch (chamber)
{
for (icirc=0; icirc<234; icirc++) {
triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);
for (istrip=0; istrip<16; istrip++) {
- if (triggerCircuit->GetXcode(0,istrip)==code)
+ if (triggerCircuit->GetXcode(0,istrip)==code)
+ {
fXbit11[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
for (istrip=0; istrip<16; istrip++) {
if (triggerCircuit->GetXcode(1,istrip)==code)
+ {
fXbit12[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
for (istrip=0; istrip<32; istrip++) {
if (triggerCircuit->GetXcode(2,istrip)==code)
+ {
fXbit21[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
for (istrip=0; istrip<32; istrip++) {
if (triggerCircuit->GetXcode(3,istrip)==code)
+ {
fXbit22[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(0,istrip)==code)
+ {
fYbit11[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(1,istrip)==code)
+ {
fYbit12[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(2,istrip)==code)
+ {
fYbit21[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(3,istrip)==code)
+ {
fYbit22[icirc][istrip]=1;
+ DigitFiredCircuit(icirc, cathode-1, chamber-1, digitindex);
+ };
}
}
break;
} // remove soft background
} // end loop on digit
fMUONData->ResetDigits();
- // } // end loop on cathode
+// } // end loop on cathode
} // end loop on chamber
}
void AliMUONTriggerDecision::Digits2Trigger(){
// call the Trigger Algorithm and fill TreeD
+ ClearDigitNumbers();
fMUONData->ResetTrigger();
Trigger();
localtr[14] |= (fYbit22[icirc][i] << i);
}
- AliMUONLocalTrigger* pLocTrig = new AliMUONLocalTrigger(localtr);
+ AliMUONLocalTrigger* pLocTrig = new AliMUONLocalTrigger(localtr, fDigitNumbers[icirc]);
fMUONData->AddLocalTrigger(*pLocTrig); // add a local trigger in the list
}
}
}
+
+//_______________________________________________________________________
+void AliMUONTriggerDecision::ClearDigitNumbers()
+{
+// Clears the fDigitNumbers arrays so that they are all empty.
+
+ for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++)
+ fDigitNumbers[i].Set(0);
+};
+
+//_______________________________________________________________________
+void AliMUONTriggerDecision::DigitFiredCircuit(
+ const Int_t circuit, const Int_t cathode,
+ const Int_t chamber, const Int_t digit
+ )
+{
+// Registers that the specified digit fired the specified circuit.
+// This digit gets added to an array which will be copied to
+// AliMUONLocalTrigger when such an object is created for each circuit.
+
+ Int_t digitnumber = AliMUONLocalTrigger::EncodeDigitNumber(chamber, cathode, digit);
+ Int_t last = fDigitNumbers[circuit].GetSize();
+ fDigitNumbers[circuit].Set(last + 1);
+ fDigitNumbers[circuit][last] = digitnumber;
+};
+
////////////////////////////////////////////////
#include <TObject.h>
+#include "AliMUONLocalTrigger.h"
class TClonesArray;
void ClearDigits();
TClonesArray* Digits(Int_t DetectionPlane);
- void AddDigit(Int_t id, Int_t* tracks, Int_t* charges, Int_t* digits);
+
+ void AddDigit(
+ Int_t id, Int_t* tracks, Int_t* charges, Int_t* digits,
+ const Int_t digitindex
+ );
// print-debug
void PrintBitPatXInput(Int_t icirc);
void GetGlobalTrigger(Int_t singlePlus[3], Int_t singleMinus[3],
Int_t singleUndef[3], Int_t pairUnlike[3],
Int_t pairLike[3]) const;
-
-
ClassDef(AliMUONTriggerDecision,1) // Trigger Decision class
- protected:
+
+protected:
+
AliMUONTriggerDecision(const AliMUONTriggerDecision& rhs);
AliMUONTriggerDecision& operator=(const AliMUONTriggerDecision& rhs);
+ void ClearDigitNumbers();
+
+ void DigitFiredCircuit(
+ const Int_t circuit, const Int_t cathode,
+ const Int_t chamber, const Int_t digit
+ );
+
+
Int_t fDebug; // print option
// Global Trigger information [0] : Low pt, [1] : High pt, [2] : All pt
Int_t fYbit21D[234][16]; // bit pattern YM21 Down
Int_t fYbit22D[234][16]; // bit pattern YM22 Down
+ TArrayI fDigitNumbers[234]; //! The digit number that fired a circuit.
AliLoader* fLoader; //! alice loader
TObjArray* fTriggerCircuit; //! List of Trigger Circuit
TObjArray* fDigits; // temp array for digits (both cathodes !) for trigger
+ TArrayI* fDigitIndices; //! Array of digit index numbers, one for each entry in fDigits.
AliMUONData* fMUONData; //! Data container for MUON subsystem
AliMUON* fMUON; //! pointer to MUON