TObjArray* Validate(const AliMUONV2DStore& store,
Bool_t (*check)(const AliMUONVCalibParam&,Int_t));
+ /// Return statuses
AliMUONV2DStore* GetStatus() const { return fStatus; }
/// Reports what is missing, trying to be as concise as possible.
virtual ~AliMUONBlockHeader();
+ //
// Block header
+ //
+ /// Return data key word for CRT header
Int_t GetDataKey() const {return fDataKey;}
+ /// Return total length of block structure (w/o padding word)
Int_t GetTotalLength() const {return fTotalLength;}
+ /// Return length of raw data
Int_t GetLength() const {return fLength;}
+ /// Return Dsp id
Int_t GetDspId() const {return fDspId;}
+ /// Return L0 trigger word
Int_t GetL0Trigger() const {return fL0Trigger;}
+ /// Return Bunch Crossing for mini-event id (see TDR chapter 8)
Int_t GetMiniEventId() const {return fMiniEventId;}
+ /// Return Event Id in bunch crossing
Int_t GetEventId1() const {return fEventId1;}
+ /// Return Event Id in orbit number
Int_t GetEventId2() const {return fEventId2;}
+ /// Return header length in word
Int_t GetHeaderLength() const {return fgkHeaderLength;}
+ /// Return default data key word for CRT header
UInt_t GetDefaultDataKey() const {return fgkDefaultDataKey;}
+
+ /// Set data key word for CRT header
void SetDataKey(Int_t d) {fDataKey = d;}
+ /// Set total length of block structure (w/o padding word)
void SetTotalLength(Int_t l) {fTotalLength = l;}
+ /// Set length of raw data
void SetLength(Int_t l) {fLength = l;}
+ /// Set Dsp id
void SetDspId(Int_t d) {fDspId = d;}
+ /// Set L0 trigger word
void SetL0Trigger(Int_t l) {fL0Trigger = l;}
+ /// Set Bunch Crossing for mini-event id (see TDR chapter 8)
void SetMiniEventId(Int_t e) {fMiniEventId = e;}
+ /// Set Event Id in bunch crossing
void SetEventId1(Int_t e) {fEventId1 = e;}
+ /// Set Event Id in orbit number
void SetEventId2(Int_t e) {fEventId2 = e;}
-
+
+
+ /// Return header
Int_t* GetHeader() {return &fDataKey;}
void AddDspHeader(const AliMUONDspHeader& dspHeader);
- // get TClonesArray
+ /// get TClonesArray
TClonesArray* GetDspHeaderArray() const {return fDspHeaderArray;}
- // get entries
+ /// get entries
Int_t GetDspHeaderEntries() const {return fDspHeaderArray->GetEntriesFast();}
- // get entry
+ /// get entry
AliMUONDspHeader* GetDspHeaderEntry(Int_t i) const {
return (AliMUONDspHeader*)fDspHeaderArray->At(i);}
AliMUONBusStruct& operator=(const AliMUONBusStruct& rhs);
// header
+ /// Return Data key word for bus patch header
Int_t GetDataKey() const {return fDataKey;}
+ /// Return total length of buspatch structure
Int_t GetTotalLength() const {return fTotalLength;}
+ /// Return length of raw data
Int_t GetLength() const {return fLength;}
+ /// Return bus patch id
Int_t GetBusPatchId() const {return fBusPatchId;}
+ /// Return header length in word
Int_t GetHeaderLength() const {return fgkHeaderLength;}
+ /// Return default data key word for Bus Patch Header
UInt_t GetDefaultDataKey() const {return fgkDefaultDataKey;}
+ /// Return header
Int_t* GetHeader() {return &fDataKey;}
// data
+ /// Return initial size for data array
Int_t GetBufSize() const {return fBufSize;}
+ /// Return data
UInt_t* GetData() const {return fData;}
+ /// Return block numer for monitoring
Int_t GetBlockId() const {return fBlkId;}
+ /// Return Dsp number for monitoring
Int_t GetDspId() const {return fDspId;}
Char_t GetParity(Int_t n) const;
UInt_t GetData(Int_t n) const;
// header setter
+ /// Set Data key word for bus patch header
void SetDataKey(Int_t d) {fDataKey = d;}
+ /// Set total length of buspatch structure
void SetTotalLength(Int_t l) {fTotalLength = l;}
+ /// Set length of raw data
void SetLength(Int_t l) {fLength = l;}
+ /// Set bus patch id
void SetBusPatchId(Int_t b) {fBusPatchId = b;}
// data
+ /// Set data
void SetData(UInt_t d, Int_t n) {fData[n] = d;}
+ /// Set block numer for monitoring
void SetBlockId(Int_t b) {fBlkId = b;}
+ /// Set Dsp number for monitoring
void SetDspId(Int_t d) {fDspId = d;}
void AddData(UInt_t d);
void SetAlloc(Int_t size);
// TClonesArray
+ /// Return true as Compare() is implemented
Bool_t IsSortable() const {return kTRUE;}
Int_t Compare(const TObject *obj) const;
void Clear(Option_t* opt);
AliMUONTriggerEfficiencyCells* TriggerEfficiency() const;
protected:
+ /// Not implemented
AliMUONCalibrationData(const AliMUONCalibrationData& other);
+ /// Not implemented
AliMUONCalibrationData& operator=(const AliMUONCalibrationData& other);
private:
AliMUONTriggerEfficiencyCells* OnDemandTriggerEfficiency() const;
private:
- mutable Bool_t fIsValid; // Whether we were able to correctly initialize
- Int_t fRunNumber; // The run number for which we hold calibrations
- mutable AliMUONV2DStore* fGains; //!
- mutable AliMUONV2DStore* fPedestals; //!
- mutable TMap* fHV; //!
- mutable AliMUONV1DStore* fLocalTriggerBoardMasks; //!
- mutable AliMUONV1DStore* fRegionalTriggerBoardMasks; //!
- mutable AliMUONVCalibParam* fGlobalTriggerBoardMasks; //!
- mutable AliMUONTriggerLut* fTriggerLut; //!
- mutable AliMUONTriggerEfficiencyCells* fTriggerEfficiency; //!
+ mutable Bool_t fIsValid; ///< Whether we were able to correctly initialize
+ Int_t fRunNumber; ///< The run number for which we hold calibrations
+ mutable AliMUONV2DStore* fGains; //!< Gains
+ mutable AliMUONV2DStore* fPedestals; //!< Pedestals
+ mutable TMap* fHV; //!< HV
+ mutable AliMUONV1DStore* fLocalTriggerBoardMasks; //!< Local trigger board maska
+ mutable AliMUONV1DStore* fRegionalTriggerBoardMasks; //!< Regional trigger board maska
+ mutable AliMUONVCalibParam* fGlobalTriggerBoardMasks; //!< Global trigger board maska
+ mutable AliMUONTriggerLut* fTriggerLut; //!< TRigger LUTs
+ mutable AliMUONTriggerEfficiencyCells* fTriggerEfficiency; //!< Trigger efficiency cells
ClassDef(AliMUONCalibrationData,4) // Storage for all MUON calibration data.
};
fData(0x0),
fTree(0)
{
- // ctor
+ /// ctor
fRunLoader = AliRunLoader::Open(fFileName.Data(),"MUONFolder","READ");
if (!fRunLoader)
//_____________________________________________________________________________
AliMUONCheck::AliMUONCheck(const AliMUONCheck& rhs) : TObject(rhs)
{
- // copy ctor
+ /// copy ctor
AliFatal("Implement me if needed");
}
AliMUONCheck&
AliMUONCheck::operator=(const AliMUONCheck&)
{
- // assignement operator
+ /// assignement operator
AliFatal("Implement me if needed")
return *this;
}
void
AliMUONCheck::CheckESD(Bool_t pdc06TriggerResponse)
{
- // Check ESD files
+ /// Check ESD files
if ( !IsValid() ) return;
void
AliMUONCheck::CheckKine()
{
- // Check Stack
+ /// Check Stack
if ( !IsValid() ) return;
// Stack of particle for each event
void
AliMUONCheck::CheckTrackRef()
{
- // Check TrackRef files
+ /// Check TrackRef files
if ( !IsValid() ) return;
Int_t flag11=0,flag12=0,flag13=0,flag14=0;
private:
/// Not implemented
AliMUONCheck(const AliMUONCheck& rhs);
- /// Not implemented
+ /// Not implemented
AliMUONCheck& operator=(const AliMUONCheck& rhs);
private:
AliMUONData* fData; //!< AliMUONData pointer (to access containers)
- TTree * fTree ; //!pointer to the analyzed TTree or TChain
- AliESD * fESD ; //! Declaration of leave types
+ TTree * fTree ; //!< pointer to the analyzed TTree or TChain
+ AliESD * fESD ; //!< Declaration of leave types
ClassDef(AliMUONCheck,0) // Dumper of MUON related data
};
TObject* Next();
private:
+ /// Not implemented
AliMUONCheckItemIterator(const AliMUONCheckItemIterator&);
+ /// Not implemented
AliMUONCheckItemIterator& operator=(const AliMUONCheckItemIterator&);
private:
void
AliMUONCluster::Copy(TObject& obj) const
{
- //
- // Copy this cluster to (cluster&)obj
- //
+ ///
+ /// Copy this cluster to (cluster&)obj
+ ///
TObject::Copy(obj);
AliMUONCluster& dest = static_cast<AliMUONCluster&>(obj);
dest.fPads = static_cast<TObjArray*>(fPads->Clone());
/// Return the cathode's charges asymmetry
Float_t ChargeAsymmetry() const;
+ /// Return chi2 of the RawCharge fit (if any)
Float_t Chi2() const { return fChi2; }
virtual void Copy(TObject& obj) const;
+ /// Return false for pre-cluster
Bool_t HasPosition() const { return fHasPosition; }
/// Whether we have at least one saturated pad in a given cathode
/// Whether we have one saturated pad on *each* cathode
Bool_t IsSaturated() const { return IsSaturated(0) && IsSaturated(1); }
+ /// Return the max charge on the chathod
Int_t MaxChargeCathode() const { return Charge(0) > Charge(1) ? 0:1; }
+ /// Return the max raw charge on the chathod
Int_t MaxRawChargeCathode() const { return RawCharge(0) > RawCharge(1) ? 0:1; }
/// Return the smallest pad dimensions for a given cathode
virtual void Paint(Option_t* opt="");
+ /// Return (x,y) of that cluster
TVector2 Position() const { return fPosition; }
+ /// Return errors on (x,y)
TVector2 PositionError() const { return fPositionError; }
virtual void Print(Option_t* opt="") const;
Float_t RawChargeAsymmetry() const;
void RemovePad(AliMUONPad* pad);
-
+
+ /// Set cathode (re)computed charges
void SetCharge(Float_t chargeCath0, Float_t chargeCath1)
{ fHasCharge = kTRUE; fCharge[0]=chargeCath0; fCharge[1]=chargeCath1; }
-
+
+ /// Set chi2 of the RawCharge fit
void SetChi2(Float_t chi2) { fChi2 = chi2; }
+ /// Set (x,y) of that cluster and errors
void SetPosition(const TVector2& pos, const TVector2& errorOnPos)
{ fHasPosition = kTRUE; fPosition = pos; fPositionError = errorOnPos; }
virtual AliMUONCluster* NextCluster();
private:
+ /// Not implemented
AliMUONClusterFinderCOG(const AliMUONClusterFinderCOG& rhs);
+ /// Not implemented
AliMUONClusterFinderCOG& operator=(const AliMUONClusterFinderCOG& rhs);
+
void ComputePosition(AliMUONCluster& cluster);
private:
AliMUONCluster*
AliMUONClusterFinderMLEM::CheckPreclusterTwoCathodes(AliMUONCluster* cluster)
{
- // Check two-cathode cluster
+ /// Check two-cathode cluster
Int_t i1 = cluster->Multiplicity(0) ? 0 : 1;
Int_t i2 = cluster->Multiplicity(1) ? 1 : 0;
virtual void Paint(Option_t* opt="");
private:
+ /// Not implemented
AliMUONClusterFinderMLEM(const AliMUONClusterFinderMLEM& rhs);
+ /// Not implemented
AliMUONClusterFinderMLEM& operator=(const AliMUONClusterFinderMLEM& rhs);
Bool_t WorkOnPreCluster();
static const TVector2 fgkIncreaseSize; ///< idem
static const TVector2 fgkDecreaseSize; ///< idem
- AliMUONVClusterFinder* fPreClusterFinder; ///!< the pre-clustering worker
- AliMUONCluster* fPreCluster; ///<! current pre-cluster
- TObjArray fClusterList; ///!< clusters corresponding to the current pre-cluster
+ AliMUONVClusterFinder* fPreClusterFinder; //!< the pre-clustering worker
+ AliMUONCluster* fPreCluster; //!< current pre-cluster
+ TObjArray fClusterList; //!< clusters corresponding to the current pre-cluster
- Int_t fEventNumber; ///!< current event being processed
- Int_t fDetElemId; ///!< current DE being processed
- Int_t fClusterNumber; ///!< current cluster number
+ Int_t fEventNumber; //!< current event being processed
+ Int_t fDetElemId; //!< current DE being processed
+ Int_t fClusterNumber; //!< current cluster number
const AliMpVSegmentation *fSegmentation[2]; //!< new segmentation
Bool_t fPlot; //!< whether we should plot thing (for debug only, quite slow!)
TObjArray* fTimers; //!< internal timers
+
+ /// \todo add comment
enum ETimer { kMainLoop, kCheckPreCluster, kLast };
AliMUONClusterSplitterMLEM* fSplitter; //!< helper class to go from pixel arrays to clusters
virtual AliMUONCluster* NextCluster();
private:
+ /// Not implemented
AliMUONClusterFinderSimpleFit(const AliMUONClusterFinderSimpleFit& rhs);
+ /// Not implemented
AliMUONClusterFinderSimpleFit& operator=(const AliMUONClusterFinderSimpleFit& rhs);
+
void ComputePosition(AliMUONCluster& cluster);
private:
TClonesArray* GetRawClusters() {return fRawClusters;}
/// Reset raw clusters
void ResetRawClusters();
-// set evt number
+/// Set evt number
void SetEventNumber(Int_t evtNumber) {fEvtNumber = evtNumber;}
protected:
Float_t DiscrChargeS2(Int_t i,Double_t *par);
Float_t DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath);
//
- protected:
- AliMUONClusterInput();
private:
+ /// Not implemented
+ AliMUONClusterInput();
+ /// Not implemented
AliMUONClusterInput(const AliMUONClusterInput& clusterInput);
+ /// Not implemented
AliMUONClusterInput & operator = (const AliMUONClusterInput& rhs);
static AliMUONClusterInput* fgClusterInput; //!< singleton instance
virtual void Digits2Clusters(Int_t chBeg = 0);
virtual void Trigger2Trigger() ;
- // Reco Model
+ /// Return cluster recontruction model
AliMUONClusterFinderVS* GetRecoModel() {return fRecModel;}
void SetRecoModel(AliMUONClusterFinderVS* rec);
protected:
-
+ /// Not implemented
AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs); // copy constructor
+ /// Not implemented
AliMUONClusterReconstructor& operator=(const AliMUONClusterReconstructor& rhs); // assignment operator
void ClusterizeOneDE(Int_t detElemId);
//_____________________________________________________________________________
AliMUONClusterSplitterMLEM::~AliMUONClusterSplitterMLEM()
{
+ /// Destructor
+
delete fMathieson;
}
void UpdatePads(const AliMUONCluster& cluster, Int_t nfit, Double_t *par);
private:
- // will not be implemented
+ /// will not be implemented
AliMUONClusterSplitterMLEM(const AliMUONClusterSplitterMLEM&);
- // will not be implemented
+ /// will not be implemented
AliMUONClusterSplitterMLEM& operator=(const AliMUONClusterSplitterMLEM&);
private:
static const Double_t fgkCouplMin; ///< threshold on coupling
- TObjArray* fPixArray; //! < not owner
- AliMUONMathieson* fMathieson; //!<
+ TObjArray* fPixArray; //!< \todo add comment
+ AliMUONMathieson* fMathieson; //!< Mathieson
Int_t fDetElemId; //!< detection element we are working on
Int_t fNpar; //!< number of fit parameters
Double_t fQtot; //!< total charge
protected:
private:
+ /// Not implemented
AliMUONCommonGeometryBuilder(const AliMUONCommonGeometryBuilder& right);
+ /// Not implemented
AliMUONCommonGeometryBuilder&
operator = (const AliMUONCommonGeometryBuilder& right);
// data members
void AddDspHeader(const AliMUONDspHeader& dspHeader, Int_t iBlock);
void AddBlkHeader(const AliMUONBlockHeader& blkHeader);
- // get TClonesArray
+ /// get TClonesArray
TClonesArray* GetBlkHeaderArray() const {return fBlkHeaderArray;}
- // get entries
+ /// get entries
Int_t GetBlkHeaderEntries() const {return fBlkHeaderArray->GetEntriesFast();}
- // get entry
+ /// get entry
AliMUONBlockHeader* GetBlkHeaderEntry(Int_t i) const {
return (AliMUONBlockHeader*)fBlkHeaderArray->At(i);}
private:
-
- TClonesArray* fBlkHeaderArray; ///< array of block header
-
+ /// Not implemented
AliMUONDDLTracker(const AliMUONDDLTracker& event);
+ /// Not implemented
AliMUONDDLTracker& operator=(const AliMUONDDLTracker& event);
+
+ TClonesArray* fBlkHeaderArray; ///< array of block header
ClassDef(AliMUONDDLTracker,1) // MUON DDL Tracker
};
void AddLocStruct(const AliMUONLocalStruct& loc, Int_t iReg);
void AddRegHeader(const AliMUONRegHeader& regHeader);
- // get AliMUONDarcHeader
+ /// get AliMUONDarcHeader
AliMUONDarcHeader* GetDarcHeader() const {return fDarcHeader;}
private:
-
-
- AliMUONDarcHeader* fDarcHeader; ///< pointer of darc header
-
+ /// Not implemented
AliMUONDDLTrigger(const AliMUONDDLTrigger& event);
+ /// Not implemented
AliMUONDDLTrigger& operator=(const AliMUONDDLTrigger& event);
+ AliMUONDarcHeader* fDarcHeader; ///< pointer of darc header
+
ClassDef(AliMUONDDLTrigger,1) // MUON DDL Trigger
};
#endif
virtual ~AliMUONDarcHeader();
+ /// Return first word
UInt_t GetWord() const {return fWord;}
+ /// Return global input
Int_t GetGlobalInput(Int_t n) const {return fGlobalInput[n];}
+ /// Return global output
UChar_t GetGlobalOutput() const {return (fGlobalOutput & 0xFF);}
+ /// Return global config
UShort_t GetGlobalConfig() const {return ((fGlobalOutput >> 16) & 0xFFFF);}
//MBZ:1, phys trig:1, type:3, ,SerialNb:4,Version:8,VME trig:1,
//GlobalFlag:1, CTP trig:1, DAQ:1, Reg pattern:8;
+ /// Return event type
Bool_t GetEventType() const {return (fWord & 0x40000000);}
+ /// Return Darc type
UChar_t GetDarcType() const {return (UChar_t)(fWord >> 27) & 0x7;}
+ /// Return serial number
UChar_t GetSerialNb() const {return (UChar_t)(fWord >> 23) & 0xF;}
+ /// Return version
UChar_t GetVersion() const {return (UChar_t)(fWord >> 15) & 0xFF;}
+ /// Return VME trig
Bool_t GetVMETrig() const {return (fWord & 0x800);}
+ /// Return global flag
Bool_t GetGlobalFlag() const {return (fWord & 0x400);}
+ /// Return CPT trigger
Bool_t GetCTPTrig() const {return (fWord & 0x200);}
+ /// Return DAQ flag
Bool_t GetDAQFlag() const {return (fWord & 0x100);}
+ /// Return reg pattern
UChar_t GetRegPattern() const {return (UChar_t)(fWord & 0xFF);}
+ /// Set first word
void SetWord(UInt_t w) {fWord = w;}
+ /// Set global input
void SetGlobalInput(Int_t in, Int_t n) {fGlobalInput[n] = in;}
+ /// Set global output
void SetGlobalOutput(Int_t out) {fGlobalOutput = out;}
+ /// Return darc header length
Int_t GetDarcHeaderLength() const {return fgkDarcHeaderLength;}
+ /// Return global header length
Int_t GetGlobalHeaderLength() const {return fgkGlobalHeaderLength;}
+ /// Return header
UInt_t* GetHeader() {return &fWord;}
+ /// Return global input
Int_t* GetGlobalInput() {return &fGlobalInput[0];}
// DARC get methods
+ /// Return DARC L0 received and used
UInt_t GetDarcL0R() const {return fDarcL0R;}
+ /// Return DARC L1 physics
UInt_t GetDarcL1P() const {return fDarcL1P;}
+ /// Return DARC L1 software
UInt_t GetDarcL1S() const {return fDarcL1S;}
+ /// Return DARC L2 accept
UInt_t GetDarcL2A() const {return fDarcL2A;}
+ /// Return DARC L2 reject
UInt_t GetDarcL2R() const {return fDarcL2R;}
+ /// Return DARC clock
UInt_t GetDarcClock() const {return fDarcClk;}
+ /// Return DARC hold (dead time)
UInt_t GetDarcHold() const {return fDarcHold;}
// don't use setting methods but memcpy
+ /// Return global L0
UInt_t* GetGlobalScalers() {return &fGlobalL0;}
+ /// Return DARC L0 received and used
UInt_t* GetDarcScalers() {return &fDarcL0R;}
// global get methods
+ /// Return global L0
UInt_t GetGlobalL0() const {return fGlobalL0;}
+ /// Return global clock
UInt_t GetGlobalClock() const {return fGlobalClk;}
+ /// Return global scaler
const UInt_t* GetGlobalScaler() const {return fGlobalScaler;}
+ /// Return global hold (dead time)
UInt_t GetGlobalHold() const {return fGlobalHold;}
+ /// Return global spare
UInt_t GetGlobalSpare() const {return fGlobalSpare;}
+ /// Return length of global scaler in word
Int_t GetGlobalScalerLength() const {return fgkGlobalScalerLength;}
+ /// Return length of DARC scaler in word
Int_t GetDarcScalerLength() const {return fgkDarcScalerLength;}
+ /// Return end of darc info word
UInt_t GetEndOfDarc() const {return fgkEndOfDarc;}
+ /// Return end of global info word
UInt_t GetEndOfGlobal() const {return fgkEndOfGlobal;}
// set random numbers to fill variable
void SetScalersNumbers();
- // get TClonesArray
+ /// get TClonesArray
TClonesArray* GetRegHeaderArray() const {return fRegHeaderArray;}
- // get entries
+ /// get entries
Int_t GetRegHeaderEntries() const {return fRegHeaderArray->GetEntriesFast();}
- // get entry
+ /// get entry
AliMUONRegHeader* GetRegHeaderEntry(Int_t i) const {
return (AliMUONRegHeader*)fRegHeaderArray->At(i);}
/* $Id$ */
-/// \class AliMUONData class
+/// \class AliMUONData
///
/// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
/// The classe makes the lik between the MUON data lists and the event trees from loaders
fSplitLevel(0),
fCurrentEvent(-1)
{
- // Default constructor
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
Float_t phi, Float_t length, Float_t destep,
Float_t Xref,Float_t Yref,Float_t Zref)
{
- // Add new hit to the hit list
+ /// Add new hit to the hit list
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliMUONHit(fIshunt, track, detElemId,
void
AliMUONData::DumpKine(Int_t event2Check)
{
- // Load kinematics
+/// Dump kinematics
+
fRunLoader->LoadKinematics("READ");
Int_t nevents = fRunLoader->GetNumberOfEvents();
void
AliMUONData::DumpHits(Int_t event2Check, Option_t* opt)
{
- // Loading data
+/// Dump hits
+
fLoader->LoadHits("READ");
// Event loop
void
AliMUONData::DumpDigits(Int_t event2Check, Option_t* opt)
{
- // Loading data
+/// Dump digits
+
fLoader->LoadDigits("READ");
// Event loop
void
AliMUONData::DumpSDigits(Int_t event2Check, Option_t* opt)
{
- // Loading data
+/// Dump SDigits
+
fLoader->LoadSDigits("READ");
// Event loop
void
AliMUONData::DumpRecPoints(Int_t event2Check, Option_t* opt)
{
- // Loading data
+/// Dump rec points
+
fLoader->LoadRecPoints("READ");
// Event loop
void GetRecTracks() const;
void GetRecTriggerTracks() const;
+ /// Return split level
Int_t GetSplitLevel() const {return fSplitLevel;}
Bool_t IsRawClusterBranchesInTree();
void DumpRecTrigger(Int_t event2Check=0, Int_t write = 0, Bool_t readFromRP = kTRUE);
protected:
+ /// Not implemented
AliMUONData(const AliMUONData& rhs);
+ /// Not implemented
AliMUONData& operator=(const AliMUONData& rhs);
AliRunLoader* fRunLoader; //!< Run loader pointer
Int_t NumberOfRecTracks();
AliMUONTrack* RecTrack(Int_t rectrack);
+ /// Returns the file name from which we are fetching data
TString CurrentFile() const { return fFilename; };
- // Returns the name of the currently selected folder.
+ /// Returns the name of the currently selected folder.
TString CurrentFolder() const { return fFoldername; };
- // Returns the number of the currently selected event.
+ /// Returns the number of the currently selected event.
Int_t CurrentEvent() const { return fEventnumber; };
- // Returns the currently selected track.
+ /// Returns the currently selected track.
Int_t CurrentTrack() const { return fTrack; };
- // Returns the currently selected cathode in TreeS.
+ /// Returns the currently selected cathode in TreeS.
Int_t CurrentSCathode() const { return fSCathode; };
- // Returns the currently selected cathode in TreeD.
+ /// Returns the currently selected cathode in TreeD.
Int_t CurrentDCathode() const { return fCathode; };
private:
+ /// Not implemented
AliMUONDataInterface(const AliMUONDataInterface& rhs);
+ /// Not implemented
AliMUONDataInterface& operator=(const AliMUONDataInterface& rhs);
Bool_t FetchMuonLoader(TString filename, TString foldername);
TObject(),
fIterator(0x0)
{
+/// Default constructor
}
//_____________________________________________________________________________
TObject(),
fIterator(0x0)
{
+/// Standard constructor
+
TString opt(onWhatToIterate);
opt.ToLower();
if ( opt.Contains("digit") || opt.Contains("d") )
//_____________________________________________________________________________
AliMUONDataIterator::~AliMUONDataIterator()
{
+/// Destructor
+
delete fIterator;
}
TObject*
AliMUONDataIterator::Next()
{
+/// Set iterator to the next element
+
if (fIterator) return fIterator->Next();
return 0x0;
}
//_____________________________________________________________________________
Bool_t
AliMUONDataIterator::Remove()
-{
+{
+/// Remove current element
+
if (fIterator) return fIterator->Remove();
return kFALSE;
}
void
AliMUONDataIterator::Reset()
{
+/// Reset
+
if (fIterator) fIterator->Reset();
}
class AliMUONDataIterator : public TObject
{
public:
-
+ /// Iteration style
enum EIterationStyle { kAllChambers, kTrackingChambers, kTriggerChambers };
AliMUONDataIterator();
AliMUONVDataIterator* fIterator; //!< the real worker
private:
+ /// Not implemented
AliMUONDataIterator(const AliMUONDataIterator& rhs);
+ /// Not implemented
AliMUONDataIterator& operator=(const AliMUONDataIterator& rhs);
ClassDef(AliMUONDataIterator,0) // Iterator on MUON data structures.
AliMUONClusterFinderAZ *recModel, AliMUONSegmentation* segmentation); // constructor
virtual ~AliMUONDetElement(); // Destructor
- Int_t IdDE(void) const { return fidDE; } // det. elem. ID
- Int_t Chamber(void) const { return fChamber; } // chamber No
- Double_t Z(void) const { return fZ; } // Z-coordinate
- Int_t Left(Int_t cath) const { return fLeft[cath]; } // number of unused digits
- //Int_t GetMapElem(AliMUONDigit *digit) const; // get map element
- TObjArray *Digits(Int_t cath) const { return fDigits[cath]; } // array of digits
- TObjArray *RawClusters() const { return fRawClus; } // array of raw clusters
- TObjArray *HitsForRec() const { return fHitsForRec; } // hits for rec.
- Int_t NHitsForRec() const { return fNHitsForRec; } // No. of hits for rec.
+ Int_t IdDE(void) const { return fidDE; } ///< det. elem. ID
+ Int_t Chamber(void) const { return fChamber; } ///< chamber No
+ Double_t Z(void) const { return fZ; } ///< Z-coordinate
+ Int_t Left(Int_t cath) const { return fLeft[cath]; } ///< number of unused digits
+ //Int_t GetMapElem(AliMUONDigit *digit) const; ///< get map element
+ TObjArray *Digits(Int_t cath) const { return fDigits[cath]; } ///< array of digits
+ TObjArray *RawClusters() const { return fRawClus; } ///< array of raw clusters
+ TObjArray *HitsForRec() const { return fHitsForRec; } ///< hits for rec.
+ Int_t NHitsForRec() const { return fNHitsForRec; } ///< No. of hits for rec.
//Bool_t Inside(Double_t x, Double_t y, Double_t z) const; // check if point inside DE
Bool_t Inside(Double_t x, Double_t y, Double_t z, Double_t dx, Double_t dy) const; // check if point inside DE
- void SetID(Int_t idDE) { fidDE = idDE; } // set det. elem. ID
- void SetIndex(Int_t index) { fIndex = index; } // set position index
- void SetZ(Double_t z) { fZ = z; } // set Z-coord.
- void SetLeft(Int_t cath, Int_t left) { fLeft[cath] = left; } // set No. of digits
- //void SetMapElem(const AliMUONDigit *digit, Int_t flag); // set map element
- void AddDigit(AliMUONDigit *dig); // add digit
- void Fill(AliMUONData *data); // fill hit maps
- void ClusterReco(Double_t x, Double_t y, Double_t dx, Double_t dy); // run cluster reco around (x,y)
- void AddHitForRec(AliMUONRawCluster *clus); // make HitForRec
- // What is necessary for sorting TObjArray's
+ void SetID(Int_t idDE) { fidDE = idDE; } ///< set det. elem. ID
+ void SetIndex(Int_t index) { fIndex = index; } ///< set position index
+ void SetZ(Double_t z) { fZ = z; } ///< set Z-coord.
+ void SetLeft(Int_t cath, Int_t left) { fLeft[cath] = left; } ///< set No. of digits
+ //void SetMapElem(const AliMUONDigit *digit, Int_t flag); ///< set map element
+ void AddDigit(AliMUONDigit *dig); ///< add digit
+ void Fill(AliMUONData *data); ///< fill hit maps
+ void ClusterReco(Double_t x, Double_t y, Double_t dx, Double_t dy); ///< run cluster reco around (x,y)
+ void AddHitForRec(AliMUONRawCluster *clus); ///< make HitForRec
+ /// What is necessary for sorting TObjArray's
Bool_t IsSortable() const { return kTRUE; }
- Int_t Compare(const TObject* detElem) const; // "Compare" function for sorting
+ Int_t Compare(const TObject* detElem) const; ///< "Compare" function for sorting
private:
Int_t fidDE; ///< det. elem. ID
AliMUONClusterFinderAZ *fRecModel; ///< cluster finder
// Functions
+ /// Not implemented
AliMUONDetElement(const AliMUONDetElement & rhs); // copy constructor
+ /// Not implemented
AliMUONDetElement& operator = (const AliMUONDetElement& rhs); // assignment operator
ClassDef(AliMUONDetElement,0) // detection element object
void
AliMUONDigit::SetElectronics(Int_t manuId, Int_t manuChannel)
{
+ /// Set manuIs and manuChannel
+
//
//FIXME: should we check that the values are ok here ??
//
virtual Int_t PadY() const {return fPadY;} ///< Return pad number along y
virtual Int_t Cathode() const {return fCathode;} ///< Return cathode number
- virtual Float_t Signal() const {return fSignal;} ///< Return signal amplitude
+ virtual Float_t Signal() const {return fSignal;} ///< Return signal amplitude
- virtual Float_t Physics() const {return fPhysics;} ///< Return MC physics contribution to signal
+ virtual Float_t Physics() const {return fPhysics;} ///< Return MC physics contribution to signal
virtual Int_t Hit() const {return fHit;} ///< Return MC hit number
virtual Bool_t IsSaturated() const;
virtual Bool_t IsNoiseOnly() const;
virtual Bool_t IsEfficiencyApplied() const;
- virtual UInt_t StatusMap() const { return fStatusMap; }
+ virtual UInt_t StatusMap() const { return fStatusMap; } ///< Return Neighbouring pad status
virtual void NoiseOnly(Bool_t value=kTRUE);
virtual void Saturated(Bool_t saturated=kTRUE);
virtual void EfficiencyApplied(Bool_t value=kTRUE);
virtual void SetElectronics(Int_t manuId, Int_t manuChannel);
- virtual void SetADC(Int_t adc) { fADC=adc; }
+ virtual void SetADC(Int_t adc) {fADC=adc; } ///< Set ADC value
virtual void SetDetElemId(Int_t id) {fDetElemId = id;} ///< Set detection element ID
virtual void SetPadX(Int_t pad) {fPadX = pad;} ///< Set pad number along x
virtual void SetPadY(Int_t pad) {fPadY = pad;} ///< Set pad number along y
- virtual void SetSignal(Float_t q) {fSignal = q;} ///< Set signal amplitude
- virtual void AddSignal(Float_t q) {fSignal += q;} ///< Add signal amplitude
- virtual void AddPhysicsSignal(Float_t q) {fPhysics += q;} ///< Add MC physics contribution to signal
+ virtual void SetSignal(Float_t q) {fSignal = q;} ///< Set signal amplitude
+ virtual void AddSignal(Float_t q) {fSignal += q;} ///< Add signal amplitude
+ virtual void AddPhysicsSignal(Float_t q) {fPhysics += q;} ///< Add MC physics contribution to signal
virtual void SetHit(Int_t n) {fHit = n;} ///< Set MC hit number
virtual void SetCathode(Int_t c) {fCathode = c;} ///< Set cathode number
- virtual void SetPhysicsSignal(Float_t q) {fPhysics = q; } ///< Set MC physics contribution to signal
- virtual void SetStatusMap(UInt_t statusMap) { fStatusMap = statusMap; }
+ virtual void SetPhysicsSignal(Float_t q) {fPhysics = q; } ///< Set MC physics contribution to signal
+ virtual void SetStatusMap(UInt_t statusMap) { fStatusMap = statusMap; } ///< Set status map
virtual void Print(Option_t* opt="") const;
virtual void Exec(Option_t*);
private:
+ /// Not implemented
AliMUONDigitCalibrator(const AliMUONDigitCalibrator& other);
+ /// Not implemented
AliMUONDigitCalibrator& operator=(const AliMUONDigitCalibrator& other);
AliMUONData* fData; //!< MUON data
void SetCrateManager(AliMUONTriggerCrateStore* crateManager) {fCrateManager = crateManager;}
private:
+ /// Not implemented
+ AliMUONDigitMaker (const AliMUONDigitMaker& rhs); // copy constructor
+ /// Not implemented
+ AliMUONDigitMaker& operator=(const AliMUONDigitMaker& rhs); // assignment operator
+
+ void GetCrateName(Char_t* name, Int_t iDDL, Int_t iReg) const;
AliMUONData* fMUONData; //!< Data container for MUON subsystem
TStopwatch fTriggerTimer; //!< time watcher for trigger part
TStopwatch fMappingTimer; //!< time watcher for mapping-tracker part
- AliMUONDigitMaker (const AliMUONDigitMaker& rhs); // copy constructor
- AliMUONDigitMaker& operator=(const AliMUONDigitMaker& rhs); // assignment operator
-
- void GetCrateName(Char_t* name, Int_t iDDL, Int_t iReg) const;
-
ClassDef(AliMUONDigitMaker,1) // MUON digit maker from rawdata
};
virtual FlagType TestHit(Int_t ix, Int_t iy) const;
private:
+ /// Not implemented
AliMUONDigitMapA1(const AliMUONDigitMapA1 & hitMap);
- // Assignment operator
+ /// Not implemented
AliMUONDigitMapA1& operator = (const AliMUONDigitMapA1& rhs);
// Check index
virtual Bool_t Init();
private:
-
+ /// Not implemented
AliMUONDigitizerV3(const AliMUONDigitizerV3& other);
+ /// Not implemented
AliMUONDigitizerV3& operator=(const AliMUONDigitizerV3& other);
void AddOrUpdateDigit(TClonesArray& array,
TObjArray *Phits() {return fPhits;} ///< Return hit points for each chamber
TObjArray *Rpoints() {return fRpoints;} ///< Return cog points for each cathode
virtual void Paint(Option_t *option="");
- virtual void SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;} // *MENU*
- virtual void SetChamberAndCathode(Int_t chamber=1, Int_t cathode=1); // *MENU*
- virtual void SetDrawCoG(Bool_t draw=kTRUE) {fDrawCoG=draw;} // *MENU*
- virtual void SetDrawTracks(Bool_t draw=kTRUE) {fDrawTracks=draw;} // *MENU*
- virtual void SetRange(Float_t rrange=250., Float_t zrange=1050.); // *MENU*
- virtual void SetEvent(Int_t newevent=0); // *MENU*
+ virtual void SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;} ///< Set flag to draw clusters
+ virtual void SetChamberAndCathode(Int_t chamber=1, Int_t cathode=1); ///< Set chamber and cathod
+ virtual void SetDrawCoG(Bool_t draw=kTRUE) {fDrawCoG=draw;} ///< Set flag to draw CoG
+ virtual void SetDrawTracks(Bool_t draw=kTRUE) {fDrawTracks=draw;} ///< Set flag to draw tracks
+ virtual void SetRange(Float_t rrange=250., Float_t zrange=1050.);
+ virtual void SetEvent(Int_t newevent=0);
virtual void SetView(Float_t theta=0, Float_t phi=-90, Float_t psi=0);
virtual void SetPickMode();
virtual void SetZoomMode();
virtual void ShowNextEvent(Int_t delta=1);
- virtual void UnZoom(); // *MENU*
+ virtual void UnZoom();
virtual void ResetPoints();
virtual void ResetPhits();
virtual void ResetRpoints();
void Trigger();
protected:
+ /// Not implemented
AliMUONDisplay(const AliMUONDisplay& display);
+ /// Not implemented
AliMUONDisplay& operator = (const AliMUONDisplay& rhs);
virtual ~AliMUONDspHeader();
// DSP header
+ /// Return Data key word for FRT header
Int_t GetDataKey() const {return fDataKey;}
+ /// Return total length of block structure
Int_t GetTotalLength() const {return fTotalLength;}
+ /// Return length of raw data
Int_t GetLength() const {return fLength;}
+ /// Return Dsp id
Int_t GetDspId() const {return fDspId;}
+ /// Return L1 accept in Block Structure (CRT)
Int_t GetBlkL1ATrigger() const {return fBlkL1ATrigger;}
+ /// Return Mini Event Id in bunch crossing
Int_t GetMiniEventId() const {return fMiniEventId;}
+ /// Return Number of L1 accept in DSP Structure (FRT)
Int_t GetL1ATrigger() const {return fL1ATrigger;}
+ /// Return Number of L1 reject in DSP Structure (FRT)
Int_t GetL1RTrigger() const {return fL1RTrigger;}
+ /// Return padding dummy word for 64 bits transfer
UInt_t GetPaddingWord() const {return fPaddingWord;}
+ /// Return Error word
Int_t GetErrorWord() const {return fErrorWord;}
+ /// Return header length
Int_t GetHeaderLength() const {return fgkHeaderLength;}
+ /// Return default data key word for FRT header
UInt_t GetDefaultDataKey() const {return fgkDefaultDataKey;}
+ /// Return default padding word value
UInt_t GetDefaultPaddingWord() const {return fgkDefaultPaddingWord;}
+ /// Set Data key word for FRT header
void SetDataKey(Int_t d) {fDataKey = d;}
+ /// Set total length of block structure
void SetTotalLength(Int_t l) {fTotalLength = l;}
+ /// Set length of raw data
void SetLength(Int_t l) {fLength = l;}
+ /// Set Dsp id
void SetDspId(Int_t d) {fDspId = d;}
+ /// Set L1 accept in Block Structure (CRT)
void SetBlkL1ATrigger(Int_t l1) {fBlkL1ATrigger = l1;}
+ /// Set Mini Event Id in bunch crossing
void SetMiniEventId(Int_t id) {fMiniEventId = id;}
+ /// Set Number of L1 accept in DSP Structure (FRT)
void SetL1ATrigger(Int_t l1a) {fL1ATrigger = l1a;}
+ /// Set Number of L1 reject in DSP Structure (FRT)
void SetL1RTrigger(Int_t l1r) {fL1RTrigger = l1r;}
+ /// Set padding dummy word for 64 bits transfer
void SetPaddingWord(UInt_t w) {fPaddingWord = w;}
+ /// Set Error word
void SetErrorWord(Int_t w) {fErrorWord = w;}
+ /// Return header
Int_t* GetHeader() {return &fDataKey;}
void AddBusPatch(const AliMUONBusStruct& busPatch);
- // get TClonesArray
+ /// get TClonesArray
TClonesArray* GetBusPatchArray() const {return fBusPatchArray;}
- // get entries
+ /// get entries
Int_t GetBusPatchEntries() const {return fBusPatchArray->GetEntriesFast();}
- // get entry
+ /// get entry
AliMUONBusStruct* GetBusPatchEntry(Int_t i) const {
return (AliMUONBusStruct*)fBusPatchArray->At(i);}
void FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel); // fill event info
void FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const; // fill used rec. points from det. elems
- Int_t Nz() const { return fNZ; } // number of DE different Z-positions
- Double_t Z(Int_t iz) const { return (*fZ)[iz]; } // Z of DE
- Int_t *DEatZ(Int_t iz) const { return fDEvsZ[iz]+1; } // list of DE's at Z
- AliMUONDetElement *DetElem(Int_t iPos) const { return (AliMUONDetElement*) fDetElems->UncheckedAt(iPos); }
+ Int_t Nz() const { return fNZ; } ///< number of DE different Z-positions
+ Double_t Z(Int_t iz) const { return (*fZ)[iz]; } ///< Z of DE
+ Int_t *DEatZ(Int_t iz) const { return fDEvsZ[iz]+1; } ///< list of DE's at Z
+ AliMUONDetElement *DetElem(Int_t iPos) const { return (AliMUONDetElement*) fDetElems->UncheckedAt(iPos); } ///< Det element
Int_t IZfromHit(AliMUONHitForRec *hit) const; // IZ from Hit
protected:
AliMUONEventRecoCombi(AliMUONSegmentation* segmentation = 0);
private:
+ /// Not implemented
+ AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
+ /// Not implemented
+ AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
+
static AliMUONEventRecoCombi* fgRecoCombi; //!< singleton instance
AliMUONSegmentation* fSegmentation; //!< Segmentation
TClonesArray *fDetElems; //!< array of Det. Elem. objects
Int_t fNZ; //!< number of different Z's
Int_t **fDEvsZ; //!< list of DE's vs Z-coordinates
- AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
- AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
-
ClassDef(AliMUONEventRecoCombi, 0) // Combined cluster/track finder steering class
};
#endif
virtual UInt_t Process(TMap* /*dcsAliasMap*/);
private:
+ /// Not implemented
AliMUONGMSSubprocessor(const AliMUONGMSSubprocessor&);
+ /// Not implemented
AliMUONGMSSubprocessor& operator=(const AliMUONGMSSubprocessor&);
UInt_t ProcessFile(const TString& filename);
static const TString fgkMatrixArrayName; ///< The fixed matrix array name
// data members
- AliMUONGeometryTransformer fTransformer;///< Geometry transformer (used to get vo
+ AliMUONGeometryTransformer fTransformer;///< Geometry transformer
- ClassDef(AliMUONGMSSubprocessor, 1); // Shuttle sub-processor for GMS
+ ClassDef(AliMUONGMSSubprocessor, 1) // Shuttle sub-processor for GMS
};
#endif
protected:
+ /// Not implemented
AliMUONGeometry(const AliMUONGeometry& right);
+ /// Not implemented
AliMUONGeometry& operator = (const AliMUONGeometry& right);
private:
virtual void SetAlign(const TString& fileName, Bool_t align = true);
protected:
+ /// Not implemented
AliMUONGeometryBuilder(const AliMUONGeometryBuilder& right);
+ /// Not implemented
AliMUONGeometryBuilder& operator = (const AliMUONGeometryBuilder& right);
private:
const TGeoCombiTrans* GetTransformation() const;
protected:
+ /// Not implemented
AliMUONGeometryConstituent(const AliMUONGeometryConstituent& rhs);
+ /// Not implemented
AliMUONGeometryConstituent& operator = (const AliMUONGeometryConstituent& rhs);
private:
const TGeoHMatrix* GetGlobalTransformation() const;
protected:
+ /// Not implemented
AliMUONGeometryDetElement(const AliMUONGeometryDetElement& rhs);
+ /// Not implemented
AliMUONGeometryDetElement& operator = (const AliMUONGeometryDetElement& rhs);
private:
void PrintTransform(const TGeoHMatrix* transform) const;
// static data members
- static const TString fgkDENamePrefix; /// < Geometry module name prefix
+ static const TString fgkDENamePrefix; ///< Geometry module name prefix
// data members
TString fDEName; ///< detection element name
const TObjArray* GetConstituents() const;
protected:
+ /// Not implemented
AliMUONGeometryEnvelope(const AliMUONGeometryEnvelope& rhs);
+ /// Not implemented
AliMUONGeometryEnvelope& operator = (const AliMUONGeometryEnvelope& rhs);
private:
AliMUONGeometryEnvelope* FindEnvelope(const TString& name) const;
protected:
+ /// Not implemented
AliMUONGeometryEnvelopeStore(const AliMUONGeometryEnvelopeStore& rhs);
+ /// Not implemented
AliMUONGeometryEnvelopeStore& operator = (const AliMUONGeometryEnvelopeStore& rhs);
private:
{fUseGaus=!useuni; fUseUni=useuni;}
protected:
+ /// Not implemented
AliMUONGeometryMisAligner(const AliMUONGeometryMisAligner & right);
+ /// Not implemented
AliMUONGeometryMisAligner & operator =(const AliMUONGeometryMisAligner &right);
AliMUONGeometryModuleTransformer* GetTransformer() const;
protected:
+ /// Not implemented
AliMUONGeometryModule(const AliMUONGeometryModule& rhs);
+ /// Not implemented
AliMUONGeometryModule& operator = (const AliMUONGeometryModule& rhs);
private:
GetDetElement(Int_t detElemId, Bool_t warn = true) const;
protected:
+ /// Not implemented
AliMUONGeometryModuleTransformer(const AliMUONGeometryModuleTransformer& rhs);
+ /// Not implemented
AliMUONGeometryModuleTransformer&
operator = (const AliMUONGeometryModuleTransformer& rhs);
private:
// static data members
- static const TString fgkModuleNamePrefix; /// < Geometry module name prefix
+ static const TString fgkModuleNamePrefix; ///< Geometry module name prefix
// data members
Int_t fModuleId; ///< the module Id
virtual void Print(Option_t* opt = "") const;
protected:
+ /// Not implemented
AliMUONGeometrySegmentation(const AliMUONGeometrySegmentation& rhs);
+ /// Not implemented
AliMUONGeometrySegmentation& operator=(const AliMUONGeometrySegmentation & rhs);
private:
Bool_t HasDE(Int_t detElemId) const;
protected:
+ /// Not implemented
AliMUONGeometryTransformer(const AliMUONGeometryTransformer& right);
+ /// Not implemented
AliMUONGeometryTransformer& operator = (const AliMUONGeometryTransformer& right);
private:
//----------------------------------------------------------------------
void AliMUONGlobalTrigger::Print(Option_t* opt) const
{
- //
- // Printing Global Trigger information
- //
+ ///
+ /// Printing Global Trigger information
+ ///
TString sopt(opt);
sopt.ToUpper();
if ( sopt.Contains("FULL") ) {
/// - inputs are regional responses
/// - output is a 12-bit word
/// - 4 bits per trigger level
+/// \todo Change member functions comments in capital letters to normal text
///
/// \author Rachid Guernane (LPCCFd)
//___________________________________________
AliMUONGlobalTriggerBoard::AliMUONGlobalTriggerBoard()
{
+/// Default constructor
+
for (Int_t i=0;i<16;i++) fRegionalResponse[i] = 0;
}
//___________________________________________
AliMUONGlobalTriggerBoard::AliMUONGlobalTriggerBoard(const char *name, Int_t a) : AliMUONTriggerBoard(name, a)
{
+/// Standard constructor
+
for (Int_t i=0;i<16;i++) fRegionalResponse[i] = 0;
}
+//___________________________________________
+AliMUONGlobalTriggerBoard::~AliMUONGlobalTriggerBoard()
+{
+/// Destructor
+}
+
//___________________________________________
void AliMUONGlobalTriggerBoard::Mask(Int_t index, UShort_t mask)
{
- // MASK GLOBAL TRIGGER BOARD INPUT index WITH VALUE mask
+ /// MASK GLOBAL TRIGGER BOARD INPUT index WITH VALUE mask
if ( index>=0 && index < 16 )
{
fMask[index]=mask;
//___________________________________________
void AliMUONGlobalTriggerBoard::Response()
{
- // COMPUTE THE GLOBAL TRIGGER BOARD
- // RESPONSE ACCORDING TO THE Algo() METHOD
-/// output from global trigger algorithm
-/// [+, -, LS, US] * [Hpt, Lpt]
-/// transformed to [usHpt, usLpt, lsHpt, lsLpt, sHpt, sLpt] according
-/// to Global Trigger Unit user manual
+ /// COMPUTE THE GLOBAL TRIGGER BOARD
+ /// RESPONSE ACCORDING TO THE Algo() METHOD
+// output from global trigger algorithm
+// [+, -, LS, US] * [Hpt, Lpt]
+// transformed to [usHpt, usLpt, lsHpt, lsLpt, sHpt, sLpt] according
+// to Global Trigger Unit user manual
Int_t t[16];
for (Int_t i=0;i<16;i++) t[i] = fRegionalResponse[i] & fMask[i];
//___________________________________________
UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres)
{
- // GLOBAL TRIGGER ALGORITHM
+ /// GLOBAL TRIGGER ALGORITHM
TBits a(8), b(8); a.Set(8,&i); b.Set(8,&j);
TBits trg1(2), trg2(2), trg(2);
//___________________________________________
void AliMUONGlobalTriggerBoard::Scan(Option_t*) const
{
- // PRINT GLOBAL TRIGGER OUTPUT
+ /// PRINT GLOBAL TRIGGER OUTPUT
TBits w(8); w.Set(8,&fResponse);
// TRG[1:0]
/// \ingroup sim
/// \class AliMUONGlobalTriggerBoard
-/// \brief Global trigger
+/// \brief Global trigger board
///
// Author: Rachid Guernane (LPCCFd)
AliMUONGlobalTriggerBoard();
AliMUONGlobalTriggerBoard(const char *name, Int_t a);
- virtual ~AliMUONGlobalTriggerBoard() {;}
-
+ virtual ~AliMUONGlobalTriggerBoard();
+
+ /// Set regional board responses
virtual void SetRegionalResponse(UShort_t resp[16]) {for (Int_t i=0; i<16; i++) fRegionalResponse[i] = resp[i];}
virtual void Response();
virtual UShort_t Algo(UShort_t i, UShort_t j, char *thres);
-
+
+ /// Reset regional board responses
virtual void Reset() {for (Int_t i=0; i<16; i++) fRegionalResponse[i] = 0;}
virtual void Scan(Option_t *option) const;
+ /// \todo add comment
virtual void Resp(Option_t*) const {}
void Mask(Int_t index, UShort_t mask);
TObjArray* CompactAliases() const;
private:
+ /// Not implemented
AliMUONHVNamer(const AliMUONHVNamer& right);
+ /// Not implemented
AliMUONHVNamer& operator = (const AliMUONHVNamer& right);
- static const char* fgHVChannelSt345Pattern[]; // HV Channel name template
- static const char* fgHVChannelSt12Pattern[]; // HV Channel name template
- static const char* fgHVSwitchSt345Pattern; // HV Switch name template
+ static const char* fgHVChannelSt345Pattern[]; ///< HV Channel name template
+ static const char* fgHVChannelSt12Pattern[]; ///< HV Channel name template
+ static const char* fgHVSwitchSt345Pattern; ///< HV Switch name template
ClassDef(AliMUONHVNamer,0) // Utility class for coding/decoding DCS HV aliases
};
virtual UInt_t Process(TMap* dcsAliasMap);
private:
+ /// Not implemented
AliMUONHVSubprocessor(const AliMUONHVSubprocessor&);
+ /// Not implemented
AliMUONHVSubprocessor& operator=(const AliMUONHVSubprocessor&);
ClassDef(AliMUONHVSubprocessor,1) // Shuttle Subprocessor for MUON TRK HV
{
/// Copy constructor
+}
+
+ //__________________________________________________________________________
+AliMUONHitForRec::~AliMUONHitForRec()
+{
+/// Destructor
}
//__________________________________________________________________________
class AliMUONHitForRec : public TObject {
public:
AliMUONHitForRec(); // Constructor
- virtual ~AliMUONHitForRec(){} // Destructor
+ virtual ~AliMUONHitForRec(); // Destructor
AliMUONHitForRec (const AliMUONHitForRec& AliMUONHitForRec); // copy constructor
AliMUONHitForRec& operator=(const AliMUONHitForRec& AliMUONHitForRec); // assignment operator
AliMUONHitForRec(AliTrackReference* mHit); // Constructor from track ref. hit
AliMUONHitForRec(AliMUONRawCluster* theRawCluster); // Constructor from raw cluster
// Inline functions for Get and Set
+ /// Return coordinate (cm) in bending plane
Double_t GetBendingCoor(void) const { return fBendingCoor;}
+ /// Set coordinate (cm) in bending plane
void SetBendingCoor(Double_t BendingCoor) { fBendingCoor = BendingCoor;}
+ /// Return coordinate (cm) in non bending plane
Double_t GetNonBendingCoor(void) const { return fNonBendingCoor;}
+ /// Set coordinate (cm) in non bending plane
void SetNonBendingCoor(Double_t NonBendingCoor) { fNonBendingCoor = NonBendingCoor;}
+ /// Return Z coordinate (cm)
Double_t GetZ(void) const { return fZ;}
+ /// Set Z coordinate (cm)
void SetZ(Double_t Z) { fZ = Z;}
+ /// Return resolution**2 (cm**2) on coordinate in bending plane
Double_t GetBendingReso2(void) const { return fBendingReso2;}
+ /// Set resolution**2 (cm**2) on coordinate in bending plane
void SetBendingReso2(Double_t BendingReso2) { fBendingReso2 = BendingReso2;}
+ /// Return resolution**2 (cm**2) on coordinate in non bending plane
Double_t GetNonBendingReso2(void) const { return fNonBendingReso2;}
+ /// Set resolution**2 (cm**2) on coordinate in non bending plane
void SetNonBendingReso2(Double_t NonBendingReso2) { fNonBendingReso2 = NonBendingReso2;}
+ /// Return chamber number (0...)
Int_t GetChamberNumber(void) const { return fChamberNumber;}
+ /// Set chamber number (0...)
void SetChamberNumber(Int_t ChamberNumber) { fChamberNumber = ChamberNumber;}
+ /// Return detection element Id
Int_t GetDetElemId(void) const {return fDetElemId;}
+ /// Set detection element Id
void SetDetElemId(Int_t id) { fDetElemId = id;}
+ /// Return hit number (0...)
Int_t GetHitNumber(void) const { return fHitNumber;}
+ /// Set hit number (0...)
void SetHitNumber(Int_t HitNumber) { fHitNumber = HitNumber;}
+ /// Return track number (0...) in TTR
Int_t GetTTRTrack(void) const { return fTTRTrack;}
+ /// Set track number (0...) in TTR
void SetTTRTrack(Int_t TTRTrack) { fTTRTrack = TTRTrack;}
+ /// Return Track ref. signal (1) or background (0)
Int_t GetTrackRefSignal(void) const { return fTrackRefSignal;}
+ /// Set Track ref. signal (1) or background (0)
void SetTrackRefSignal(Int_t TrackRefSignal) { fTrackRefSignal = TrackRefSignal;}
+ /// Return number of TrackHit's made with HitForRec
Int_t GetNTrackHits(void) const { return fNTrackHits;}
+ /// Set number of TrackHit's made with HitForRec
void SetNTrackHits(Int_t NTrackHits) { fNTrackHits = NTrackHits;}
Double_t NormalizedChi2WithHitForRec(AliMUONHitForRec* Hit, Double_t Sigma2Cut) const;
- // What is necessary for sorting TClonesArray's; sufficient too ????
+ /// What is necessary for sorting TClonesArray's; sufficient too ????
Bool_t IsSortable() const { return kTRUE; }
Int_t Compare(const TObject* HitForRec) const; // "Compare" function for sorting
virtual FlagType TestHit(Int_t ix, Int_t iy);
private:
+ /// Not implemented
AliMUONHitMapA1(const AliMUONHitMapA1 & hitMap);
- // Assignment operator
+ /// Not implemented
AliMUONHitMapA1& operator = (const AliMUONHitMapA1& rhs);
// Check index
AliMUONData * GetMUONData();
protected:
+ /// Not implemented
AliMUONLoader(const AliMUONLoader& rhs);
+ /// Not implemented
AliMUONLoader& operator=(const AliMUONLoader& rhs);
AliMUONData * fMUONData; ///< data for MUON subsystem
- private:
- //descendant classes should
- //use protected interface methods to access these folders
-
- /**********************************************/
- /*********** P U B L I C **************/
- /********* S T A T I C ************/
- /********* METHODS ************/
- /********* They are used by ************/
- /*********** AliRunLoader as well**************/
- /**********************************************/
-
ClassDef(AliMUONLoader,1)
};
}
+
+//___________________________________________
+AliMUONLocalStruct::~AliMUONLocalStruct()
+{
+/// Destructor
+}
+
//___________________________________________
AliMUONLocalStruct&
AliMUONLocalStruct::operator=(const AliMUONLocalStruct& event)
AliMUONLocalStruct& operator=(const AliMUONLocalStruct& event);
- virtual ~AliMUONLocalStruct(){;}
+ virtual ~AliMUONLocalStruct();
// local board info
+ /// Return local data
UInt_t GetData(Int_t n) const {return fData[n];}
+ /// Return X2
UShort_t GetX2() const {return (fData[0] >> 16) & 0xFFFF;}
+ /// Return X1
UShort_t GetX1() const {return (fData[0]) & 0xFFFF;}
+ /// Return X4
UShort_t GetX4() const {return (fData[1] >> 16) & 0xFFFF;}
+ /// Return X3
UShort_t GetX3() const {return (fData[1]) & 0xFFFF;}
+ /// Return Y2
UShort_t GetY2() const {return (fData[2] >> 16) & 0xFFFF;}
+ /// Return Y1
UShort_t GetY1() const {return (fData[2]) & 0xFFFF;}
+ /// Return Y4
UShort_t GetY4() const {return (fData[3] >> 16) & 0xFFFF;}
+ /// Return Y3
UShort_t GetY3() const {return (fData[3]) & 0xFFFF;}
+ /// Return Id
UChar_t GetId() const {return fData[4] >> 19 & 0xF;}
+ /// Return Dec
UChar_t GetDec() const {return fData[4] >> 15 & 0xF;}
+ /// Return TriggerY
Bool_t GetTriggerY() const {return (fData[4] >> 14 & 0x1);}
+ /// Return Upos
UChar_t GetYPos() const {return fData[4] >> 10 & 0xF;}
+ /// Return Xdev
UChar_t GetXDev() const {return fData[4] >> 5 & 0x1F;}
+ /// Return TriggerX
Bool_t GetTriggerX() const {return ((GetXDev() >> 4 & 0x1) && !(GetXDev() & 0xF));}
+ /// Return Xpos
UChar_t GetXPos() const {return fData[4] & 0x1F;}
+ /// Return LPT
Int_t GetLpt() const {return (GetDec() & 0x3);}
+ /// Return HPT
Int_t GetHpt() const {return (GetDec() >> 2) & 0x3;}
+ /// Set local data
void SetData(UInt_t d, Int_t n) {fData[n] = d;}
+ /// Return data
UInt_t* GetData() {return &fData[0];}
// Scaler methods
+ /// Return local L0
UInt_t GetL0() const {return fL0;}
+ /// Return local hold (dead time)
UInt_t GetHold() const {return fHold;}
+ /// Return local clock
UInt_t GetClock() const {return fClk;}
+ /// Return switch
UChar_t GetSwitch() const {return (fEOS >> 2) & 0x3FF;}
+ /// Return ComptXY
UChar_t GetComptXY() const {return fEOS & 3;}
+ /// Return XY1
UShort_t GetXY1(Int_t n) const {return (n % 2 == 0) ?
(fScaler[TMath::Nint(Float_t(n/2))] & 0xFFFF) :
(fScaler[TMath::Nint(Float_t(n/2))] >> 16) & 0xFFFF;}
+ /// Return XY2
UShort_t GetXY2(Int_t n) const {return (n % 2 == 0) ?
(fScaler[8 + TMath::Nint(Float_t(n/2))] & 0xFFFF) :
(fScaler[8 + TMath::Nint(Float_t(n/2))] >> 16) & 0xFFFF;}
+ /// Return XY3
UShort_t GetXY3(Int_t n) const {return (n % 2 == 0) ?
(fScaler[8*2 + TMath::Nint(Float_t(n/2))] & 0xFFFF) :
(fScaler[8*2 + TMath::Nint(Float_t(n/2))] >> 16) & 0xFFFF;}
+ /// Return XY4
UShort_t GetXY4(Int_t n) const {return (n % 2 == 0) ?
(fScaler[8*3 + TMath::Nint(Float_t(n/2))] & 0xFFFF) :
(fScaler[8*3 + TMath::Nint(Float_t(n/2))] >> 16) & 0xFFFF;}
+ /// Return scalers
UInt_t* GetScalers() {return &fL0;}
// get length
+ /// Return scaler length in word
Int_t GetScalerLength() const {return fgkScalerLength;}
+ /// Return local info length in word
Int_t GetLength() const {return fgkLength;}
+ /// Return end of local info word
UInt_t GetEndOfLocal() const {return fgkEndOfLocal;}
+ /// Return Word for "empty" slots
UInt_t GetDisableWord() const {return fgkDisableWord;}
- // set random numbers to fill variable
+ // set random numbers to fill variable
void SetScalersNumbers();
private:
/// Copy constructor (useful for TClonesArray)
}
+
+//----------------------------------------------------------------------
+AliMUONLocalTrigger::~AliMUONLocalTrigger()
+{
+/// Destructor
+}
+
//----------------------------------------------------------------------
AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& theMUONLocalTrig)
{
//----------------------------------------------------------------------
void AliMUONLocalTrigger::Print(Option_t* opt) const
{
- //
- // Printing Local Trigger information
- //
+/// Printing Local Trigger information
+
TString sopt(opt);
sopt.ToUpper();
public:
AliMUONLocalTrigger();
AliMUONLocalTrigger(const AliMUONLocalTrigger& rhs); // copy constructor !
- virtual ~AliMUONLocalTrigger(){;}
+ virtual ~AliMUONLocalTrigger();
AliMUONLocalTrigger& operator=(const AliMUONLocalTrigger& rhs);
// getter methods
/* $Id$ */
-//_________________________________________________________________________
-// Implementation of local trigger board objects
-// A local trigger board has as input a bit pattern and returns
-// the local trigger response after comparison w/ a LUT
-//*-- Author: Rachid Guernane (LPCCFd)
-//*
-//*
+/// \class AliMUONLocalTriggerBoard
+/// A local trigger board has as input a bit pattern and returns
+/// the local trigger response after comparison w/ a LUT
+/// \todo Change member functions comments in capital letters to normal text
+///
+/// \author Rachid Guernane (LPCCFd)
#include "AliMUONLocalTriggerBoard.h"
#include "AliMUONTriggerLut.h"
#include <TBits.h>
#include <Riostream.h>
+/// \cond CLASSIMP
+ClassImp(AliMUONLocalTriggerBoard)
+/// \endcond
+
const Int_t AliMUONLocalTriggerBoard::fgkCircuitId[234] =
{
111, 121, 131, 141, 151, 161, 171,
fLUT(0x0),
fCoinc44(0)
{
-//* constructor
-//*
+/// Default constructor
+///
for (Int_t i=0; i<2; i++)
for (Int_t j=0; j<4; j++)
fLUT(lut),
fCoinc44(0)
{
-//* constructor
-//*
+/// Standard constructor
+///
for (Int_t i=0; i<2; i++)
for (Int_t j=0; j<4; j++)
for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
}
-//______________________________________________________________________________
-AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right)
- : AliMUONTriggerBoard(right),
- fNumber(right.fNumber),
- fCrate(right.fCrate),
- fTC(right.fTC),
- fStripX11(right.fStripX11),
- fStripY11(right.fStripY11),
- fDev(right.fDev),
- fOutput(right.fOutput),
- fLUT(right.fLUT),
- fCoinc44(right.fCoinc44)
-{
-/// Protected copy constructor (not implemented)
-
- AliFatal("Copy constructor not provided.");
-}
-
-//______________________________________________________________________________
-AliMUONLocalTriggerBoard&
-AliMUONLocalTriggerBoard::operator=(const AliMUONLocalTriggerBoard& right)
+//___________________________________________
+AliMUONLocalTriggerBoard::~AliMUONLocalTriggerBoard()
{
-/// Protected assignement operator (not implemented)
-
- // check assignement to self
- if (this == &right) return *this;
-
- AliFatal("Assignement operator not provided.");
-
- return *this;
-}
+/// Destructor
+}
//___________________________________________
void AliMUONLocalTriggerBoard::Reset()
{
-//* reset board
-//*
+/// reset board
+///
for (Int_t i=0; i<2; i++)
for (Int_t j=0; j<4; j++)
fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
//___________________________________________
void AliMUONLocalTriggerBoard::Setbit(Int_t strip, Int_t cathode, Int_t chamber)
{
-// 0 .. LBS : N-1 .. MSB
+/// 0 .. LBS : N-1 .. MSB
TBits w, m;
UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
//___________________________________________
void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber)
{
-// 0 .. LBS : N-1 .. MSB
+/// 0 .. LBS : N-1 .. MSB
TBits w, m;
UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
//___________________________________________
void AliMUONLocalTriggerBoard::Pattern(Option_t *option) const
{
-//* print bit pattern
-//*
+/// print bit pattern
+///
TString op = option;
if (op.Contains("X")) BP("X");
//___________________________________________
void AliMUONLocalTriggerBoard::BP(Option_t *option) const
{
-// RESPECT THE OLD PRINTOUT FORMAT
+/// RESPECT THE OLD PRINTOUT FORMAT
const Int_t kModuleId[126] =
{11,12,13,14,15,16,17, // right side of the chamber
//___________________________________________
void AliMUONLocalTriggerBoard::Conf() const
{
-//* board switches
-//*
+/// board switches
+///
cout << "Switch(" << GetName() << ")"
<< " x2d = " << fSwitch[0]
<< " x2m = " << fSwitch[1]
//___________________________________________
void AliMUONLocalTriggerBoard::Module(char *mod)
{
-//* get module from name
-//*
+/// get module from name
+///
const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
char s[100]; strcpy(s, GetName());
//___________________________________________
void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[32], Int_t ch4q[32])
{
-// note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4)
-//---------------------------------------------------------
-// step # 1 : declustering, reduction DS, calculate sgle & dble
-//---------------------------------------------------------
+/// note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4) \n
+///--------------------------------------------------------- \n
+/// step # 1 : declustering, reduction DS, calculate sgle & dble \n
+///---------------------------------------------------------
Int_t ch1e[19], ch2e[20], ch3e[35], ch4e[36];
Int_t sgleHit1[31], sgleHit2[63];
Int_t dbleHit1[31], dbleHit2[63];
void AliMUONLocalTriggerBoard::Sort2x5(Int_t dev1[6], Int_t dev2[6],
Int_t minDev[6], Int_t &dev1GTdev2)
{
-// returns minimun between dev1 and dev2
+/// returns minimun between dev1 and dev2
Int_t tmpDev1=0, tmpDev2=0;
for (Int_t j=0; j<5; j++)
void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], Int_t y4[16],
Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16])
{
-// note : resMid = 1 -> cancel
-//---------------------------------------------------------
-// step # 1 : prehandling Y
-//---------------------------------------------------------
+/// note : resMid = 1 -> cancel \n
+///---------------------------------------------------------\n
+/// step # 1 : prehandling Y \n
+///---------------------------------------------------------
Int_t i;
Int_t istrip;
//___________________________________________
void AliMUONLocalTriggerBoard::LocalTrigger()
{
-//* L0 trigger after LUT
-//*
+/// L0 trigger after LUT
+///
Int_t deviation=0, iStripY=0, iStripX=0;
for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
//___________________________________________
Int_t AliMUONLocalTriggerBoard::GetI() const
{
-//* old numbering
-//*
+/// old numbering
+///
const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
char s[100]; strcpy(s, GetName());
//___________________________________________
void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
{
-//* set mask
-//*
+/// set mask
+///
if ( index >= 0 && index < 2*4 )
{
Int_t i = index/4;
//___________________________________________
void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
{
-//* full dump
-//*
+/// full dump
+///
TString op = option;
if (op.Contains("CONF")) Conf();
//___________________________________________
void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
{
-//* board I/O
-//*
+/// board I/O
+///
TString op = option;
if (op.Contains("I"))
//___________________________________________
void AliMUONLocalTriggerBoard::Response()
{
-//* algo
-//*
+/// algo
+///
Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
TBits x1(16), x2(16), x3(16), x4(16);
static_cast<int>(fLutHpt[1]<<3);
}
-ClassImp(AliMUONLocalTriggerBoard)
-
/// \class AliMUONLocalTriggerBoard
/// \brief Implementation of local trigger board objects
///
-/// A local trigger board has as input a bit pattern and returns
-/// the local trigger response after comparison w/ a LUT
-///
-/// \author Rachid Guernane (LPCCFd)
+// Author Rachid Guernane (LPCCFd)
#include "AliMUONTriggerBoard.h"
{
public:
+ /// \todo add comment
enum ESwitch {
kX2d = 0,
kX2m,
AliMUONLocalTriggerBoard();
AliMUONLocalTriggerBoard(const char *name, Int_t a, AliMUONTriggerLut* lut);
- virtual ~AliMUONLocalTriggerBoard() {;}
-
- Bool_t HasLUT() const { return (fLUT != 0); }
+ virtual ~AliMUONLocalTriggerBoard();
- void SetLUT(AliMUONTriggerLut* lut) { fLUT = lut; }
- void SetCoinc44(Int_t coinc44=0) { fCoinc44 = coinc44; }
+ /// Return true if LUT is set
+ Bool_t HasLUT() const { return (fLUT != 0); }
+
+ /// Set LUT
+ void SetLUT(AliMUONTriggerLut* lut) { fLUT = lut; }
+ /// Set Coinc 44 (0/1 = coinc34/coinc44)
+ void SetCoinc44(Int_t coinc44=0) { fCoinc44 = coinc44; }
virtual void Setbit(Int_t strip, Int_t cathode, Int_t chamber);
virtual void SetbitM(Int_t strip, Int_t cathode, Int_t chamber);
virtual void Reset();
+ /// Set i-th Switch value
virtual void SetSwitch(Int_t i, Int_t value) {fSwitch[i] = value;}
+ /// Return i-th Switch value
virtual UShort_t GetSwitch(Int_t i) const {return fSwitch[i];}
+ /// Set Transverse connector
virtual void SetTC(Bool_t con) {fTC = con;}
+ /// Return Transverse connector
virtual Bool_t GetTC() const {return fTC;}
+ /// Set Board number
virtual void SetNumber(Int_t nb) {fNumber = nb;}
+ /// Return Board number
virtual Int_t GetNumber() const {return fNumber;}
virtual void Module(char *mod);
+ /// Return X34
virtual void GetX34(UShort_t *X) const {for (Int_t i=0;i<2;i++) X[i] = fXY[0][i+2];}
+ /// Set X34
virtual void SetX34(UShort_t *X) {for (Int_t i=0;i<2;i++) fXY[0][i+2] = X[i];}
+ /// Return Y
virtual void GetY(UShort_t *Y) const {for (Int_t i=0;i<4;i++) Y[i] = fXY[1][i];}
+ /// Set Y
virtual void SetY(UShort_t *Y) {for (Int_t i=0;i<4;i++) fXY[1][i] = Y[i];}
+ /// Return XY
virtual void GetXY(UShort_t XY[2][4]) const {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) XY[i][j] = fXY[i][j];}
+ /// Return XY
virtual UShort_t GetXY(Int_t i, Int_t j) const {return fXY[i][j];}
+ /// Set XY
virtual void SetXY(UShort_t XY[2][4]) {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) fXY[i][j] = XY[i][j];}
virtual void Conf() const;
virtual void TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], Int_t y4[16],
Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16]);
+ /// Set XYU
virtual void SetXYU(UShort_t V[2][4]) {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) fXYU[i][j] = V[i][j];}
+ /// Set XYD
virtual void SetXYD(UShort_t V[2][4]) {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) fXYD[i][j] = V[i][j];}
virtual void Scan(Option_t *option = "") const;
virtual void LocalTrigger();
+ /// Return info if Board has triggered
virtual Int_t Triggered() const {return fOutput;}
+ /// Return MT1 X position of the valid road
virtual Int_t GetStripX11() const {return fStripX11;}
+ /// Return MT1 Y position of the valid road
virtual Int_t GetStripY11() const {return fStripY11;}
+ /// Return Deviation in [0;+30]
virtual Int_t GetDev() const {return fDev;}
+ /// Set Crate name
virtual void SetCrate(TString crate) {fCrate = crate;}
+ /// Return Crate name
virtual TString GetCrate() const {return fCrate;}
protected:
- AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right);
- AliMUONLocalTriggerBoard& operator = (const AliMUONLocalTriggerBoard& right);
-
- static const Int_t fgkCircuitId[234]; // old numbering (to be removed)
- virtual void Resp(Option_t *option) const; // local trigger info before ("I") and after ("F") LUT
+ static const Int_t fgkCircuitId[234]; ///< old numbering (to be removed)
+
+ virtual void Resp(Option_t *option) const; ///< local trigger info before ("I") and after ("F") LUT
- virtual void BP(Option_t *option) const; // display X/Y bp
+ virtual void BP(Option_t *option) const; ///< display X/Y bp
private:
+ /// Not implemented
+ AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right);
+ /// Not implemented
+ AliMUONLocalTriggerBoard& operator = (const AliMUONLocalTriggerBoard& right);
Int_t fNumber; ///< Board number
///
/// \author Laurent Aphecetche
+/// \cond CLASSIMP
ClassImp(AliMUONLogger)
+/// \endcond
//_____________________________________________________________________________
AliMUONLogger::AliMUONLogger(Int_t maxNumberOfEntries)
void Print(Option_t* opt="") const;
private:
-
+ /// Not implemented
AliMUONLogger(const AliMUONLogger& rhs); // not implemented
+ /// Not implemented
AliMUONLogger& operator=(const AliMUONLogger& rhs); // not implemented
private:
virtual ~AliMUONObjectPair();
+ /// Return the first element of the pair
TObject* First() const { return fFirst; }
+ /// Return the second element of the pair
TObject* Second() const { return fSecond; }
+ /// Return the first element of the pair
TObject* Key() const { return fFirst; }
+ /// Return the second element of the pair
TObject* Value() const { return fSecond; }
virtual void Copy(TObject& other) const;
Init(-1,-1,-1,-1,position,dimensions,charge);
}
+//_____________________________________________________________________________
+AliMUONPad::~AliMUONPad()
+{
+/// Dtor
+}
+
//_____________________________________________________________________________
Bool_t
AliMUONPad::AreNeighbours(const AliMUONPad& d1, const AliMUONPad& d2)
AliMUONPad(Int_t detElemId, Int_t cathode,
Int_t ix, Int_t iy, Double_t x, Double_t y,
Double_t dx, Double_t dy, Double_t charge);
- virtual ~AliMUONPad() {}
+ virtual ~AliMUONPad();
+ /// \brief Backup charge
+ /// Usefull if clustering somehow plays with the charge, this one is the "original" one
void BackupCharge() { fChargeBackup = fCharge; }
+ /// Return cathode number
Int_t Cathode() const { return fCathode; }
Double_t Coord(Int_t ixy) const;
+ /// Return pad charge
Double_t Charge() const { return fCharge; }
+ /// Return backup charge
Double_t ChargeBackup() const { return fChargeBackup; }
virtual Int_t Compare(const TObject* obj) const;
+ /// Return detection element id
Int_t DetElemId() const { return fDetElemId; }
+ /// \brief Return corresponding digit index
+ /// To get back the digit from which this pad was constructed, if needed
Int_t DigitIndex() const { return fDigitIndex; }
+ /// Return half dimensions in x and y (cm)
TVector2 Dimensions() const { return fDimensions; }
+ /// Return half dimensions in x (cm)
Double_t DX() const { return fDimensions.X(); }
+ /// Return half dimensions in y (cm)
Double_t DY() const { return fDimensions.Y(); }
+ /// Return info whether this is a real pad or a virtual one
Bool_t IsReal() const { return fIsReal; }
+ /// Return info whether this pad is saturated or not
Bool_t IsSaturated() const { return fIsSaturated; }
+ /// Return true as the function Sort is implemented
Bool_t IsSortable() const { return kTRUE; }
+ /// Return true if is used
Bool_t IsUsed() const { return fClusterId >= 0; }
+ /// Return x-index
Int_t Ix() const { return fIx; }
+ /// Return y-index
Int_t Iy() const { return fIy; }
virtual void Paint(Option_t* opt="");
+ /// Return positions in x and y (cm)
TVector2 Position() const { return fPosition; }
void Print(Option_t* opt = "") const;
- // Detach this pad from a cluster
+ /// Detach this pad from a cluster
void Release() { fClusterId = -1; }
+ /// Set charge to value in backup charge
void RevertCharge() { fCharge = fChargeBackup; }
+ /// Set charge
void SetCharge(Double_t charge) { fCharge = charge; }
+ /// Set charge backup
void SetChargeBackup(Double_t charge) { fChargeBackup = charge; }
void SetCoord(Int_t ixy, Double_t Coord);
+ /// \brief Set corresponding digit index
+ /// To get back the digit from which this pad was constructed, if needed
void SetDigitIndex(Int_t digitIndex) { fDigitIndex = digitIndex; }
+ /// Set status word
void SetStatus(Int_t status) { fStatus = status; }
+ /// \brief Set cluster id this pad belongs to
+ /// -1 if not attached to a cluster
void SetClusterId(Int_t id) { fClusterId = id; }
+ /// Set info whether this pad is saturated or not
void SetSaturated(Bool_t val) { fIsSaturated = val; }
void SetSize(Int_t ixy, Double_t Size);
+ /// Set info whether this is a real pad or a virtual one
void SetReal(Bool_t val) { fIsReal = val; }
void Shift(Int_t ixy, Double_t shift);
Double_t Size(Int_t ixy) const;
+ /// Return status word
Int_t Status() const { return fStatus; }
+ /// Return position in x (cm)
Double_t X() const { return fPosition.X(); }
+ /// Return position in y (cm)
Double_t Y() const { return fPosition.Y(); }
static AliMpArea Overlap(const AliMUONPad& d1, const AliMUONPad& d2);
Double_t charge);
private:
- Bool_t fIsSaturated; /// whether this pad is saturated or not
- Bool_t fIsReal; /// whether this is a real pad or a virtual one
- Int_t fClusterId; /// cluster id this pad belongs to (-1 if not attached to a cluster)
- Int_t fCathode; /// cathode number
- Int_t fDetElemId; /// detection element id
- Int_t fDigitIndex; /// corresponding digit index (to get back the digit from which this pad was constructed, if needed)
- Int_t fIx; /// x-index
- Int_t fIy; /// y-index
- Int_t fStatus; /// status word
- TVector2 fDimensions; /// half dimensions in x and y (cm)
- TVector2 fPosition; /// positions in x and y (cm)
- Double_t fCharge; /// pad charge
- Double_t fChargeBackup; /// backup charge (usefull if clustering somehow plays with the charge, this one is the "original" one)
+ Bool_t fIsSaturated; ///< whether this pad is saturated or not
+ Bool_t fIsReal; ///< whether this is a real pad or a virtual one
+ Int_t fClusterId; ///< cluster id this pad belongs to (-1 if not attached to a cluster)
+ Int_t fCathode; ///< cathode number
+ Int_t fDetElemId; ///< detection element id
+ Int_t fDigitIndex; ///< corresponding digit index (to get back the digit from which this pad was constructed, if needed)
+ Int_t fIx; ///< x-index
+ Int_t fIy; ///< y-index
+ Int_t fStatus; ///< status word
+ TVector2 fDimensions; ///< half dimensions in x and y (cm)
+ TVector2 fPosition; ///< positions in x and y (cm)
+ Double_t fCharge; ///< pad charge
+ Double_t fChargeBackup; ///< backup charge (usefull if clustering somehow plays with the charge, this one is the "original" one)
ClassDef(AliMUONPad,1) // A full grown pad
};
fHVSt12Limits(0,5000),
fHVSt345Limits(0,5000)
{
- // ctor
+ /// ctor
}
//_____________________________________________________________________________
AliMUONPadStatusMaker::~AliMUONPadStatusMaker()
{
- // dtor.
+ /// dtor.
}
//_____________________________________________________________________________
static AliMUONV2DStore* GeneratePadStatus(Int_t value);
+ /// Return Low and High threshold for St12 HV
TVector2 HVSt12Limits() const { return fHVSt12Limits; }
+ /// Return Low and High threshold for St345 HV
TVector2 HVSt345Limits() const { return fHVSt345Limits; }
+ /// Return Low and High threshold for pedestal mean
TVector2 PedMeanLimits() const { return fPedMeanLimits; }
+ /// Return Low and High threshold for pedestal sigma
TVector2 PedSigmaLimits() const { return fPedSigmaLimits; }
+ /// Set Low and High threshold for St12 HV
void SetHVSt12Limits(float low, float high) { fHVSt12Limits.Set(low,high); }
+ /// Set Low and High threshold for St345 HV
void SetHVSt345Limits(float low, float high) { fHVSt345Limits.Set(low,high); }
+ /// Set Low and High threshold for pedestal mean
void SetPedMeanLimits(float low, float high) { fPedMeanLimits.Set(low,high); }
+ /// Set Low and High threshold for pedestal sigma
void SetPedSigmaLimits(float low, float high) { fPedSigmaLimits.Set(low,high); }
private:
+ /// Not implemented
AliMUONPadStatusMaker(const AliMUONPadStatusMaker&);
+ /// Not implemented
AliMUONPadStatusMaker& operator=(const AliMUONPadStatusMaker&);
private:
private:
-
+ /// General status
enum EGeneralStatus
{
kMissing = (1<<7)
};
+ /// Pedestal status
enum EPedestalStatus
{
kPedOK = 0,
kPedMissing = kMissing // please always use last bit for meaning "missing"
};
+ /// HV Error
enum EHVError
{
kHVOK = 0,
fBlockHeader(new AliMUONBlockHeader()),
fDspHeader(new AliMUONDspHeader())
{
- //
- // create an object to decode MUON payload
- //
+ ///
+ /// create an object to decode MUON payload
+ ///
}
//___________________________________
AliMUONPayloadTracker::~AliMUONPayloadTracker()
{
- //
- // clean up
- //
+ ///
+ /// clean up
+ ///
delete fDDLTracker;
delete fBusStruct;
delete fBlockHeader;
Bool_t AliMUONPayloadTracker::Decode(UInt_t* buffer, Int_t totalDDLSize)
{
- // Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most
- // and each of DSP has at most 5 buspatches.
- // The different structures, Block (CRT), DSP (FRT) and Buspatch,
- // are identified by a key word 0xFC0000FC, 0xF000000F and 0xB000000B respectively.
- // (fBusPatchManager no more needed !)
+ /// Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most
+ /// and each of DSP has at most 5 buspatches.
+ /// The different structures, Block (CRT), DSP (FRT) and Buspatch,
+ /// are identified by a key word 0xFC0000FC, 0xF000000F and 0xB000000B respectively.
+ /// (fBusPatchManager no more needed !)
//Read Header Size of DDL,Block,DSP and BusPatch
//______________________________________________________
void AliMUONPayloadTracker::ResetDDL()
{
- // reseting TClonesArray
- // after each DDL
- //
+ /// reseting TClonesArray
+ /// after each DDL
+ ///
fDDLTracker->GetBlkHeaderArray()->Delete();
}
//______________________________________________________
void AliMUONPayloadTracker::SetMaxBlock(Int_t blk)
{
- // set regional card number
+ /// set regional card number
if (blk > 2) blk = 2;
fMaxBlock = blk;
}
//______________________________________________________
Bool_t AliMUONPayloadTracker::CheckDataParity()
{
- // parity check
- // taken from MuTrkBusPatch.cxx (sotfware test for CROCUS)
- // A. Baldisseri
+ /// parity check
+ /// taken from MuTrkBusPatch.cxx (sotfware test for CROCUS)
+ /// A. Baldisseri
Int_t parity;
UInt_t data;
AliMUONPayloadTracker();
virtual ~AliMUONPayloadTracker();
+ /// Return maximum number of block per DDL in DATE file
Int_t GetMaxBlock() const {return fMaxBlock;}
+ /// Return maximum number of Dsp per block in DATE file
Int_t GetMaxDsp() const {return fMaxDsp;}
+ /// Return maximum number of Buspatch per Dsp in DATE file
Int_t GetMaxBus() const {return fMaxBus;}
// check input before assigment
void SetMaxBlock(Int_t blk);
- // does not check, done via BusPatchManager
+ /// \brief Set maximum number of Dsp per block in DATE file
+ /// does not check, done via BusPatchManager
void SetMaxDsp(Int_t dsp) {fMaxDsp = dsp;}
+ /// \brief Set maximum number of Buspatch per Dsp in DATE file
+ /// does not check, done via BusPatchManager
void SetMaxBus(Int_t bus) {fMaxBus = bus;}
void ResetDDL();
Bool_t Decode(UInt_t* buffer, Int_t datasize);
+ /// Return pointer for local structure
AliMUONBusStruct* GetBusPatchInfo() const {return fBusStruct;}
+ /// Return pointer for buspatch structure
AliMUONDDLTracker* GetDDLTracker() const {return fDDLTracker;}
private :
+ /// Not implemented
+ AliMUONPayloadTracker(const AliMUONPayloadTracker& stream);
+ /// Not implemented
+ AliMUONPayloadTracker& operator = (const AliMUONPayloadTracker& stream);
+
+ Bool_t CheckDataParity();
Int_t fBusPatchId; ///< entry of buspatch structure
Int_t fDspId; ///< entry of Dsp header
AliMUONBlockHeader* fBlockHeader; //!< pointer for block structure
AliMUONDspHeader* fDspHeader; //!< pointer for dsp structure
- AliMUONPayloadTracker(const AliMUONPayloadTracker& stream);
- AliMUONPayloadTracker& operator = (const AliMUONPayloadTracker& stream);
-
- Bool_t CheckDataParity();
-
ClassDef(AliMUONPayloadTracker, 1) // base class for reading MUON raw digits
};
Bool_t Decode(UInt_t *buffer);
void ResetDDL();
+ /// Return maximum number of regional cards in DATE file
Int_t GetMaxReg() const {return fMaxReg;}
+ /// Return maximum number of local cards in DATE file
Int_t GetMaxLoc() const {return fMaxLoc;}
void SetMaxReg(Int_t reg);
void SetMaxLoc(Int_t loc);
+ /// Return pointer to local structure
AliMUONLocalStruct* GetLocalInfo() const {return fLocalStruct;}
+ /// Return pointer for regional structure
AliMUONRegHeader* GetRegHeader() const {return fRegHeader;}
+ /// Return pointer for DDL structure
AliMUONDDLTrigger* GetDDLTrigger() const {return fDDLTrigger;}
private :
+ /// Not implemented
+ AliMUONPayloadTrigger(const AliMUONPayloadTrigger& stream);
+ /// Not implemented
+ AliMUONPayloadTrigger& operator = (const AliMUONPayloadTrigger& stream);
Int_t fMaxReg; ///< maximum number of regional cards in DATE file
Int_t fMaxLoc; ///< maximum number of local cards in DATE file
AliMUONRegHeader* fRegHeader; //!< pointer for regional structure
AliMUONLocalStruct* fLocalStruct; //!< pointer to local structure
-
- AliMUONPayloadTrigger(const AliMUONPayloadTrigger& stream);
- AliMUONPayloadTrigger& operator = (const AliMUONPayloadTrigger& stream);
-
ClassDef(AliMUONPayloadTrigger, 1) // base class for reading MUON trigger rawdata
};
void Exec(Option_t* option);
+ /// Set option whether to generate DDL ascii files or not
void MakeDDL(Bool_t value) { fMakeDDL = value; }
private:
+ /// Not implemented
AliMUONPedestalEventGenerator(const AliMUONPedestalEventGenerator&);
+ /// Not implemented
AliMUONPedestalEventGenerator& operator=(const AliMUONPedestalEventGenerator&);
+
Bool_t ConvertRawFilesToDate();
void GenerateDigits(AliMUONData* data);
AliMUONData* GetDataAccess(const char* mode);
void Digits2Raw();
private:
- TList* fManuList; //! list of (de,manu) pairs
- AliMUONCalibrationData* fCalibrationData; //! access to pedestal CDB
- TString fDateFileName; //! basefilename of the DATE output file
- TString fGAliceFileName; //! absolute path to galice.root file
- Bool_t fMakeDDL; //! whether to generate DDL ascii files or not
- static Int_t fgCounter; //!
+ TList* fManuList; //!< list of (de,manu) pairs
+ AliMUONCalibrationData* fCalibrationData; //!< access to pedestal CDB
+ TString fDateFileName; //!< basefilename of the DATE output file
+ TString fGAliceFileName; //!< absolute path to galice.root file
+ Bool_t fMakeDDL; //!< whether to generate DDL ascii files or not
+ static Int_t fgCounter; //!< counter
ClassDef(AliMUONPedestalEventGenerator,1) // Random generator of pedestal events for MUON TRK
};
"Upload MUON Tracker pedestals to OCDB"),
fPedestals(0x0)
{
- // default ctor
+ /// default ctor
}
//_____________________________________________________________________________
AliMUONPedestalSubprocessor::~AliMUONPedestalSubprocessor()
{
- // dtor
+ /// dtor
delete fPedestals;
}
UInt_t
AliMUONPedestalSubprocessor::Process(TMap* /*dcsAliasMap*/)
{
- // Store the pedestals into the CDB
+ /// Store the pedestals into the CDB
if (!fPedestals) return 0;
Int_t
AliMUONPedestalSubprocessor::ReadFile(const char* filename)
{
- // Read the pedestals from an ASCII file.
- // Format of that file is one line per channel :
- //---------------------------------------------------------------------------
- // BUS_PATCH MANU_ADDR CHANNEL MEAN SIGMA
- //---------------------------------------------------------------------------
- //
- // Return kFALSE if reading was not successfull.
- //
+ /// Read the pedestals from an ASCII file. \n
+ /// Format of that file is one line per channel : \n
+ ///-------------------------------------------------------------------------\n
+ /// BUS_PATCH MANU_ADDR CHANNEL MEAN SIGMA \n
+ ///-------------------------------------------------------------------------\n
+ /// \n
+ /// Return kFALSE if reading was not successfull. \n
+ ///
TString sFilename(gSystem->ExpandPathName(filename));
AliMUONPixel(Double_t xc, Double_t yc, Double_t wx, Double_t wy, Double_t charge); // constructor
virtual ~AliMUONPixel(); // Destructor
- Double_t Charge(void) const { return fCharge; } // pixel charge
- Double_t Size(Int_t ixy) const { return fSize[ixy]; } // pixel size
- Double_t Coord(Int_t ixy) const { return fXY[ixy]; } // pixel coordinate
- Int_t Flag(void) const { return fFlag; } // pixel flag
+ Double_t Charge(void) const { return fCharge; } ///< pixel charge
+ Double_t Size(Int_t ixy) const { return fSize[ixy]; } ///< pixel size
+ Double_t Coord(Int_t ixy) const { return fXY[ixy]; } ///< pixel coordinate
+ Int_t Flag(void) const { return fFlag; } ///< pixel flag
- void SetCharge(Double_t Charge) { fCharge = Charge; } // set charge
- void SetSize(Int_t ixy, Double_t Size) { fSize[ixy] = Size; } // set size
- void SetCoord(Int_t ixy, Double_t Coord) { fXY[ixy] = Coord; } // set coordinate
- void SetFlag(Int_t flag) { fFlag = flag; } // set flag
- void Shift(Int_t ixy, Double_t shift) { fXY[ixy] += shift; }
+ void SetCharge(Double_t Charge) { fCharge = Charge; } ///< set charge
+ void SetSize(Int_t ixy, Double_t Size) { fSize[ixy] = Size; } ///< set size
+ void SetCoord(Int_t ixy, Double_t Coord) { fXY[ixy] = Coord; } ///< set coordinate
+ void SetFlag(Int_t flag) { fFlag = flag; } ///< set flag
+ void Shift(Int_t ixy, Double_t shift) { fXY[ixy] += shift; } ///< \todo add comment
void Print(const char* opt="") const;
- // What is necessary for sorting TObjArray's
+ /// What is necessary for sorting TObjArray's
Bool_t IsSortable() const { return kTRUE; }
Int_t Compare(const TObject* pixel) const; // "Compare" function for sorting
virtual void SetMatrix(TMatrixF *matrix) {fMatrix = matrix;}
protected:
+ /// Not implemented
AliMUONPoints(const AliMUONPoints& points);
+ /// Not implemented
AliMUONPoints& operator = (const AliMUONPoints& rhs);
Int_t fHitIndex; ///< Link to hit number
virtual UInt_t Process(TMap* dcsAliasMap);
virtual void Print(Option_t* opt="") const;
+ /// Publish AliPreprocessor::Log function
void Log(const char* message) { AliPreprocessor::Log(message); }
+ /// Publish AliPreprocessor::GetFileSources function
TList* GetFileSources(Int_t system, const char* id)
{ return AliPreprocessor::GetFileSources(system,id); }
+ /// Publish AliPreprocessor::Store function
UInt_t Store(const char* pathLevel2, const char* pathLevel3, TObject* object,
AliCDBMetaData* metaData,
Int_t validityStart = 0, Bool_t validityInfinite = kFALSE)
validityStart,validityInfinite);
}
+ /// Publish AliPreprocessor::GetFile function
const char* GetFile(Int_t system, const char* id, const char* source)
{
return AliPreprocessor::GetFile(system,id,source);
void ClearSubprocessors();
private:
+ /// Not implemented
AliMUONPreprocessor(const AliMUONPreprocessor& rhs);
+ /// Not implemented
AliMUONPreprocessor& operator=(const AliMUONPreprocessor& rhs);
AliMUONVSubprocessor* Subprocessor(Int_t i) const;
private:
- TObjArray* fSubprocessors; ///!< sub processors to execute
+ TObjArray* fSubprocessors; //!< sub processors to execute
ClassDef(AliMUONPreprocessor,1) // MUON Shuttle preprocessor
};
ClassImp(AliMUONRawCluster)
/// \endcond
+//____________________________________________________
AliMUONRawCluster::AliMUONRawCluster()
: TObject(),
fClusterType(0),
fErrXY[0] = 0.144;
fErrXY[1] = 0.01;
}
+
+//____________________________________________________
+AliMUONRawCluster::~AliMUONRawCluster()
+{
+/// Destructor
+}
+
//____________________________________________________
Int_t AliMUONRawCluster::Compare(const TObject *obj) const
{
//____________________________________________________
void AliMUONRawCluster::Print(Option_t* opt) const
{
- //
- // Printing Raw Cluster (Rec Point) information
- // "full" option for printing all the information about the raw cluster
- //
+ ///
+ /// Printing Raw Cluster (Rec Point) information
+ /// "full" option for printing all the information about the raw cluster
+ ///
TString sopt(opt);
sopt.ToUpper();
public:
AliMUONRawCluster();
- virtual ~AliMUONRawCluster() { }
+ virtual ~AliMUONRawCluster();
+
+ /// Return radius
Float_t GetRadius(Int_t i) {return TMath::Sqrt(fX[i]*fX[i]+fY[i]*fY[i]);}
+ /// Return true as the function Compare() is implemented
Bool_t IsSortable() const {return kTRUE;}
Int_t Compare(const TObject *obj) const;
Int_t PhysicsContribution() const;
// inline functions
+/// Return Indices of digits
inline Int_t AliMUONRawCluster::GetIndex(Int_t i, Int_t j) const
{ return fIndexMap[i][j]; }
+/// Return Emmanuel special offset map
inline Int_t AliMUONRawCluster::GetOffset(Int_t i, Int_t j) const
{ return fOffsetMap[i][j]; }
+/// Return Contribution from digit
inline Float_t AliMUONRawCluster::GetContrib(Int_t i, Int_t j) const
{ return fContMap[i][j]; }
+/// Return Distinguish signal and background contr.
inline Int_t AliMUONRawCluster::GetPhysics(Int_t i) const
{ return fPhysicsMap[i]; }
+/// Set Indices of digits
inline void AliMUONRawCluster::SetIndex(Int_t i, Int_t j, Int_t index)
{ fIndexMap[i][j] = index; }
+/// Set Emmanuel special offset map
inline void AliMUONRawCluster::SetOffset(Int_t i, Int_t j, Int_t offset)
{ fOffsetMap[i][j] = offset; }
+/// Set Contribution from digit
inline void AliMUONRawCluster::SetContrib(Int_t i, Int_t j, Float_t contrib)
{ fContMap[i][j] = contrib; }
+/// Set Distinguish signal and background contr.
inline void AliMUONRawCluster::SetPhysics(Int_t i, Int_t physics)
{ fPhysicsMap[i] = physics; }
+/// Set ID number of the detection element (slat) on which the cluster is found.
inline void AliMUONRawCluster::SetDetElemId(Int_t Id)
{ fDetElemId = Id; }
+/// Return ID number of the detection element (slat) on which the cluster is found.
inline Int_t AliMUONRawCluster::GetDetElemId() const
{ return fDetElemId;}
+/// Set coordinate errors
inline void AliMUONRawCluster::SetError(Int_t iXY, Float_t err)
{ fErrXY[iXY] = err; }
+/// Set x coordinate error
inline void AliMUONRawCluster::SetErrX(Float_t err)
{ SetError(0, err); }
+/// Set y coordinate error
inline void AliMUONRawCluster::SetErrY(Float_t err)
{ SetError(1, err); }
+/// Return coordinate errors
inline Float_t AliMUONRawCluster::GetError(Int_t iXY) const
{ return fErrXY[iXY]; }
+/// Return x coordinate error
inline Float_t AliMUONRawCluster::GetErrX() const
{ return GetError(0); }
+/// Return y coordinate error
inline Float_t AliMUONRawCluster::GetErrY() const
{ return GetError(1); }
virtual Bool_t Next();
virtual Bool_t NextDDL();
+ /// Return maximum number of DDL in DATE file
Int_t GetMaxDDL() const {return fMaxDDL;}
+ /// Return maximum number of block per DDL in DATE file
Int_t GetMaxBlock() const {return fPayload->GetMaxBlock();}
+ /// Return maximum number of Dsp per block in DATE file
Int_t GetMaxDsp() const {return fPayload->GetMaxDsp();}
+ /// Return maximum number of Buspatch per Dsp in DATE file
Int_t GetMaxBus() const {return fPayload->GetMaxBus();}
// check input before assigment
void SetMaxDDL(Int_t ddl);
void SetMaxBlock(Int_t blk);
- // does not check, done via BusPatchManager
+ /// Set maximum number of Dsp per block in DATE file
+ /// does not check, done via BusPatchManager
void SetMaxDsp(Int_t dsp) {fPayload->SetMaxDsp(dsp);}
+ /// Set maximum number of Buspatch per Dsp in DATE file
+ /// does not check, done via BusPatchManager
void SetMaxBus(Int_t bus) {fPayload->SetMaxBus(bus);}
-
+ /// Set object for reading the raw data
void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;}
+ /// Return pointer for buspatch structure
AliMUONDDLTracker* GetDDLTracker() const {return fPayload->GetDDLTracker();}
+ /// Return number of DDL
Int_t GetDDL() const {return fDDL - 1;}
private :
+ /// Not implemented
+ AliMUONRawStreamTracker(const AliMUONRawStreamTracker& stream);
+ /// Not implemented
+ AliMUONRawStreamTracker& operator = (const AliMUONRawStreamTracker& stream);
AliRawReader* fRawReader; ///< object for reading the raw data
AliMUONPayloadTracker* fPayload; ///< pointer to payload decoder
- AliMUONRawStreamTracker(const AliMUONRawStreamTracker& stream);
- AliMUONRawStreamTracker& operator = (const AliMUONRawStreamTracker& stream);
-
ClassDef(AliMUONRawStreamTracker, 2) // base class for reading MUON raw digits
};
virtual Bool_t Next();
virtual Bool_t NextDDL();
+ /// Return maximum number of DDL in DATE file
Int_t GetMaxDDL() const {return fMaxDDL;}
+ /// Return maximum number of regional cards in DATE file
Int_t GetMaxReg() const {return fPayload->GetMaxReg();}
+ /// Return maximum number of local cards in DATE file
Int_t GetMaxLoc() const {return fPayload->GetMaxLoc();}
void SetMaxReg(Int_t reg);
void SetMaxLoc(Int_t loc);
-
+ /// Set object for reading the raw data
void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;}
+ /// Return pointer for DDL structure
AliMUONDDLTrigger* GetDDLTrigger() const {return fPayload->GetDDLTrigger();}
+ /// Return number of DDL
Int_t GetDDL() const {return fDDL - 1;}
private :
+ /// Not implemented
+ AliMUONRawStreamTrigger(const AliMUONRawStreamTrigger& stream);
+ /// Not implemented
+ AliMUONRawStreamTrigger& operator = (const AliMUONRawStreamTrigger& stream);
AliRawReader* fRawReader; ///< object for reading the raw data
AliMUONPayloadTrigger* fPayload; ///< pointer to payload decoder
Bool_t fNextDDL; ///< flag for next DDL to be read
Int_t fMaxDDL; ///< maximum number of DDL in DATE file
- AliMUONRawStreamTrigger(const AliMUONRawStreamTrigger& stream);
- AliMUONRawStreamTrigger& operator = (const AliMUONRawStreamTrigger& stream);
-
ClassDef(AliMUONRawStreamTrigger, 3) // base class for reading MUON trigger rawdata
};
TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
private:
+ /// Not implemented
+ AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
+ /// Not implemented
+ AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
AliRunLoader* fRunLoader; ///< alice run loader
AliMUONData* fMUONData; ///< Data container for MUON subsystem
/// to decide if the class should or not deal with the loaders
- AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
- AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
-
ClassDef(AliMUONRecoCheck, 0) //Utility class to check reconstruction
};
}
}
+//-------------------------------------------------------------------
+AliMUONRecoTrack::~AliMUONRecoTrack()
+{
+/// Destructor
+}
+
//-------------------------------------------------------------------
Double_t AliMUONRecoTrack::Phi() const
{
public:
AliMUONRecoTrack();
AliMUONRecoTrack(Bool_t active);
- virtual ~AliMUONRecoTrack() { } //desctructor
+ virtual ~AliMUONRecoTrack();
+
+ /// Return chi squared for reco. track
Double_t GetChi2r() const {return fChi2r;};
+ /// Return reconstr. momentum (same as in vertex)
Double_t GetMomReconstr(Int_t axis) const {return fPr[axis];};
+ /// Return charge sign
Int_t GetSign() const {return fSign;};
+ /// Return hit X position in all chambers
Double_t GetPosX(Int_t chamber) const {return fPosX[chamber];};
+ /// Return hit Y position in all chambers
Double_t GetPosY(Int_t chamber) const {return fPosY[chamber];};
+ /// Return hit Z position in all chambers
Double_t GetPosZ(Int_t chamber) const {return fPosZ[chamber];};
+ /// Return z of track vertex point
Double_t GetVertexPos() const { return fZvr;};
+ /// \todo add comment
Double_t P() const {return TMath::Sqrt(fPr[0]*fPr[0] + fPr[1]*fPr[1] + fPr[2]*fPr[2]);};
Double_t Phi() const;
+
+ /// Set chi squared for reco. track
void SetChi2r(Double_t chi) { fChi2r = chi;};
void SetHitPosition(Int_t chamber, Double_t x, Double_t y, Double_t z);
void SetMomReconstr(Double_t px, Double_t py, Double_t pz);
+ /// Set charge sign
void SetSign(Int_t sign) {fSign = sign;};
+ /// Set z of track vertex point
void SetVertexPos(Double_t zvr) {fZvr = zvr;};
+ /// Set flag of reconstructed track (0-"good", >0-"bad")
void SetFlag(Int_t flag) {fFlag = flag;};
Double_t Theta() const;
private:
Int_t fSign; ///< charge sign
- Int_t fFlag; ///< flag of reconstructed track (0-"good", >0-"bad")
+ Int_t fFlag; ///< flag of reconstructed track (0-"good", >0-"bad")
Double_t fZvr; ///< z of track vertex point
Double_t fChi2r; ///< chi squared for reco. track
- Double_t fPr[3]; // reconstr. momentum (same as in vertex)
+ Double_t fPr[3]; ///< reconstr. momentum (same as in vertex)
Double_t fPosX[10]; ///< hit X position in all chambers
Double_t fPosY[10]; ///< hit Y position in all chambers
Double_t fPosZ[10]; ///< hit Z position in all chambers
AliMUONReconstructor();
virtual ~AliMUONReconstructor();
+ /// Dummy implementation
virtual void Reconstruct(TTree* /*digitsTree*/,
TTree* /*clustersTree*/) const {return;}
+ /// Dummy implementation
virtual void Reconstruct(AliRawReader* /*rawReader*/,
TTree* /*clustersTree*/) const {return;}
virtual void Reconstruct(AliRunLoader* runLoader) const;
virtual void Reconstruct(AliRunLoader* runLoader,
AliRawReader* rawReader) const;
+ /// Dummy implementation
virtual void FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/,
AliESD* /*esd*/) const {return;}
+ /// Dummy implementation
virtual void FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/,
AliESD* /*esd*/) const {return;}
virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const;
TTask* GetCalibrationTask() const;
AliMUONClusterReconstructor* CreateClusterReconstructor() const;
+ /// Not implemented
AliMUONReconstructor(const AliMUONReconstructor& right);
+ /// Not implemented
AliMUONReconstructor& operator = (const AliMUONReconstructor& right);
private:
virtual ~AliMUONRegHeader();
+ /// Return darc word
UInt_t GetDarcWord() const {return fDarcWord;}
+ /// Return first reg word
UInt_t GetWord() const {return fWord;}
+ /// Return regional input
UInt_t GetInput(Int_t n) const {return fInput[n];}
+ /// Return L0
UShort_t GetL0() const {return fL0 & 0xFFFF;}
+ /// Return mask
UShort_t GetMask() const {return fMask & 0xFFFF;}
//word: phys type:1, reset: 6, serialNb:5, Id:4, version: 8, regional output:8
//true for phys, false for soft
+ /// Return RegPhysFlag
Bool_t GetRegPhysFlag() const {return (fWord & 0x80000000);}
+ /// Return ResetNb
UChar_t GetResetNb() const {return (UChar_t)(fWord >> 25) & 0x20;}
+ /// Return SerialNb
UChar_t GetSerialNb() const {return (UChar_t)(fWord >> 20) & 0x1F;}
+ /// Return Id
UChar_t GetId() const {return (UChar_t)(fWord >> 16) & 0x0F;}
+ /// Return Version
UChar_t GetVersion() const {return (UChar_t)(fWord >> 8) & 0xFF;}
+ /// Return Output
UChar_t GetOutput() const {return (UChar_t)(fWord & 0xFF);}
//Darc Status: error:10, #fpag:3, MBZ:3, phys type:1, present:1, not_full:1
// not_empty:1, L2Rej:1, L2Acc:1, L1:1, L0:1, #evt:4, busy:4
+ /// Return ErrorBits
UShort_t GetErrorBits() const {return (UShort_t)(fDarcWord >> 21) & 0x3FF;}
+ /// Return FPGANumber
UChar_t GetFPGANumber() const {return (UChar_t) (fDarcWord >> 18) & 0x7;}
+ /// Return DarcPhysFlag
Bool_t GetDarcPhysFlag() const {return (fDarcWord & 0x1000);}
+ /// Return PresentFlag
Bool_t GetPresentFlag() const {return (fDarcWord & 0x800);}
+ /// Return RamNotFullFlag
Bool_t GetRamNotFullFlag() const {return (fDarcWord & 0x400);}
+ /// Return RamNotEmptyFlag
Bool_t GetRamNotEmptyFlag() const {return (fDarcWord & 0x200);}
+ /// Return L2RejStatus
Bool_t GetL2RejStatus() const {return (fDarcWord & 0x100);}
+ /// Return L2AccStatus
Bool_t GetL2AccStatus() const {return (fDarcWord & 0x80);}
+ /// Return L1Status
Bool_t GetL1Status() const {return (fDarcWord & 0x40);}
+ /// Return L0Status
Bool_t GetL0Status() const {return (fDarcWord & 0x20);}
+ /// Return EventInRam
UChar_t GetEventInRam() const {return (UChar_t) (fDarcWord >> 4) & 0x4;}
+ /// Return Busy
UChar_t GetBusy() const {return (UChar_t) (fDarcWord) & 0x4;}
+ /// Set darc word
void SetDarcWord(UInt_t w) {fDarcWord = w;}
+ /// Set first reg word
void SetWord(UInt_t w) {fWord = w;}
+ /// Set local mask ("poids faible" 16 bits)
void SetMask(UShort_t m) {fMask = m;}
+ /// Set L0
void SetL0(UShort_t l) {fL0 = (l & 0xFFFF);}
+ /// Set regional input
void SetInput(UInt_t in, Int_t n) {fInput[n] = in;}
+ /// Return header length in word
Int_t GetHeaderLength() const {return fgkHeaderLength;}
+ /// Return end of regional info word
UInt_t GetEndOfReg() const {return fgkEndOfReg;}
+ /// Return header
UInt_t* GetHeader() {return &fDarcWord;}
// scalar methods
+ /// Return regional clock
UInt_t GetClock() const {return fClk;}
+ /// Return regional ouput
const UInt_t* GetScaler() const {return fScaler;}
+ /// Return regional hold (dead time)
UInt_t GetHold() const {return fHold;}
+ /// Return scalers
UInt_t* GetScalers() {return &fClk;}
- // get scaler length
+ /// get scaler length
Int_t GetScalerLength() const {return fgkScalerLength;}
- // set random numbers to fill variable
+ /// set random numbers to fill variable
void SetScalersNumbers();
- // get TClonesArray
+ /// get TClonesArray
TClonesArray* GetLocalArray() const {return fLocalArray;}
- // get entries
+ /// get entries
Int_t GetLocalEntries() const {return fLocalArray->GetEntriesFast();}
- // get entry
+ /// get entry
AliMUONLocalStruct* GetLocalEntry(Int_t i) const {
return (AliMUONLocalStruct*)fLocalArray->At(i);}
fLocalOutput[0] = theMUONRegionalTrig.fLocalOutput[0];
fLocalOutput[1] = theMUONRegionalTrig.fLocalOutput[1];
+}
+//----------------------------------------------------------------------
+AliMUONRegionalTrigger::~AliMUONRegionalTrigger()
+{
+/// Destructor
}
//----------------------------------------------------------------------
AliMUONRegionalTrigger& AliMUONRegionalTrigger::operator=(const AliMUONRegionalTrigger& theMUONRegionalTrig)
//----------------------------------------------------------------------
void AliMUONRegionalTrigger::Print(Option_t* opt) const
{
- //
- // Printing Regional Trigger information
- //
+ ///
+ /// Printing Regional Trigger information
+ ///
TString sopt(opt);
sopt.ToUpper();
public:
AliMUONRegionalTrigger();
AliMUONRegionalTrigger(const AliMUONRegionalTrigger& rhs); // copy constructor !
- virtual ~AliMUONRegionalTrigger(){;}
+ virtual ~AliMUONRegionalTrigger();
AliMUONRegionalTrigger& operator=(const AliMUONRegionalTrigger& rhs);
// getter methods
+ /// Return regional id
Int_t GetId() const {return fId;}
+ /// Return local output Lpt & Hpt
UInt_t GetLocalOutput(Int_t n) const {return fLocalOutput[n];}
+ /// Return local mask
UShort_t GetLocalMask() const {return fLocalMask;}
+ /// Return regional output (single muon:2, unlike sign:1, like sign:1)
Char_t GetOutput() const {return fOutput;}
// setter methods
+ /// Set regional id
void SetId(Int_t d) {fId = d;}
+ /// Set local output Lpt & Hpt
void SetLocalOutput(UInt_t local, Int_t n) {fLocalOutput[n] = local;}
+ /// Set local mask
void SetLocalMask(UShort_t m) {fLocalMask = m;}
+ /// Set regional output (single muon:2, unlike sign:1, like sign:1)
void SetOutput(Char_t o) {fOutput = o;}
virtual void Print(Option_t* opt="") const;
/// - entry are local board responses
/// - output is 12-bit word
/// - algorithm is similar to the global one
+/// \todo Change member functions comments in capital letters to normal text
///
/// \author Rachid Guernane (LPCCFd)
#include <Riostream.h>
+/// \cond CLASSIMP
ClassImp(AliMUONRegionalTriggerBoard)
+/// \endcond
//___________________________________________
AliMUONRegionalTriggerBoard::AliMUONRegionalTriggerBoard()
{
+/// Default constructor
for (Int_t i=0; i<16; i++) fLocalResponse[i] = 0;
}
//___________________________________________
AliMUONRegionalTriggerBoard::AliMUONRegionalTriggerBoard(const char *name, Int_t a) : AliMUONTriggerBoard(name, a)
{
+/// Standard constructor
for (Int_t i=0; i<16; i++) fLocalResponse[i] = 0;
}
+//___________________________________________
+AliMUONRegionalTriggerBoard::~AliMUONRegionalTriggerBoard()
+{
+/// Destructor
+}
+
//___________________________________________
void AliMUONRegionalTriggerBoard::Response()
{
-/*
- RESPONSE IS GIVEN FOLLOWING THE REGIONAL ALGORITHM
-*/
+/// RESPONSE IS GIVEN FOLLOWING THE REGIONAL ALGORITHM
+
Int_t t[16];
for (Int_t i=0;i<16;i++) t[i] = fLocalResponse[i] & fMask[i];
//___________________________________________
UShort_t AliMUONRegionalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres, Int_t level)
{
-// IMPLEMENTATION OF THE REGIONAL ALGORITHM
-// SIMILAR TO THE GLOBAL ALGORITHM EXCEPT FOR THE
-// INPUT LAYER
+/// IMPLEMENTATION OF THE REGIONAL ALGORITHM
+/// SIMILAR TO THE GLOBAL ALGORITHM EXCEPT FOR THE
+/// INPUT LAYER
+
TBits a(8), b(8); a.Set(8,&i); b.Set(8,&j);
TBits trg1(2), trg2(2), trg(2);
//___________________________________________
void AliMUONRegionalTriggerBoard::Scan(Option_t*) const
{
-/*
- SCAN LOCAL BOARD ENTRIES
-*/
+/// SCAN LOCAL BOARD ENTRIES
+
for (Int_t i=0; i<16; i++)
{
TBits b;
//___________________________________________
void AliMUONRegionalTriggerBoard::Mask(Int_t index, UShort_t mask)
{
-// MASK ENTRY index
+/// MASK ENTRY index
+
if ( index>=0 && index < 16 )
{
fMask[index]=mask;
AliError(Form("Index %d out of bounds (max %d)",index,16));
}
}
-
-ClassImp(AliMUONRegionalTriggerBoard)
public:
AliMUONRegionalTriggerBoard();
AliMUONRegionalTriggerBoard(const char *name, Int_t a);
- virtual ~AliMUONRegionalTriggerBoard() {;}
+ virtual ~AliMUONRegionalTriggerBoard();
+ /// Reset Local trigger inputs
virtual void Reset() {for (Int_t i=0; i<16; i++) fLocalResponse[i] = 0;}
virtual void Scan(Option_t *option) const;
+ /// Dummy implementation
virtual void Resp(Option_t*) const {}
virtual void Response();
+ /// Set Local trigger inputs
virtual void SetLocalResponse(UShort_t val[16]) {for (Int_t i=0;i<16;i++) fLocalResponse[i] = val[i];}
virtual UShort_t Algo(UShort_t i, UShort_t j, char *thres, Int_t level);
#include "AliLog.h"
#include "TList.h"
+/// \cond CLASSIMP
ClassImp(AliMUONResponse)
+/// \endcond
AliMUONResponse::AliMUONResponse()
: TObject()
//
// Configuration methods
//
- // Set number of sigmas over which cluster disintegration is performed
+ /// Set number of sigmas over which cluster disintegration is performed (dummy)
virtual void SetSigmaIntegration(Float_t) {return;}
- // Get number of sigmas over which cluster disintegration is performed
+ /// Get number of sigmas over which cluster disintegration is performed (dummy)
virtual Float_t SigmaIntegration() const {return 1.;}
- // Set single electron pulse height (ADCcounts/e)
+ /// Set single electron pulse height (ADCcounts/e) (dummy)
virtual void SetChargeSlope(Float_t ) {return;}
- // Get single electron pulse height (ADCcounts/e)
+ /// Get single electron pulse height (ADCcounts/e) (dummy)
virtual Float_t ChargeSlope() const {return 1.;}
- // Set sigmas of the charge spread function
+ /// Set sigmas of the charge spread function (dummy)
virtual void SetChargeSpread(Float_t , Float_t ) {return;}
- // Get sigma_X of the charge spread function
+ /// Get sigma_X of the charge spread function (dummy)
virtual Float_t ChargeSpreadX() const {return 1.;}
- // Get sigma_Y of the charge spread function
+ /// Get sigma_Y of the charge spread function (dummy)
virtual Float_t ChargeSpreadY() const {return 1.;}
- // Set maximum Adc-count value
+ /// Set maximum Adc-count value (dummy)
virtual void SetMaxAdc(Int_t ) {return;}
- // Set saturation value
+ /// Set saturation value (dummy)
virtual void SetSaturation(Int_t ) {return;}
- // Set zero suppression threshold
+ /// Set zero suppression threshold (dummy)
virtual void SetZeroSuppression(Int_t ) {return;}
- // Get maximum Adc-count value
+ /// Get maximum Adc-count value (dummy)
virtual Int_t MaxAdc() const {return kTRUE;}
- // Get saturation value
+ /// Get saturation value (dummy)
virtual Int_t Saturation() const {return kTRUE;}
- // Get maximum zero suppression threshold
+ /// Get maximum zero suppression threshold (dummy)
virtual Int_t ZeroSuppression() const {return kTRUE;}
- // Set anode cathode Pitch
+ /// Set anode cathode Pitch (dummy)
virtual void SetPitch(Float_t) {return;}
- // Get anode cathode Pitch
+ /// Get anode cathode Pitch (dummy)
virtual Float_t Pitch() const {return 1.;}
- // Set the charge correlation
+ /// Set the charge correlation (dummy)
virtual void SetChargeCorrel(Float_t) {return;}
- // Get the charge correlation
+ /// Get the charge correlation (dummy)
virtual Float_t ChargeCorrel() const {return 1.;}
- //
+ ///
// Chamber response methods
- // Pulse height from scored quantity (eloss)
+ /// Pulse height from scored quantity (eloss) (dummy)
virtual Float_t IntPH(Float_t) const {return 1.;}
- // Charge disintegration
+ /// Charge disintegration (dummy)
virtual Float_t IntXY(Int_t, AliMUONGeometrySegmentation*) const {return 1.;}
- /// Go from one hit to several digits, applying charge spreading.
+ //// Go from one hit to several digits, applying charge spreading.
virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
//
#include "AliMUONResponseTrigger.h"
#include "AliMUONResponseTriggerV1.h"
+/// \cond CLASSIMP
ClassImp(AliMUONResponseFactory)
+/// \endcond
//__________________________________________________________________________
AliMUONResponseFactory::AliMUONResponseFactory(const char* name)
void BuildStation(AliMUON* where, Int_t stationNumber);
private:
+ /// Not implemented
AliMUONResponseFactory(const AliMUONResponseFactory& rhs);
+ /// Not implemented
AliMUONResponseFactory& operator=(const AliMUONResponseFactory& rhs);
void BuildCommon();
Float_t AliMUONResponseTriggerV1::FireStripProb(Float_t x4, Float_t theta)
const
{
-// parametrisation of the probability that a strip neighbour of the main
-// strip is fired (V.Barret B.Espagnon and P.Rosnet INT/DIM/01-04 (2001)
-// WARNING : need to convert x4 from cm to mm
+/// parametrisation of the probability that a strip neighbour of the main
+/// strip is fired (V.Barret B.Espagnon and P.Rosnet INT/DIM/01-04 (2001)
+/// WARNING : need to convert x4 from cm to mm
return
(TMath::Cos(theta)*fA/(fA+TMath::Cos(theta)*TMath::Power(x4*10.,fB))+fC)/
virtual void Print(Option_t* opt="") const;
protected:
+ /// Not implemented
+ AliMUONResponseV0(const AliMUONResponseV0& rhs);
+ /// Not implemented
+ AliMUONResponseV0& operator = (const AliMUONResponseV0& rhs);
+
Float_t fChargeSlope; ///< Slope of the charge distribution
Float_t fChargeSpreadX; ///< Width of the charge distribution in x
Float_t fChargeSpreadY; ///< Width of the charge distribution in y
AliMUONMathieson* fMathieson; ///< pointer to mathieson fct
Float_t fChargeThreshold; ///< Charges below this threshold are = 0
- private:
- AliMUONResponseV0(const AliMUONResponseV0& rhs);
- AliMUONResponseV0& operator = (const AliMUONResponseV0& rhs);
-
-
ClassDef(AliMUONResponseV0,2) // Implementation of detector response
};
AliMUONSDigitizerV2::AliMUONSDigitizerV2()
: TTask("AliMUONSDigitizerV2","From Hits to SDigits for MUON")
{
- //
- // ctor.
- //
+ ///
+ /// ctor.
+ ///
}
//_____________________________________________________________________________
AliMUONSDigitizerV2::~AliMUONSDigitizerV2()
{
- //
- // dtor.
- //
+ ///
+ /// dtor.
+ ///
}
//_____________________________________________________________________________
void
AliMUONSDigitizerV2::Exec(Option_t*)
{
- //
- // Go from hits to sdigits.
- //
- // In the code below, apart from the loop itself (which look complicated
- // but is really only a loop on each hit in the input file) the main
- // work is done in AliMUONResponse::DisIntegrate method, which converts
- // a single hit in (possibly) several sdigits.
- //
+ ///
+ /// Go from hits to sdigits.
+ ///
+ /// In the code below, apart from the loop itself (which look complicated
+ /// but is really only a loop on each hit in the input file) the main
+ /// work is done in AliMUONResponse::DisIntegrate method, which converts
+ /// a single hit in (possibly) several sdigits.
+ ///
AliDebug(1,"");
// Returned segmentation contains all the lower level segmentations
// created with the factory
- protected:
+ private:
+ /// Not implemented
AliMUONSegFactory(const AliMUONSegFactory& rhs);
+ /// Not implemented
AliMUONSegFactory& operator=(const AliMUONSegFactory& rhs);
- private:
AliMUONVGeometryDESegmentation*
CreateDESegmentation(Int_t detElemId, AliMp::CathodType cath);
// Create DE segmentation, operating in local reference frame
TString GetDEName(Int_t detElemId, Int_t cathod = 0) const;
protected:
+ /// Not implemented
AliMUONSegmentation(const AliMUONSegmentation& right);
+ /// Not implemented
AliMUONSegmentation& operator = (const AliMUONSegmentation& right);
private:
// $Id$
//
-// Class AliMUONSlatGeometryBuilder
-// -------------------------------
-// Abstract base class for geometry construction per chamber.
-//
-
-
-// This Builder is designed according to the enveloppe methode. The basic idea is to be able to allow moves
-// of the slats on the support panels.
-// Those moves can be described with a simple set of parameters. The next step should be now to describe all
-// the slats and their places by a unique
-// class, which would make the SlatBuilder far more compact since now only three parameters can define a slat
-// and its position, like:
-// * Bool_t rounded_shape_slat
-// * Float_t slat_length
-// * Float_t slat_number or Float_t slat_position
-// Reference system is the one described in the note ALICE-INT-2003-038 v.2 EDMS Id 406391
+/// \class AliMUONSlatGeometryBuilder
+/// This Builder is designed according to the enveloppe methode. The basic idea is to be able to allow moves
+/// of the slats on the support panels.
+/// Those moves can be described with a simple set of parameters. The next step should be now to describe all
+/// the slats and their places by a unique
+/// class, which would make the SlatBuilder far more compact since now only three parameters can define a slat
+/// and its position, like:
+/// - Bool_t rounded_shape_slat
+/// - Float_t slat_length
+/// - Float_t slat_number or Float_t slat_position
+/// Reference system is the one described in the note ALICE-INT-2003-038 v.2 EDMS Id 406391
+///
+/// \author Eric Dumonteil (dumontei@cea.fr)
#include "AliMUONSlatGeometryBuilder.h"
#include "AliMUON.h"
: AliMUONVGeometryBuilder(4, 12),
fMUON(muon)
{
-// Standard constructor
+/// Standard constructor
}
: AliMUONVGeometryBuilder(),
fMUON(0)
{
-// Default constructor
+/// Default constructor
}
//______________________________________________________________________________
-AliMUONSlatGeometryBuilder::~AliMUONSlatGeometryBuilder() {
-//
+AliMUONSlatGeometryBuilder::~AliMUONSlatGeometryBuilder()
+{
+/// Destructor
}
//
//______________________________________________________________________________
void AliMUONSlatGeometryBuilder::CreateGeometry()
{
- // CreateGeometry is the method containing all the informations concerning Stations 345 geometry.
- // It includes description and placements of support panels and slats.
- // The code comes directly from what was written in AliMUONv1.cxx before, with modifications concerning
- // the use of Enveloppe method to place the Geant volumes.
- // Now, few changes would allow the creation of a Slat methode where slat could be described by few parameters,
- // and this builder would then be dedicated only to the
- // placements of the slats. Those modifications could shorten the Station 345 geometry by a non-negligeable factor...
+ /// CreateGeometry is the method containing all the informations concerning Stations 345 geometry.
+ /// It includes description and placements of support panels and slats.
+ /// The code comes directly from what was written in AliMUONv1.cxx before, with modifications concerning
+ /// the use of Enveloppe method to place the Geant volumes.
+ /// Now, few changes would allow the creation of a Slat methode where slat could be described by few parameters,
+ /// and this builder would then be dedicated only to the
+ /// placements of the slats. Those modifications could shorten the Station 345 geometry by a non-negligeable factor...
Int_t *idtmed = fMUON->GetIdtmed()->GetArray()-1099;
//______________________________________________________________________________
void AliMUONSlatGeometryBuilder::SetTransformations()
{
-// Defines the transformations for the station345 chambers.
-// ---
+/// Defines the transformations for the station345 chambers.
if (gAlice->GetModule("DIPO")) {
// if DIPO is preset, the whole station will be placed in DDIP volume
//______________________________________________________________________________
void AliMUONSlatGeometryBuilder::SetSensitiveVolumes()
{
-// Defines the sensitive volumes for slat stations chambers.
-// ---
+/// Defines the sensitive volumes for slat stations chambers.
GetGeometry( 4)->SetSensitiveVolume("S05G");
GetGeometry( 5)->SetSensitiveVolume("S05G");
//______________________________________________________________________________
Int_t AliMUONSlatGeometryBuilder::ConvertSlatNum(Int_t numslat, Int_t quadnum, Int_t fspq) const
{
-// On-line function establishing the correspondance between numslat (the slat number on a particular quadrant (numslat->0....4 for St3))
-// and slatnum (the slat number on the whole panel (slatnum->1...18 for St3)
+/// On-line function establishing the correspondance between numslat (the slat number on a particular quadrant (numslat->0....4 for St3))
+/// and slatnum (the slat number on the whole panel (slatnum->1...18 for St3)
numslat += 1;
if (quadnum==2 || quadnum==3)
numslat += fspq;
/// \class AliMUONSlatGeometryBuilder
/// \brief MUON Station3 geometry construction class
///
-/// Author: Eric Dumonteil (dumontei@cea.fr)
+// Author: Eric Dumonteil (dumontei@cea.fr)
#ifndef ALI_MUON_SLAT_GEOMETRY_BUILDER_H
virtual void SetTransformations();
virtual void SetSensitiveVolumes();
- protected:
-
private:
+ /// Not implemented
AliMUONSlatGeometryBuilder(const AliMUONSlatGeometryBuilder& rhs);
-
- // operators
+ /// Not implemented
AliMUONSlatGeometryBuilder& operator = (const AliMUONSlatGeometryBuilder& rhs);
+
Int_t ConvertSlatNum(Int_t numslat, Int_t quadnum, Int_t fspq) const;
AliMUON* fMUON; ///< the MUON detector class
virtual TF1* CorrFunc(Int_t isec) const;
// Get the correction Function
- protected:
+ private:
+ /// Not implemented
AliMUONSt12QuadrantSegmentation(const AliMUONSt12QuadrantSegmentation& rhs);
-
- // operators
+ /// Not implemented
AliMUONSt12QuadrantSegmentation& operator=(const AliMUONSt12QuadrantSegmentation & rhs);
- private:
// methods
void UpdateCurrentPadValues(const AliMpPad& pad);
protected:
private:
+ /// Not implemented
AliMUONSt1GeometryBuilder(const AliMUONSt1GeometryBuilder& rhs);
-
- // operators
+ /// Not implemented
AliMUONSt1GeometryBuilder& operator = (const AliMUONSt1GeometryBuilder& rhs);
- AliMUON* fMUON; ///< the MUON detector class
+
+ AliMUON* fMUON; ///< the MUON detector class
ClassDef(AliMUONSt1GeometryBuilder,1) //MUON Station1 coarse geometry construction class
};
typedef map<Int_t , AliMUONSt1SpecialMotif> SpecialMap;
#endif
-//typedef Float_t GReal_t; // for AliGeant3
+// typedef Float_t GReal_t; // for AliGeant3
typedef Double_t GReal_t; // for VirtualMC
class AliMUON;
protected:
private:
+ /// Not implemented
AliMUONSt1GeometryBuilderV2(const AliMUONSt1GeometryBuilderV2& rMUON);
+ /// Not implemented
AliMUONSt1GeometryBuilderV2& operator = (const AliMUONSt1GeometryBuilderV2& rhs);
+
// Constants
//
static const GReal_t fgkHzPadPlane; ///< Pad plane
: AliMUONVGeometryBuilder(2, 2),
fMUON(muon)
{
-// Standard constructor
+/// Standard constructor
}
: AliMUONVGeometryBuilder(),
fMUON(0)
{
-// Default constructor
+/// Default constructor
}
//______________________________________________________________________________
-AliMUONSt2GeometryBuilder::~AliMUONSt2GeometryBuilder() {
-//
+AliMUONSt2GeometryBuilder::~AliMUONSt2GeometryBuilder()
+{
+/// Destructor
}
//
//______________________________________________________________________________
void AliMUONSt2GeometryBuilder::CreateGeometry()
{
-// From AliMUONv1::CreateGeometry()
+/// From AliMUONv1::CreateGeometry()
//
//********************************************************************
//______________________________________________________________________________
void AliMUONSt2GeometryBuilder::SetTransformations()
{
-// Defines the transformations for the station2 chambers.
-// ---
+/// Defines the transformations for the station2 chambers.
// Define chamber volumes as virtual
SetVolume(2, "SC03", true);
//______________________________________________________________________________
void AliMUONSt2GeometryBuilder::SetSensitiveVolumes()
{
-// Defines the sensitive volumes for station2 chambers.
-// ---
+/// Defines the sensitive volumes for station2 chambers.
GetGeometry(2)->SetSensitiveVolume("S03G");
GetGeometry(3)->SetSensitiveVolume("S04G");
virtual void SetTransformations();
virtual void SetSensitiveVolumes();
- protected:
-
private:
+ /// Not implemented
AliMUONSt2GeometryBuilder(const AliMUONSt2GeometryBuilder& rhs);
-
- // operators
+ /// Not implemented
AliMUONSt2GeometryBuilder& operator = (const AliMUONSt2GeometryBuilder& rhs);
- AliMUON* fMUON; ///< the MUON detector class
+
+ AliMUON* fMUON; ///< the MUON detector class
ClassDef(AliMUONSt2GeometryBuilder,1) // MUON Station2 coarse geometry construction class
};
: AliMUONVGeometryBuilder(2, 2),
fMUON(muon)
{
-// Standard constructor
+/// Standard constructor
}
: AliMUONVGeometryBuilder(),
fMUON(0)
{
-// Default constructor
+/// Default constructor
}
//______________________________________________________________________________
-AliMUONSt2GeometryBuilderV2::~AliMUONSt2GeometryBuilderV2() {
-//
+AliMUONSt2GeometryBuilderV2::~AliMUONSt2GeometryBuilderV2()
+{
+/// Destructor
}
//
//______________________________________________________________________________
void AliMUONSt2GeometryBuilderV2::CreateGeometry()
{
+/// Geometry construction
//
//********************************************************************
//______________________________________________________________________________
void AliMUONSt2GeometryBuilderV2::SetTransformations()
{
-// Defines the transformations for the station2 chambers.
-// ---
+/// Defines the transformations for the station2 chambers.
if (gAlice->GetModule("SHIL")) {
SetMotherVolume(2, "YOUT1");
//______________________________________________________________________________
void AliMUONSt2GeometryBuilderV2::SetSensitiveVolumes()
{
-// Defines the sensitive volumes for station2 chambers.
-// ---
+/// Defines the sensitive volumes for station2 chambers.
GetGeometry(2)->SetSensitiveVolume("C3G0");
GetGeometry(2)->SetSensitiveVolume("C3G1");
protected:
private:
+ /// Not implemented
AliMUONSt2GeometryBuilderV2(const AliMUONSt2GeometryBuilderV2& rhs);
-
- // operators
+ /// Not implemented
AliMUONSt2GeometryBuilderV2& operator = (const AliMUONSt2GeometryBuilderV2& rhs);
- AliMUON* fMUON; ///< the MUON detector class
+
+ AliMUON* fMUON; ///< the MUON detector class
ClassDef(AliMUONSt2GeometryBuilderV2,1) //MUON Station2 detailed geometry construction class
};
void Print(Option_t* opt = "") const;
protected:
+ /// Not implemented
AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& right);
+ /// Not implemented
AliMUONSt345SlatSegmentation& operator = (const AliMUONSt345SlatSegmentation& right);
private:
void Print(const TString& key, ofstream& out) const;
protected:
+ /// Not implemented
AliMUONStringIntMap(const AliMUONStringIntMap& rhs);
+ /// Not implemented
AliMUONStringIntMap& operator = (const AliMUONStringIntMap& rhs);
private:
}
//__________________________________________________________________________
-Double_t AliMUONTrackExtrap::ApproximateBetheBloch(Double_t beta2) {
- //------------------------------------------------------------------
- // This is an approximation of the Bethe-Bloch formula with
- // the density effect taken into account at beta*gamma > 3.5
- // (the approximation is reasonable only for solid materials)
- //------------------------------------------------------------------
+Double_t AliMUONTrackExtrap::ApproximateBetheBloch(Double_t beta2)
+{
+/// This is an approximation of the Bethe-Bloch formula with
+/// the density effect taken into account at beta*gamma > 3.5
+/// (the approximation is reasonable only for solid materials)
+
if (beta2/(1-beta2)>3.5*3.5)
return 0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2);
//__________________________________________________________________________
void AliMUONTrackExtrap::ExtrapOneStepHelix(Double_t charge, Double_t step, Double_t *vect, Double_t *vout)
{
+/// <pre>
/// ******************************************************************
/// * *
/// * Performs the tracking of one step in a magnetic field *
/// * modified v.perevoztchikov
/// * *
/// ******************************************************************
+/// </pre>
// modif: everything in double precision
//__________________________________________________________________________
void AliMUONTrackExtrap::ExtrapOneStepHelix3(Double_t field, Double_t step, Double_t *vect, Double_t *vout)
{
+/// <pre>
/// ******************************************************************
/// * *
/// * Tracking routine in a constant field oriented *
/// * Rewritten V.Perevoztchikov
/// * *
/// ******************************************************************
+/// </pre>
Double_t hxp[3];
Double_t h4, hp, rho, tet;
//__________________________________________________________________________
void AliMUONTrackExtrap::ExtrapOneStepRungekutta(Double_t charge, Double_t step, Double_t* vect, Double_t* vout)
{
+/// <pre>
/// ******************************************************************
/// * *
/// * Runge-Kutta method for tracking a particle through a magnetic *
/// * *
/// * *
/// ******************************************************************
+/// </pre>
Double_t h2, h4, f[4];
Double_t xyzt[3], a, b, c, ph,ph2;
static const Double_t fgkRungeKuttaMaxResidue;//!< Maximal distance (in Z) to destination to stop the track extrapolation (used in Runge-Kutta)
// Functions
+
+ /// Not implemented
AliMUONTrackExtrap(const AliMUONTrackExtrap& trackExtrap);
+ /// Not implemented
AliMUONTrackExtrap& operator=(const AliMUONTrackExtrap& trackExtrap);
static void ExtrapToZHelix(AliMUONTrackParam *trackParam, Double_t Z);
AliMUONTrackK(AliMUONObjectPair *segment); // Constructor from a segment
// Pointer to hits on track
- TObjArray* GetTrackHits(void) const {return fTrackHits;} // ptr. to hits on track
- Int_t GetNTrackHits(void) const {return fNmbTrackHits;} // hits on track
- Double_t GetTrackQuality(void) const {return fChi2;} // track quality
- TMatrixD* GetTrackParameters(void) const {return fTrackPar;} // track parameters
- Double_t GetZ(void) const {return fPosition;} // Z-coordinate of track
- TMatrixD* GetCovariance(void) const {return fCovariance;} // covariance matrix
- Int_t GetTrackDir(void) const {return fTrackDir;} // get track propagation direction
- void SetTrackDir(Int_t iDir) {fTrackDir = iDir;} // set track propagation direction
- Bool_t GetBPFlag(void) const {return fBPFlag;} // get backpropagation flag
- void SetBPFlag(Bool_t BPFlag) {fBPFlag = BPFlag;} // set backpropagation flag
- Int_t GetRecover(void) const {return fRecover;} // return recover flag
- void SetRecover(Int_t iRecover) {fRecover = iRecover;} // set recover flag
- AliMUONObjectPair* GetStartSegment(void) const {return fStartSegment;} // return seed segment
- Bool_t KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back, Double_t zDipole1, Double_t zDipole2); // Kalman filter
+ TObjArray* GetTrackHits(void) const {return fTrackHits;} ///< ptr. to hits on track
+ Int_t GetNTrackHits(void) const {return fNmbTrackHits;} ///< hits on track
+ Double_t GetTrackQuality(void) const {return fChi2;} ///< track quality
+ TMatrixD* GetTrackParameters(void) const {return fTrackPar;} ///< track parameters
+ Double_t GetZ(void) const {return fPosition;} ///< Z-coordinate of track
+ TMatrixD* GetCovariance(void) const {return fCovariance;} ///< covariance matrix
+ Int_t GetTrackDir(void) const {return fTrackDir;} ///< get track propagation direction
+ void SetTrackDir(Int_t iDir) {fTrackDir = iDir;} ///< set track propagation direction
+ Bool_t GetBPFlag(void) const {return fBPFlag;} ///< get backpropagation flag
+ void SetBPFlag(Bool_t BPFlag) {fBPFlag = BPFlag;} ///< set backpropagation flag
+ Int_t GetRecover(void) const {return fRecover;} ///< return recover flag
+ void SetRecover(Int_t iRecover) {fRecover = iRecover;} ///< set recover flag
+ AliMUONObjectPair* GetStartSegment(void) const {return fStartSegment;} ///< return seed segment
+ Bool_t KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back, Double_t zDipole1, Double_t zDipole2); ///< Kalman filter
void StartBack(void); // start backpropagator
void SetTrackQuality(Int_t iChi2); // compute track quality or Chi2
Bool_t KeepTrack(AliMUONTrackK* track0) const; // keep or discard track
Bool_t Smooth(void); // apply smoother
Double_t GetChi2PerPoint(Int_t iPoint) const; // return Chi2 at point
void Print(FILE *lun) const; // print track information
- void Print(const char* /*opt*/) const {return;} // print track information
+ void Print(const char* /*opt*/) const {return;} ///< print track information
AliMUONHitForRec* GetHitLastOk(void); // get hit before the skipped one
Int_t GetStation0(void); // return seed station number
- Int_t DebugLevel(void) const {return fgDebug;} // return debug level
- void SetDebugLevel(Int_t iDebug) {fgDebug = iDebug;} // set debug level
+ Int_t DebugLevel(void) const {return fgDebug;} ///< return debug level
+ void SetDebugLevel(Int_t iDebug) {fgDebug = iDebug;} ///< set debug level
void FillMUONTrack(void); // set track parameters as for AliMUONTrack
void SetTrackParam(AliMUONTrackParam *trackParam, TMatrixD *par, Double_t z); // fill AliMUONTrackParam object
- // What is necessary for sorting TClonesArray's
+ /// What is necessary for sorting TClonesArray's
Bool_t IsSortable() const { return kTRUE; }
Int_t Compare(const TObject* trackK) const; // "Compare" function for sorting
// Functions
- AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
+ AliMUONTrackK (const AliMUONTrackK& source); ///< Not implemented copy constructor
void EvalCovariance(Double_t dZ);
void ParPropagation(Double_t zEnd);
void WeightPropagation(Double_t zEnd, Bool_t smooth);
}
//__________________________________________________________________________
-void AliMUONTrackReconstructor::FillMUONTrack()
+void AliMUONTrackReconstructor::FillMUONTrack(void)
{
/// Fill fHitForRecAtHit of AliMUONTrack's
AliMUONTrack *track;
// Parameters for reconstruction
static const Double_t fgkMaxNormChi2; ///< maximum Chi2 per degree of freedom for reconstruction
- static const Bool_t fgkTrackAllTracks; /// kTRUE to track all the possible candidates; kFALSE to track only the best ones
+ static const Bool_t fgkTrackAllTracks; ///< kTRUE to track all the possible candidates; kFALSE to track only the best ones
// Functions
- AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); ///< copy constructor
- AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); ///< assignment operator
+ /// Not implemented copy constructor
+ AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs);
+ /// Not implemented copy assignment operator
+ AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs);
void RemoveIdenticalTracks(void);
void FollowTrackInStation(AliMUONTrack* trackCandidate, Int_t nextStation);
virtual Int_t Clusters2Tracks(AliESD* /*esd*/);
+ /// Dummy implementation
virtual Int_t PropagateBack(AliESD* /*event*/) {return 0;}
+ /// Dummy implementation
virtual Int_t RefitInward(AliESD* /*event*/) {return 0;}
+ /// Dummy implementation
virtual Int_t LoadClusters(TTree* /*tree*/) {return 0;}
+ /// Dummy implementation
virtual void UnloadClusters() {return;}
+ /// Dummy implementation
virtual AliCluster *GetCluster(Int_t /*index*/) const {return 0;}
+ /// Set trigger circuit
void SetTriggerCircuit(TClonesArray* circuit) {fTriggerCircuit = circuit;}
+ /// Set pointer to data container
void SetMUONData(AliMUONData* data) {fMUONData = data;}
+ /// Set option
void SetOption(Option_t* opt);
private:
-
+ /// Not implemented
+ AliMUONTracker(const AliMUONTracker& rhs);
+ /// Not implemented
+ AliMUONTracker& operator=(const AliMUONTracker& rhs);
+
TClonesArray* fTriggerCircuit; //!< trigger circuit
AliMUONData* fMUONData; //!< pointer to container
AliMUONVTrackReconstructor* fTrackReco; //!< track reconstructor
- AliMUONTracker(const AliMUONTracker& rhs);
- AliMUONTracker& operator=(const AliMUONTracker& rhs);
-
ClassDef(AliMUONTracker,0) //tracker base class for MUON
};
#endif
virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
private:
+ /// Not implemented
AliMUONTrackerPreprocessor(const AliMUONTrackerPreprocessor& rhs);
+ /// Not implemented
AliMUONTrackerPreprocessor& operator=(const AliMUONTrackerPreprocessor& rhs);
private:
/// May 06, taken info from Global Trigger branch (Ch.F)
//----------------------------------------------------------------------
+/// \cond CLASSIMP
ClassImp(AliMUONTrigger)
+/// \endcond
//----------------------------------------------------------------------
AliMUONTrigger::AliMUONTrigger()
: AliTriggerDetector()
{
+/// Default constructor
+
SetName("MUON");
CreateInputs();
}
+//----------------------------------------------------------------------
+AliMUONTrigger::~AliMUONTrigger()
+{
+/// Destructor
+}
+
//----------------------------------------------------------------------
void AliMUONTrigger::CreateInputs()
{
- // inputs
+ /// inputs
// Do not create inputs again!!
if( fInputs.GetEntriesFast() > 0 ) return;
//----------------------------------------------------------------------
void AliMUONTrigger::Trigger()
{
- // sets the trigger inputs
+ /// sets the trigger inputs
+
AliMUONGlobalTrigger* globalTrigger;
TClonesArray* globalTriggerArray;
{
public:
AliMUONTrigger(); // constructor
- virtual ~AliMUONTrigger(){} // destructor
+ virtual ~AliMUONTrigger(); // destructor
virtual void CreateInputs();
virtual void Trigger();
/* $Id$ */
-//*-- Author: Rachid Guernane (LPCCFd)
-// TRIGGER BOARD SUPER CLASS IMPLEMENTATION
-// CAN BE A LOCAL, REGIONAL, OR GLOBAL BOARD
-// REGIONAL BOARD IS PER CONVENTION
-// ALWAYS IN THE SLOT 0
+/// \class AliMUONTriggerBoard
+/// TRIGGER BOARD SUPER CLASS IMPLEMENTATION
+/// CAN BE A LOCAL, REGIONAL, OR GLOBAL BOARD
+/// REGIONAL BOARD IS PER CONVENTION
+/// ALWAYS IN THE SLOT 0
+/// \todo Change comments in capital letters to normal text
+///
+/// \author Rachid Guernane (LPCCFd)
#include "AliMUONTriggerBoard.h"
#include "AliLog.h"
+/// \cond CLASSIMP
+ClassImp(AliMUONTriggerBoard)
+/// \endcond
+
//___________________________________________
AliMUONTriggerBoard::AliMUONTriggerBoard()
: TNamed(),
fSlot(0),
fResponse(0)
{
-// Default Ctor
+/// Default Ctor
}
fSlot(islot),
fResponse(0)
{
-// Standard Ctor
+/// Standard Ctor
}
//___________________________________________
-AliMUONTriggerBoard::AliMUONTriggerBoard(const AliMUONTriggerBoard &board)
- : TNamed(board),
- fSlot(board.fSlot),
- fResponse(board.fResponse)
+AliMUONTriggerBoard::~AliMUONTriggerBoard()
{
-// Dummy Copy Ctor
-// board.Copy(*this);
-}
+/// Destructor
+}
-//___________________________________________
-AliMUONTriggerBoard& AliMUONTriggerBoard::operator=(const AliMUONTriggerBoard&)
-{
- AliFatal("Assignment operator not implemented");
- return *this;
-}
-//___________________________________________
-void AliMUONTriggerBoard::Copy(TObject&) const
-{
- Fatal("Copy","Not implemented!\n");
-}
-
-ClassImp(AliMUONTriggerBoard)
/// \class AliMUONTriggerBoard
/// \brief TRIGGER BOARD BASE CLASS
///
-/// \author Rachid Guernane (LPCCFd)
+// Author Rachid Guernane (LPCCFd)
#include <TNamed.h>
{
public:
AliMUONTriggerBoard();
- AliMUONTriggerBoard(const AliMUONTriggerBoard &entry);
AliMUONTriggerBoard(const char *name, Int_t islot);
- virtual ~AliMUONTriggerBoard() {}
-
- AliMUONTriggerBoard& operator=(const AliMUONTriggerBoard &rhs);
+ virtual ~AliMUONTriggerBoard();
+ /// \todo add comment
virtual void Response() = 0;
+ /// \todo add comment
virtual void Reset() = 0;
+ /// \todo add comment
virtual void Scan(Option_t *option) const = 0;
+ /// \todo add comment
virtual void Resp(Option_t *option) const = 0;
+ /// Return response
virtual UShort_t GetResponse() const {return fResponse;}
+ /// \todo add comment
virtual void Mask(Int_t index, UShort_t mask) = 0;
protected:
+ /// Not implemented
+ AliMUONTriggerBoard(const AliMUONTriggerBoard &entry);
+ /// Not implemented
+ AliMUONTriggerBoard& operator=(const AliMUONTriggerBoard &rhs);
Int_t fSlot; ///< SLOT NUMBER IN CRATE
UShort_t fResponse; ///< RESPONSE
- void Copy(TObject&) const;
-
- private:
-
-
-
ClassDef(AliMUONTriggerBoard,1)
};
#endif
fDebugLevel(0),
fGaliceDir(galiceRunDir)
{
+/// Standard constructor
ResetArrays();
delete gAlice;
}
AliMUONTriggerChamberEff(Int_t firstRun, Int_t lastRun, const char* galiceRunDir, Int_t firstEvent=0, Int_t lastEvent=-1);
virtual ~AliMUONTriggerChamberEff();
+ /// Set Reproduce trigger response
void SetReproduceTrigResponse(Bool_t reproduceTrigRes=kFALSE)
{fReproduceTrigResponse=reproduceTrigRes;}
+ /// Set Print informations on event
void SetPrintInfo(Bool_t printInfo=kFALSE)
{fPrintInfo=printInfo;}
+ /// Set Debug level
void SetDebugLevel(Int_t debugLevel)
{fDebugLevel=debugLevel;}
void WriteEfficiencyMap(const char* outputDir);
private:
+ /// Not implemented
AliMUONTriggerChamberEff(const AliMUONTriggerChamberEff& other);
+ /// Not implemented
AliMUONTriggerChamberEff& operator=(const AliMUONTriggerChamberEff& other);
void SetGaliceFile(const char* galiceFile);
// void dump(const char* what, const Float_t* array, Int_t size);
// void dump(const char* what, const Int_t* array, Int_t size);
+ /// Set pointer to transformations
void SetTransformer(const AliMUONGeometryTransformer* transformer) {fTransformer = transformer;}
private:
/* $Id$ */
-//*-- Author: Rachid Guernane (LPCCFd)
-// COLLECTION OF TRIGGER BOARDS
-// ONE REGIONAL
-// SIXTEEN LOCAL
-// SLOT 0 HOLDS THE REGIONAL BOARD
+/// \class AliMUONTriggerCrate
+/// Collection of trigger boards
+/// - one regional
+/// - sixteen local
+/// slot 0 holds the regional board
+/// \author Rachid Guernane (LPCCFd)
#include <TObjArray.h>
fBoards(0x0),
fSourceFileName(0)
{
- // Def Ctor
+/// Default constructor
}
//___________________________________________
AliMUONTriggerCrate::~AliMUONTriggerCrate()
{
+/// Destructor
+
delete fBoards;
}
fBoards(new TObjArray(fNslots)),
fSourceFileName(0)
{
+/// Standard constructor
}
//___________________________________________
void AliMUONTriggerCrate::AddBoard(AliMUONTriggerBoard *board, Int_t i)
{
- // ADD BOARD IN CRATE CONTAINER
+/// Add board in crate container
fBoards->AddAt(board,i);
fNboards++;
}
-//___________________________________________
-AliMUONTriggerCrate::AliMUONTriggerCrate(const AliMUONTriggerCrate &crate)
- : TNamed(crate),
- fNslots(crate.fNslots),
- fNboards(crate.fNboards),
- fBoards(crate.fBoards),
- fSourceFileName(crate.fSourceFileName)
-{
-
-// Dummy Copy Ctor
-// crate.Copy(*this);
-}
-
-//___________________________________________
-AliMUONTriggerCrate& AliMUONTriggerCrate::operator=(const AliMUONTriggerCrate &rhs)
-{
-// Assignment optor
- rhs.Copy(*this);
- return (*this);
-}
-
-//___________________________________________
-void AliMUONTriggerCrate::Copy(TObject&) const
-{
- Fatal("Copy","Not implemented!\n");
-}
/// \class AliMUONTriggerCrate
/// \brief Trigger Crate
///
-/// \author Rachid Guernane (LPCCFd)
+// Author Rachid Guernane (LPCCFd)
#include <TNamed.h>
class AliMUONTriggerCrate : public TNamed
{
public:
-
AliMUONTriggerCrate();
- AliMUONTriggerCrate(const AliMUONTriggerCrate &entry);
AliMUONTriggerCrate(const char *name, Int_t n = 17); // 16 + 1
virtual ~AliMUONTriggerCrate();
-// CRATE CONFIG FROM ASCII FILE
+ /// Crate config from ascii file
virtual void SetDataSource(TString SourceFile) {fSourceFileName = SourceFile;}
virtual void AddBoard(AliMUONTriggerBoard *board, Int_t i);
+ /// Return pointer to board objects
virtual TObjArray* Boards() {return fBoards;}
- AliMUONTriggerCrate& operator=(const AliMUONTriggerCrate &rhs);
-
- protected:
- void Copy(TObject&) const;
private:
+ /// Not implemented
+ AliMUONTriggerCrate(const AliMUONTriggerCrate &entry);
+ /// Not implemented
+ AliMUONTriggerCrate& operator=(const AliMUONTriggerCrate &rhs);
- Int_t fNslots; ///< NUMBER OF SLOTS
- Int_t fNboards; ///< NUMBER OF BOARDS
+ Int_t fNslots; ///< Number of slots
+ Int_t fNboards; ///< Number of boards
- TObjArray *fBoards; ///< POINTER TO BOARD OBJECTS
- TString fSourceFileName; ///< SOURCE FILE
+ TObjArray *fBoards; ///< Pointer to board objects
+ TString fSourceFileName; ///< Source file
ClassDef(AliMUONTriggerCrate,1)
};
// //____________________________________________________________________
TString AliMUONTriggerCrateStore::GetCrateName(Int_t ddl, Int_t reg) const
{
- // set crate name from DDL & reg number
+ /// set crate name from DDL & reg number
Char_t name[10];
switch(reg) {
protected:
+ /// Not implemented
AliMUONTriggerCrateStore(const AliMUONTriggerCrateStore& rhs);
+ /// Not implemented
AliMUONTriggerCrateStore& operator = (const AliMUONTriggerCrateStore& rhs);
private:
static const Int_t fgkNofCells=80; ///< Number of cells
+ /// the cells content
Float_t fCellContent[4][18][2][fgkNofCells][fgkNofCells]; //[trig. chambers][RPCs][cathode][cellsX][cellsY]
Float_t fCellSize[4][18][2]; ///< the size of the cells
Int_t fCellNumber[4][18][2]; ///< id of the cells
static const Int_t fgkNofBoards=234; ///< Number of boards
+ /// the boards content
Float_t fBoardContent[4][2][fgkNofBoards]; //[trig. chambers][RPCs][cathode][board]
ClassDef(AliMUONTriggerEfficiencyCells,2) // Trigger efficiency store
//_______________________________________________________________________
void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
{
- // LOAD MASKS FROM CDB
+ /// LOAD MASKS FROM CDB
// SET MASKS
virtual void Trigger();
private:
+ /// Not implemented
AliMUONTriggerElectronics(const AliMUONTriggerElectronics& right);
+ /// Not implemented
AliMUONTriggerElectronics& operator = (const AliMUONTriggerElectronics& right);
private:
: AliMUONVGeometryBuilder(16, 4),
fMUON(muon)
{
-// Standard constructor
+/// Standard constructor
}
: AliMUONVGeometryBuilder(),
fMUON(0)
{
-// Default constructor
+/// Default constructor
}
//______________________________________________________________________________
-AliMUONTriggerGeometryBuilder::~AliMUONTriggerGeometryBuilder() {
-//
+AliMUONTriggerGeometryBuilder::~AliMUONTriggerGeometryBuilder()
+{
+/// Destructor
}
//
//______________________________________________________________________________
void AliMUONTriggerGeometryBuilder::CreateGeometry()
{
-// From AliMUONv1::CreateGeometry()
+/// From AliMUONv1::CreateGeometry()
/*
zpos1 and zpos2 are the middle of the first and second
//______________________________________________________________________________
void AliMUONTriggerGeometryBuilder::SetTransformations()
{
-// Defines the transformations for the trigger chambers.
-// ---
+/// Defines the transformations for the trigger chambers.
if (gAlice->GetModule("SHIL")) {
SetMotherVolume(16, "YOUT2");
//______________________________________________________________________________
void AliMUONTriggerGeometryBuilder::SetSensitiveVolumes()
{
-// Defines the sensitive volumes for trigger station chambers.
-// ---
+/// Defines the sensitive volumes for trigger station chambers.
GetGeometry(16)->SetSensitiveVolume("S11G");
GetGeometry(17)->SetSensitiveVolume("S12G");
virtual void CreateGeometry();
virtual void SetTransformations();
virtual void SetSensitiveVolumes();
+
+ /// Do not apply global transformation (geometry is defined in the new ALICE reference frame)
virtual bool ApplyGlobalTransformation() { return false; }
protected:
private:
+ /// Not implemented
AliMUONTriggerGeometryBuilder(const AliMUONTriggerGeometryBuilder& rhs);
-
- // operators
+ /// Not implemented
AliMUONTriggerGeometryBuilder& operator = (const AliMUONTriggerGeometryBuilder& rhs);
- AliMUON* fMUON; ///< the MUON detector class
+
+ AliMUON* fMUON; ///< the MUON detector class
ClassDef(AliMUONTriggerGeometryBuilder,1) // MUON Trigger stations geometry construction class
};
delete fAptUnde;
}
-void
-AliMUONTriggerLut::ReadFromFile(const char* filename)
+//----------------------------------------------------------------------
+void AliMUONTriggerLut::ReadFromFile(const char* filename)
{
/// Return output of LuT for corresponding TH3S
void GetLutOutput(Int_t circuit, Int_t xstrip, Int_t idev, Int_t ystrip,
Int_t lutLpt[2], Int_t lutHpt[2]);
- protected:
- // assignment operator
- AliMUONTriggerLut& operator=(const AliMUONTriggerLut& AliMUONTriggerLut);
-
private:
- // copy constructor
+ /// Not implemented copy constructor
AliMUONTriggerLut (const AliMUONTriggerLut& AliMUONTriggerLut);
+ /// Not implemented assignment operator
+ AliMUONTriggerLut& operator=(const AliMUONTriggerLut& AliMUONTriggerLut);
+
Int_t GetMask(Int_t ystrip);
private:
AliMUONTriggerSegmentation::GiveTestPoints(Int_t& /*n*/,
Float_t* /*x*/, Float_t*/*y*/) const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Float_t& x4)
{
/// \param x1 : hit x(y) position
-/// \param x2 : x(y) coordinate of the main strip
-/// \param x3 : current strip real x(y) coordinate
-/// \param x4 : dist. between x(y) hit pos. and the closest border of the current strip
+/// \param x2 : x(y) coordinate of the main strip
+/// \param x3 : current strip real x(y) coordinate
+/// \param x4 : dist. between x(y) hit pos. and the closest border of the current strip
///
/// Note : need to return (only) x4.
virtual void Init(Int_t) {} ///< Not implemented
- virtual void IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2);
+ virtual void IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& x4);
virtual Int_t ISector();
virtual Int_t Ix();
Int_t ModuleColNum(Int_t ixGlo) const;
-protected:
-
+private:
+ /// Not implemented
AliMUONTriggerSegmentation(const AliMUONTriggerSegmentation& rhs);
+ /// Not implemented
AliMUONTriggerSegmentation& operator=(const AliMUONTriggerSegmentation& rhs);
-private:
Int_t fDetElemId; ///< det elem Id
AliMp::PlaneType fPlaneType; ///< plane type
const AliMpTrigger* fSlat; ///< slat
AliMUONTriggerTrack& operator=(const AliMUONTriggerTrack& AliMUONTriggerTrack); // assignment operator
AliMUONTriggerTrack(Float_t x11, Float_t y11, Float_t thetax, Float_t thetay, Int_t iloTrg, Long_t theGTPattern);
- // getter
+ // getters
+
+ /// Return x position of fired Y strip in MC11
Float_t GetX11() const {return fx11;}
+ /// Return y position of fired X strip in MC11
Float_t GetY11() const {return fy11;}
+ /// Return track theta angle in X
Float_t GetThetax() const {return fthetax;}
+ /// Return track theta angle in Y
Float_t GetThetay() const {return fthetay;}
+ /// Return local trigger number
Int_t GetLoTrgNum() const {return floTrgNum;}
- // setter
+ // setters
+
+ /// Set x position of fired Y strip in MC11
void SetX11(Float_t x) {fx11 = x;}
+ /// Set y position of fired X strip in MC11
void SetY11(Float_t y) {fy11 = y;}
+ /// Set track theta angle in X
void SetThetax(Float_t tx) {fthetax = tx;}
+ /// Set track theta angle in Y
void SetThetay(Float_t ty) {fthetay = ty;}
+ /// Set local trigger number
void SetLoTrgNum(Int_t loTrgNum) {floTrgNum = loTrgNum;}
+ /// Set Global trigger pattern (do not work with static statement)
void SetGTPattern(UChar_t pat) {fGTPattern = pat;}
+ /// Return Global trigger pattern (do not work with static statement)
UChar_t GetGTPattern() const {return fGTPattern;}
protected:
/// Return an empty copy of self.
virtual AliMUONV2DStore* CloneEmpty() const { return 0x0; }
+ /// Return iterator
virtual AliMUONVDataIterator* Iterator() const { return 0x0; }
/// Return the object stored at (i,j).
/// Retrieve the value for a given (channel,dim) as a float.
virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const = 0;
- /// Retrieve the value for a given (channel,dim) as an integer.
+ /// Retrieve the value for a given (channel,dim) as an integer.
virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const = 0;
+ /// Return 1E38 as invalid float value
static Float_t InvalidFloatValue() { return 1E38; }
ClassDef(AliMUONVCalibParam,0) //
//_____________________________________________________________________________
AliMUONVClusterFinder::AliMUONVClusterFinder() : TObject()
{
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONVClusterFinder::~AliMUONVClusterFinder()
{
+/// Destructor
}
//_____________________________________________________________________________
AliMUONVClusterFinder();
virtual ~AliMUONVClusterFinder();
+ /// \todo add comment
virtual Bool_t Prepare(const AliMpVSegmentation* segmentations[2],
TClonesArray* digits[2]) = 0;
+ /// \todo add comment
virtual AliMUONCluster* NextCluster() = 0;
/** Add a pad to the list of pads to be considered for clustering.
AliMUONVDataIterator();
virtual ~AliMUONVDataIterator();
+ /// \todo add comment
virtual TObject* Next() = 0;
+ /// \todo add comment
virtual void Reset() = 0;
+ /// \todo add comment
virtual Bool_t Remove() = 0;
ClassDef(AliMUONVDataIterator,0) // Interface for an iterator on AliMUONData.
private:
//methods
+
+ /// Not implemented
AliMUONVGeometryBuilder(const AliMUONVGeometryBuilder& rhs);
+ /// Not implemented
AliMUONVGeometryBuilder& operator = (const AliMUONVGeometryBuilder& rhs);
TGeoHMatrix ConvertTransform(const TGeoHMatrix& transform) const;
virtual const AliMpVSegmentation* GetMpSegmentation() const = 0;
protected:
+ /// Not implemented
AliMUONVGeometryDESegmentation(const AliMUONVGeometryDESegmentation& rhs);
+ /// Not implemented
AliMUONVGeometryDESegmentation& operator=(
const AliMUONVGeometryDESegmentation& rhs);
virtual ~AliMUONVSubprocessor();
virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
+
+ /// Process this sub-task
virtual UInt_t Process(TMap* dcsAliasMap) = 0;
protected:
+ /// Return the pointer to our master
AliMUONPreprocessor* Master() const { return fMaster; }
+ /// Not implemented
AliMUONVSubprocessor();
+ /// Not implemented
AliMUONVSubprocessor(const AliMUONVSubprocessor&);
+ /// Not implemented
AliMUONVSubprocessor& operator=(const AliMUONVSubprocessor&);
private:
//__________________________________________________________________________
Bool_t AliMUONVTrackReconstructor::MakeTriggerTracks(void)
{
- // To make the trigger tracks from Local Trigger
+ /// To make the trigger tracks from Local Trigger
AliDebug(1, "Enter MakeTriggerTracks");
TTree* treeR;
// Functions
void EventReconstruct(void);
void EventReconstructTrigger(void);
- virtual void EventDump(void) = 0; // dump reconstructed event
+ virtual void EventDump(void) = 0; ///< dump reconstructed event
void EventDumpTrigger(void); // dump reconstructed trigger event
/// Return MUON data
AliMUONData* GetMUONData() {return fMUONData;}
+ /// Set MUON data
void SetMUONData(AliMUONData* data) {fMUONData = data;}
/// Set trigger circuit
void SortHitsForRecWithIncreasingChamber();
TClonesArray *MakeSegmentsInStation(Int_t station);
+ /// \todo add comment
virtual void AddHitsForRecFromRawClusters() = 0;
+ /// \todo add comment
virtual void MakeTracks(void) = 0;
+ /// \todo add comment
virtual void MakeTrackCandidates(void) = 0;
+ /// \todo add comment
virtual void FollowTracks(void) = 0;
+ /// \todo add comment
virtual void RemoveDoubleTracks(void) = 0;
+ /// \todo add comment
virtual void FillMUONTrack(void) = 0;
private:
{fStepMaxInActiveGas = StepMax; }
protected:
+ /// Not implemented
AliMUONv1(const AliMUONv1& right);
+ /// Not implemented
AliMUONv1& operator = (const AliMUONv1& right);
virtual Int_t GetGeomModuleId(Int_t volId) const;
void
AliMpArea::Print(Option_t*) const
{
+/// Printing
+
cout << (*this) << endl;
}
private:
+ /// Not implemented
AliMpBusPatch();
+ /// Not implemented
AliMpBusPatch(const AliMpBusPatch& rhs);
+ /// Not implemented
AliMpBusPatch& operator=(const AliMpBusPatch& rhs);
// static data members
- static const Int_t fgkOffset; //< Offset for conversion global/local ID
+ static const Int_t fgkOffset; ///< Offset for conversion global/local ID
// data members
Int_t fId; ///< Identifier (unique)
/// Return the motif type which contains this connection
AliMpMotifType *GetOwner() const {return fOwner;}
- void SetGassiNum(Int_t n) { fGassiNum = n; }
-
AliMpIntPair LocalIndices() const;
TString PadName() const;
//
// modifiers
//
+
+ /// Set Gassiplex channel number
+ void SetGassiNum(Int_t n) { fGassiNum = n; }
/// Set the motif type which contains this connection
void SetOwner(AliMpMotifType *owner) {fOwner=owner;}
void GetBusPerDsp(Int_t* iBusPerDSP) const;
private:
+ /// Not implemented
AliMpDDL();
+ /// Not implemented
AliMpDDL(const AliMpDDL& rhs);
+ /// Not implemented
AliMpDDL& operator=(const AliMpDDL& rhs);
// data members
private:
AliMpDDLStore();
+ /// Not implemented
AliMpDDLStore(const AliMpDDLStore& rhs);
+ /// Not implemented
AliMpDDLStore& operator=(const AliMpDDLStore& rhs);
// methods
private:
AliMpDEStore();
+ /// Not implemented
AliMpDEStore(const AliMpDEStore& rhs);
+ /// Not implemented
AliMpDEStore& operator=(const AliMpDEStore& rhs);
// methods
//__________________________________________________________
void AliMpDEVisu::DrawManuMotif(Bool_t popup)
{
- // Draw manu motif in yellow and popup channel motif window
+ /// Draw manu motif in yellow and popup channel motif window
fEcanvas->GetCanvas()->SetEditable(kTRUE);
AliMpVPainter* painter,
const char* option)
{
- // Create transient frame
+ /// Create transient frame
TCanvas* c = new TCanvas(windowName,windowName,-200,100,w,h);
const char* option);
private:
+ /// Not implemented
+ AliMpDEVisu(const AliMpDEVisu& src);
+ /// Not implemented
+ AliMpDEVisu& operator=(const AliMpDEVisu& src);
const TGWindow* fkMainWindow; //!< main window
TGMainFrame* fMain; //!< main frame
enum {kChamberCombo, kDECombo, kPlaneType, kDEName, kManuEntries, kLogMessage, kZoomMode};
- AliMpDEVisu(const AliMpDEVisu& src);
- AliMpDEVisu& operator=(const AliMpDEVisu& src);
-
ClassDef(AliMpDEVisu,1)
};
#endif
Int_t GetManuIdFromSerial(Int_t serialNb) const;
private:
+ /// Not implemented
AliMpDetElement();
+ /// Not implemented
AliMpDetElement(const AliMpDetElement& rhs);
+ /// Not implemented
AliMpDetElement& operator=(const AliMpDetElement& rhs);
// static data members
AliMp::PlaneType fPlaneType; ///< Plane type on cathod0
//AliMpExMap fBusPatches; ///< Bus patches connected to this detection element
AliMpArrayI fBusPatchIds; ///< Bus patches connected to this detection element
- mutable TExMap fManuToSerialNbs; //< Map from manuId to serial #
- mutable TExMap fSerialNbToManus; //< Map manu serial # to manuId
+ mutable TExMap fManuToSerialNbs; ///< Map from manuId to serial #
+ mutable TExMap fSerialNbToManus; ///< Map manu serial # to manuId
ClassDef(AliMpDetElement,1) // The manager class for definition of detection element types
};
void
AliMpFiles::SetTopPath(const TString& topPath)
{
+/// Set top file path
+
GetTop() = topPath;
}
void SetFirst(Int_t ix) {fFirst=ix; fValidity=true; }
/// Set second value
void SetSecond(Int_t iy) {fSecond=iy; fValidity=true;}
+ /// Set both first and second value
void Set(Int_t ix, Int_t iy) { fFirst=ix; fSecond=iy; fValidity=true; }
+ //
// TObject functions used for sorting in Root collections
+ //
+ /// Return true as Compare() function is implemented
virtual Bool_t IsSortable() const {return kTRUE;}
virtual Int_t Compare(const TObject* obj) const;
TVector2 GetPosition() const { return fPosition; }
private:
+ /// Not implemented
AliMpIteratorPainter();
+ /// Not implemented
AliMpIteratorPainter(const AliMpIteratorPainter&);
+ /// Not implemented
AliMpIteratorPainter& operator=(const AliMpIteratorPainter&);
TObjArray* fPads; //!< pads of the iterator
Int_t GetManuSerial(AliMpIntPair& pair);
private:
+ /// Not implemented
AliMpManuGeo(const AliMpManuGeo& src);
+ /// Not implemented
AliMpManuGeo& operator = (const AliMpManuGeo& src) ;
Bool_t
AliMpMotifType::Save() const
{
+/// Save this motif type
+
return Save(fID.Data());
}
fNofPads(0),
fMotifMap(0)
{
- //
- // Default ctor.
- //
+ ///
+ /// Default ctor.
+ ///
#ifdef WITH_ROOT
fMotifPositions.SetOwner(kTRUE);
#endif
fNofPads(0),
fMotifMap(motifMap)
{
- //
- // Normal ctor. Must be fed with the PCB's name (id), the pad dimensions
- // and the global dimension of the virtual enveloppe of the PCB
- // (usually 400x400 mm)
+ ///
+ /// Normal ctor. Must be fed with the PCB's name (id), the pad dimensions
+ /// and the global dimension of the virtual enveloppe of the PCB
+ /// (usually 400x400 mm)
#ifdef WITH_ROOT
fMotifPositions.SetOwner(kTRUE);
#endif
fNofPads(0),
fMotifMap(0x0)
{
- //
- // Copy constructor
+ ///
+ /// Copy constructor
#ifdef WITH_ROOT
fMotifPositions.SetOwner(kTRUE);
fNofPads(ms->GetMotifType()->GetNofPads()),
fMotifMap(0x0)
{
- //
- // Very special ctor to be used by trigger stations only (and for a very
- // specific case).
- //
- // Note that in this very case, we only allow one (special) motif per PCB.
- // This limitation might not be justified, except that it's all we need
- // so far ;-)
- //
+ ///
+ /// Very special ctor to be used by trigger stations only (and for a very
+ /// specific case).
+ ///
+ /// Note that in this very case, we only allow one (special) motif per PCB.
+ /// This limitation might not be justified, except that it's all we need
+ /// so far ;-)
+ ///
AliDebug(1,Form("this=%p (ctor special motif)",this));
AliMpPCB&
AliMpPCB::operator=(const AliMpPCB& o)
{
- // Assignment operator
+ /// Assignment operator
AliDebug(1,Form("this=%p (assignment op) : begin",this));
o.Copy(*this);
//_____________________________________________________________________________
AliMpPCB::~AliMpPCB()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
AliDebug(1,Form("this=%p",this));
#ifndef WITH_ROOT
for ( size_t i = 0; i < fMotifPositions.size(); ++i )
Double_t
AliMpPCB::ActiveXmin() const
{
- //
- // Returns the mininum x for which there is a pad in this PCB.
- // Different from Xmin only for PCB which are not full of pads.
- //
+ ///
+ /// Returns the mininum x for which there is a pad in this PCB.
+ /// Different from Xmin only for PCB which are not full of pads.
+ ///
return fActiveXmin;
}
Double_t
AliMpPCB::ActiveXmax() const
{
- //
- // Returns the maximum x for which there is a pad in this PCB.
- // Different from Xmax only for PCB which are not full of pads.
- //
+ ///
+ /// Returns the maximum x for which there is a pad in this PCB.
+ /// Different from Xmax only for PCB which are not full of pads.
+ ///
return fActiveXmax;
}
void
AliMpPCB::Add(AliMpMotifType* mt, Int_t ix, Int_t iy)
{
- //
- // Add a motif to this PCB. (ix,iy) indicates one corner position of the motif
- // where the sign of ix and iy is used to indicate which corner is the
- // reference (then for values, abs(ix) and abs(iy) are used indeed) :
- //
- // (ix>0,iy>0) : bottom-left corner
- // (ix<0,iy>0) : bottom-right corner
- // (ix<0,iy<0) : top-right corner
- // (ix>0,iy<0) : top-left corner.
+ ///
+ /// Add a motif to this PCB. (ix,iy) indicates one corner position of the motif
+ /// where the sign of ix and iy is used to indicate which corner is the
+ /// reference (then for values, abs(ix) and abs(iy) are used indeed) :
+ ///
+ /// (ix>0,iy>0) : bottom-left corner
+ /// (ix<0,iy>0) : bottom-right corner
+ /// (ix<0,iy<0) : top-right corner
+ /// (ix>0,iy<0) : top-left corner.
TString id(Form("%s-%e-%e",mt->GetID().Data(),PadSizeX(),PadSizeY()));
AliMpArea
AliMpPCB::Area() const
{
+ /// Return the area of this PCB
+
return AliMpArea(TVector2( (Xmin()+Xmax())/2.0,DY()),
TVector2( DX(), DY() ) );
}
TObject*
AliMpPCB::Clone(const char* /*newname*/) const
{
- //
- // Return a full copy of this object.
- //
+ ///
+ /// Return a full copy of this object.
+ ///
AliDebug(1,"begin");
TObject* object = new AliMpPCB(*this);
AliDebug(1,"end");
AliMpPCB*
AliMpPCB::Clone(const TArrayI& manuids, Int_t ixOffset, Double_t xOffset) const
{
- //
- // Get a full copy of *this, and then apply 2 changes to it :
- //
- // a) define the relationship motifType <-> manu id
- // b) define the x-offset
- // c) shift ix indices backwards to insure that e.g. the first
- // pcb of a slat will start at ix=0 (only relevant for rounded pcbs).
- //
+ ///
+ /// Get a full copy of *this, and then apply 2 changes to it :
+ ///
+ /// a) define the relationship motifType <-> manu id
+ /// b) define the x-offset
+ /// c) shift ix indices backwards to insure that e.g. the first
+ /// pcb of a slat will start at ix=0 (only relevant for rounded pcbs).
+ ///
AliDebug(1,"begin");
void
AliMpPCB::Copy(TObject& o) const
{
- // Copy *this into o
+ /// Copy *this into o
AliDebug(1,"begin");
Double_t
AliMpPCB::ActiveDX() const
{
- //
- // Half-length (in x-direction) occupied by pads
- //
+ ///
+ /// Half-length (in x-direction) occupied by pads
+ ///
return GetNofPadsX()*fPadSizeX/2.0;
}
Double_t
AliMpPCB::DX() const
{
- //
- // Half-length (in x-direction) of the PCB.
- // This length is the one of the virtual enveloppe of the PCB and might
- // be bigger than the length occupied by pads (e.g. for rounded or short
- // PCBs).
- // See also ActiveDX().
- //
+ ///
+ /// Half-length (in x-direction) of the PCB.
+ /// This length is the one of the virtual enveloppe of the PCB and might
+ /// be bigger than the length occupied by pads (e.g. for rounded or short
+ /// PCBs).
+ /// See also ActiveDX().
+ ///
return fEnveloppeSizeX/2.0;
}
Double_t
AliMpPCB::ActiveDY() const
{
- //
- // Half-length (in y-direction) occupied by pads
- //
+ ///
+ /// Half-length (in y-direction) occupied by pads
+ ///
return GetNofPadsY()*fPadSizeY/2.0;
}
Double_t
AliMpPCB::DY() const
{
- //
- // Half-length (in y-direction) of the PCB.
- // This length is the one of the virtual enveloppe of the PCB and might
- // be bigger than the length occupied by pads (e.g. for rounded or short
- // PCBs).
- // See also ActiveDY().
- //
+ ///
+ /// Half-length (in y-direction) of the PCB.
+ /// This length is the one of the virtual enveloppe of the PCB and might
+ /// be bigger than the length occupied by pads (e.g. for rounded or short
+ /// PCBs).
+ /// See also ActiveDY().
+ ///
return fEnveloppeSizeY/2.0;
}
AliMpMotifPosition*
AliMpPCB::FindMotifPosition(Int_t ix, Int_t iy) const
{
- //
- // Returns the motifPosition located at the position referenced by
- // integer indices (ix,iy).
- //
+ ///
+ /// Returns the motifPosition located at the position referenced by
+ /// integer indices (ix,iy).
+ ///
#ifdef WITH_ROOT
for (Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
AliMpMotifPosition*
AliMpPCB::FindMotifPosition(Double_t x, Double_t y) const
{
- //
- // Returns the motifPosition located at position (x,y)
- //
+ ///
+ /// Returns the motifPosition located at position (x,y)
+ ///
#ifdef WITH_ROOT
for (Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
const char*
AliMpPCB::GetID() const
{
- //
- // Returns the name of this PCB.
- //
+ ///
+ /// Returns the name of this PCB.
+ ///
return fId.Data();
}
AliMpMotifPosition*
AliMpPCB::GetMotifPosition(AliMpPCB::Size_t i) const
{
- //
- // Get the i-th motifPosition stored in this PCB's internal array.
- //
+ ///
+ /// Get the i-th motifPosition stored in this PCB's internal array.
+ ///
#ifdef WITH_ROOT
if ( i >= fMotifPositions.GetEntriesFast() ) return 0;
Int_t
AliMpPCB::GetNofPadsX() const
{
- //
- // Returns the number of pads in x-direction.
- //
+ ///
+ /// Returns the number of pads in x-direction.
+ ///
return fIxmax-fIxmin+1;
}
Int_t
AliMpPCB::GetNofPadsY() const
{
- //
- // Returns the number of pads in y-direction.
- //
+ ///
+ /// Returns the number of pads in y-direction.
+ ///
return fIymax-fIymin+1;
}
AliMpPCB::Size_t
AliMpPCB::GetSize() const
{
- //
- // Returns the number of motifPositions stored in this PCB.
- //
+ ///
+ /// Returns the number of motifPositions stored in this PCB.
+ ///
#ifdef WITH_ROOT
return fMotifPositions.GetEntriesFast();
Int_t
AliMpPCB::Ixmin() const
{
- //
- // Returns the index value of the leftmost pad.
- //
+ ///
+ /// Returns the index value of the leftmost pad.
+ ///
return fIxmin;
}
Int_t
AliMpPCB::Ixmax() const
{
- //
- // Returns the index value of the rightmost pad.
- //
+ ///
+ /// Returns the index value of the rightmost pad.
+ ///
return Ixmin() + GetNofPadsX() - 1;
}
Int_t
AliMpPCB::Iymin() const
{
- //
- // Returns the index value of the bottom pad.
- //
+ ///
+ /// Returns the index value of the bottom pad.
+ ///
return fIymin;
}
Int_t
AliMpPCB::Iymax() const
{
- //
- // Returns the index value of the top pad.
- //
+ ///
+ /// Returns the index value of the top pad.
+ ///
return Iymin() + GetNofPadsY() - 1;
}
Double_t
AliMpPCB::PadSizeX() const
{
- //
- // Returns the pad size in x-direction (in mm)
- //
+ ///
+ /// Returns the pad size in x-direction (in mm)
+ ///
return fPadSizeX;
}
Double_t
AliMpPCB::PadSizeY() const
{
- //
- // Returns the pad size in y-direction (in mm)
- //
+ ///
+ /// Returns the pad size in y-direction (in mm)
+ ///
return fPadSizeY;
}
void
AliMpPCB::Print(Option_t* option) const
{
- //
- // Printout of this PCB.
- // If option="M", the contained motifs are printed too.
- //
+ ///
+ /// Printout of this PCB.
+ /// If option="M", the contained motifs are printed too.
+ ///
cout << "PCB " << GetID() << " PADSIZES=(" << fPadSizeX << ","
<< fPadSizeY << ") iMin=(" << fIxmin << "," << fIymin << ") "
void
AliMpPCB::Save() const
{
- //
- // Save this PCB in the file
+ ///
+ /// Save this PCB in the file
TString fileName(fId);
fileName += ".pcb";
Double_t
AliMpPCB::X() const
{
- //
- // Returns the x-position of the PCB center.
- //
+ ///
+ /// Returns the x-position of the PCB center.
+ ///
return fXoffset + DX();
}
Double_t
AliMpPCB::Xmin() const
{
- //
- // Returns the leftmost x-position in this PCB.
- //
+ ///
+ /// Returns the leftmost x-position in this PCB.
+ ///
return X() - DX();
}
Double_t
AliMpPCB::Xmax() const
{
- //
- // Returns the rightmost x-position in this PCB.
- //
+ ///
+ /// Returns the rightmost x-position in this PCB.
+ ///
return X() + DX();
}
Double_t
AliMpPCB::Y() const
{
- //
- // Returns the y-position of the PCB center.
- //
+ ///
+ /// Returns the y-position of the PCB center.
+ ///
return DY(); // this works as PCB are organized in a single row within slats.
}
Double_t
AliMpPCB::Ymin() const
{
- //
- // Returns the smallest y-position in this PCB.
- //
+ ///
+ /// Returns the smallest y-position in this PCB.
+ ///
return Y() - DY();
}
Double_t
AliMpPCB::Ymax() const
{
- //
- // Returns the largest y-position in this PCB.
- //
+ ///
+ /// Returns the largest y-position in this PCB.
+ ///
return Y() + DY();
}
public:
#ifdef WITH_ROOT
+ /// Type def for the array size
typedef Int_t Size_t;
#else
+ /// Type def for the array size
typedef UInt_t Size_t;
#endif
const char* GetID() const;
+ /// Return the number of pads in this PCB
Int_t NofPads() const { return fNofPads; }
+ /// Return the motif map
AliMpSlatMotifMap* MotifMap() const { return fMotifMap; }
void Save() const;
Double_t fPadSizeX; ///< x-size of this PCB's pads (cm)
Double_t fPadSizeY; ///< y-size of this PCB's pads (cm)
Double_t fEnveloppeSizeX; ///< max x-size of this PCB (cm)
- Double_t fEnveloppeSizeY; // max y-size of this PCB (cm)
+ Double_t fEnveloppeSizeY; ///< max y-size of this PCB (cm)
Double_t fXoffset; ///< x-offset = x of first pad of this PCB (cm)
Double_t fActiveXmin; ///< min x of an actual pad in this PCB (cm)
Double_t fActiveXmax; ///< max x of an actual pad in this PCB (cm)
fCurrentPad(),
fIsDone(kTRUE)
{
- //
- // Normal ctor.
- // Iteration will be done on the slat, over the crop of (area,slat_area)
- //
+ ///
+ /// Normal ctor.
+ /// Iteration will be done on the slat, over the crop of (area,slat_area)
+ ///
if (!CropArea(area))
{
AliError(Form("Could not crop area : (x,y)min=(%e,%e) ; max=(%e,%e) for slat %s",
//_____________________________________________________________________________
AliMpPCBPadIterator::~AliMpPCBPadIterator()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
delete fSlatSegmentation;
}
Bool_t
AliMpPCBPadIterator::CropArea(const AliMpArea& area)
{
- //
- // Checks the area is correct, and truncate it
- // if it goes outside the slat.
+ ///
+ /// Checks the area is correct, and truncate it
+ /// if it goes outside the slat.
AliDebug(3,Form("Input area (%7.2f,%7.2f)->(%7.2f,%7.2f)",
area.LeftBorder(),area.DownBorder(),
AliMpPad
AliMpPCBPadIterator::CurrentItem() const
{
- //
- // Returns the current iteration position (i.e. a pad)
- //
+ ///
+ /// Returns the current iteration position (i.e. a pad)
+ ///
return fCurrentPad;
}
void
AliMpPCBPadIterator::First()
{
- //
- // (re)Starts the iteration.
- //
+ ///
+ /// (re)Starts the iteration.
+ ///
AliDebug(3,Form("area = (%d,%d)->(%d,%d)",
fMinIndices.GetFirst(),fMinIndices.GetSecond(),
Bool_t
AliMpPCBPadIterator::GetNextPosition(Int_t& ix, Int_t& iy)
{
- // Get the next iteration position.
- // On input, fOffset must be a valid position (i.e. within iteration
- // area already).
+ /// Get the next iteration position.
+ /// On input, fOffset must be a valid position (i.e. within iteration
+ /// area already).
++ix;
void
AliMpPCBPadIterator::Invalidate()
{
- //
- // Invalidate the iterator.
- //
+ ///
+ /// Invalidate the iterator.
+ ///
fOffset = AliMpIntPair::Invalid();
fCurrentPad = AliMpPad::Invalid();
fIsDone = kTRUE;
Bool_t
AliMpPCBPadIterator::IsDone() const
{
- //
- // Whether the iteration is finished or not.
- //
+ ///
+ /// Whether the iteration is finished or not.
+ ///
return fIsDone;
}
void
AliMpPCBPadIterator::Next()
{
- // This one is the meat of the class.
- // We're iterating in x-direction mainly, starting from
- // lower-left of the iteration area, and proceeding right,
- // until we reach right border, in which case we increment y
- // and go back to leftmost position.
- // End of iteration occurs when both x and y are outside the iteration
- // window.
+ /// This one is the meat of the class.
+ /// We're iterating in x-direction mainly, starting from
+ /// lower-left of the iteration area, and proceeding right,
+ /// until we reach right border, in which case we increment y
+ /// and go back to leftmost position.
+ /// End of iteration occurs when both x and y are outside the iteration
+ /// window.
if (IsDone()) return;
void
AliMpPCBPadIterator::SetPad(AliMpPad& pad, const AliMpIntPair& indices)
{
- //
- // Sets the current pad.
- //
+ ///
+ /// Sets the current pad.
+ ///
pad = fSlatSegmentation->PadByIndices(indices,kFALSE);
if (pad.IsValid())
{
void Print(Option_t* opt="") const;
private:
- AliMpPCBPadIterator(const AliMpPCBPadIterator& right);
+ /// Not implemented
+ AliMpPCBPadIterator(const AliMpPCBPadIterator& right);
+ /// Not implemented
AliMpPCBPadIterator& operator = (const AliMpPCBPadIterator& right);
Bool_t GetNextPosition(Int_t& ix, Int_t& iy);
void SetPad(AliMpPad& pad, const AliMpIntPair& indices);
private:
- const AliMpSlat* fkSlat; //!< the slat we're iterating over
+ const AliMpSlat* fkSlat; //!< the slat we're iterating over
AliMpSlatSegmentation* fSlatSegmentation; //!< segmentation pointer
AliMpIntPair fMinIndices; //!< indices of bottom left of region to iterate over
AliMpIntPair fMaxIndices; //!< indices of top right of region to iterate over
AliMpPCBPainter::AliMpPCBPainter(AliMpPCB* pcb)
: AliMpVPainter(), fPCB(pcb)
{
- //
- // Default ctor.
- //
+ ///
+ /// Default ctor.
+ ///
}
//_____________________________________________________________________________
AliMpPCBPainter::~AliMpPCBPainter()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
}
//_____________________________________________________________________________
TVector2
AliMpPCBPainter::GetDimensions() const
{
- //
- // Returns the half-sizes of the PCB.
- //
+ ///
+ /// Returns the half-sizes of the PCB.
+ ///
return TVector2(fPCB->DX(),fPCB->DY());
}
TVector2
AliMpPCBPainter::GetPosition() const
{
- //
- // Returns the (x,y) position of the PCB.
- //
+ ///
+ /// Returns the (x,y) position of the PCB.
+ ///
return TVector2(fPCB->X(),fPCB->Y());
}
void
AliMpPCBPainter::Draw(Option_t* option)
{
- //
- // Draws the PCB.
- //
+ ///
+ /// Draws the PCB.
+ ///
AliMpGraphContext *gr = AliMpGraphContext::Instance();
if (!fPCB) return;
void
AliMpPCBPainter::Paint(Option_t* /*option*/)
{
- //
- // Paint the object.
- //
+ ///
+ /// Paint the object.
+ ///
AliMpGraphContext* gr = AliMpGraphContext::Instance();
if (!fPCB) return;
Int_t col=gVirtualX->GetFillColor();
TVector2 GetPosition() const;
private:
+ /// Not implemented
AliMpPCBPainter(const AliMpPCBPainter& right);
+ /// Not implemented
AliMpPCBPainter& operator = (const AliMpPCBPainter& right);
AliMpPCB* fPCB; //!< PCB to be plotted.
void
AliMpSectorSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
{
+ /// Fill the array ecn with all manuIds
+
GetSector()->GetAllMotifPositionsIDs(ecn);
}
fPosition(),
fNofPads(0)
{
- //
- // Empty ctor.
- //
+ ///
+ /// Empty ctor.
+ ///
AliDebug(1,Form("this=%p Empty ctor",this));
#ifdef WITH_ROOT
fPCBs.SetOwner(kTRUE);
fPosition(),
fNofPads(0)
{
- //
- // Normal ctor
- //
+ ///
+ /// Normal ctor
+ ///
AliDebug(1,Form("this=%p id=%s",this,id));
#ifdef WITH_ROOT
fPCBs.SetOwner(kTRUE);
//_____________________________________________________________________________
AliMpSlat::~AliMpSlat()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
AliDebug(1,Form("this=%p fId=%s",this,fId.Data()));
#ifdef WITH_ROOT
fPCBs.Delete();
void
AliMpSlat::Add(const AliMpPCB& pcbType, const TArrayI& manuList)
{
- //
- // Adds a PCB to this slat. The manuList specifies the ids of the manu
- // that compose the PCB. The manuList ordering is important, as the
- // assumption is that it's ordered counter-clockwise, starting from
- // the lower-left of the PCB.
- //
+ ///
+ /// Adds a PCB to this slat. The manuList specifies the ids of the manu
+ /// that compose the PCB. The manuList ordering is important, as the
+ /// assumption is that it's ordered counter-clockwise, starting from
+ /// the lower-left of the PCB.
+ ///
Int_t ixOffset = 0;
if ( GetSize() )
{
TVector2
AliMpSlat::Dimensions() const
{
- //
- // Returns the half-sizes of the slat.
- //
+ ///
+ /// Returns the half-sizes of the slat.
+ ///
return TVector2(DX(),DY());
}
Double_t
AliMpSlat::DX() const
{
- //
- // Returns the x-half-size of the slat.
- //
+ ///
+ /// Returns the x-half-size of the slat.
+ ///
return fDX;
}
Double_t
AliMpSlat::DY() const
{
- //
- // Returns the y-half-size of the slat.
- //
+ ///
+ /// Returns the y-half-size of the slat.
+ ///
return fDY;
}
AliMpMotifPosition*
AliMpSlat::FindMotifPosition(Int_t manuID) const
{
- //
- // Returns the motifPosition referenced by it manuID
- //
+ ///
+ /// Returns the motifPosition referenced by it manuID
+ ///
//#ifdef WITH_ROOT
return static_cast<AliMpMotifPosition*>(fManuMap.GetValue(manuID));
//#else
AliMpMotifPosition*
AliMpSlat::FindMotifPosition(Int_t ix, Int_t iy) const
{
- //
- // 1. Find the PCB containing ix (iy not needed for this)
- // 2. Forward the request to the PCB, using pcb local indices.
+ ///
+ /// - 1. Find the PCB containing ix (iy not needed for this)
+ /// - 2. Forward the request to the PCB, using pcb local indices.
//
const AliMpPCB* pcb = FindPCB(ix);
if ( pcb )
AliMpMotifPosition*
AliMpSlat::FindMotifPosition(Double_t x, Double_t y) const
{
- //
- // Returns the motifPosition containing position (x,y)
- //
+ ///
+ /// Returns the motifPosition containing position (x,y)
+ ///
const AliMpPCB* pcb = FindPCB(x,y);
if (pcb)
{
AliMpPCB*
AliMpSlat::FindPCB(Int_t ix) const
{
- //
- // Returns the PCB containing x-integer-position ix
- //
+ ///
+ /// Returns the PCB containing x-integer-position ix
+ ///
for ( Size_t i = 0; i < GetSize(); ++i )
{
AliMpPCB* pcb = GetPCB(i);
Int_t
AliMpSlat::FindPCBIndex(Int_t ix) const
{
- //
- // Returns the index of the PCB containing x-integer-position ix.
- //
+ ///
+ /// Returns the index of the PCB containing x-integer-position ix.
+ ///
for ( Size_t i = 0; i < GetSize(); ++i )
{
AliMpPCB* pcb = GetPCB(i);
AliMpPCB*
AliMpSlat::FindPCB(Double_t x, Double_t y) const
{
- //
- // Returns the PCB containing position (x,y)
- //
+ ///
+ /// Returns the PCB containing position (x,y)
+ ///
for ( Size_t i = 0; i < GetSize(); ++i )
{
AliMpPCB* pcb = GetPCB(i);
Int_t
AliMpSlat::FindPCBIndex(Double_t x, Double_t y) const
{
- //
- // Returns the index of the PCB containing position (x,y)
- //
+ ///
+ /// Returns the index of the PCB containing position (x,y)
+ ///
for ( Size_t i = 0; i < GetSize(); ++i )
{
AliMpPCB* pcb = GetPCB(i);
void
AliMpSlat::ForcePosition(const TVector2& pos)
{
- //
- // Force the position to be different from (DX(),DY()).
- // Normally only used by triggerSlats (for layers).
- // Beware that this method must be called once all PCB have been added,
- // as the Add() method resets the position.
- //
+ ///
+ /// Force the position to be different from (DX(),DY()).
+ /// Normally only used by triggerSlats (for layers).
+ /// Beware that this method must be called once all PCB have been added,
+ /// as the Add() method resets the position.
+ ///
fPosition = pos;
}
void
AliMpSlat::GetAllMotifPositionsIDs(TArrayI& ecn) const
{
- //
- // Return all the manuIds (=MotifPositionIDs) of this slat
- //
+ ///
+ /// Return all the manuIds (=MotifPositionIDs) of this slat
+ ///
ecn.Set(GetNofElectronicCards());
//#ifdef WITH_ROOT
TExMapIter it(fManuMap.GetIterator());
const char*
AliMpSlat::GetID() const
{
- //
- // Returns the name of this slat.
- //
+ ///
+ /// Returns the name of this slat.
+ ///
return fId.Data();
}
Int_t
AliMpSlat::GetMaxNofPadsY() const
{
- //
- // Returns the maximum number of pads to be found in this slat y-direction.
- //
+ ///
+ /// Returns the maximum number of pads to be found in this slat y-direction.
+ ///
return fMaxNofPadsY;
}
Int_t
AliMpSlat::GetMaxPadIndexX() const
{
- //
- // Returns the max ix that is valid for this slat.
- //
+ ///
+ /// Returns the max ix that is valid for this slat.
+ ///
AliMpPCB* last = GetPCB(GetSize()-1);
if (last)
{
const char*
AliMpSlat::GetName() const
{
- //
- // Returns the name of this slat, which is composed of its ID with
- // the plane type as a suffix.
- //
+ ///
+ /// Returns the name of this slat, which is composed of its ID with
+ /// the plane type as a suffix.
+ ///
TString name(GetID());
if ( fPlaneType == AliMp::kBendingPlane )
{
Int_t
AliMpSlat::GetNofElectronicCards() const
{
- //
- // Returns the number of manus that compose the readout of this slat.
- //
+ ///
+ /// Returns the number of manus that compose the readout of this slat.
+ ///
return fManuMap.GetSize();
}
Int_t
AliMpSlat::GetNofPadsX() const
{
- //
- // Returns the number of pad in x-direction.
- //
+ ///
+ /// Returns the number of pad in x-direction.
+ ///
return fNofPadsX;
}
AliMpPCB*
AliMpSlat::GetPCB(AliMpSlat::Size_t i) const
{
- //
- // Returns the i-th PCB of this slat.
- //
+ ///
+ /// Returns the i-th PCB of this slat.
+ ///
#ifdef WITH_ROOT
if ( i >= fPCBs.GetEntriesFast() ) return 0;
return (AliMpPCB*)fPCBs[i];
AliMpSlat::Size_t
AliMpSlat::GetSize() const
{
- //
- // Returns the number of PCB in this slat.
- //
+ ///
+ /// Returns the number of PCB in this slat.
+ ///
#ifdef WITH_ROOT
return fPCBs.GetEntriesFast();
#else
void
AliMpSlat::Print(Option_t* option) const
{
- //
- // Prints the slat characteristics.
- //
+ ///
+ /// Prints the slat characteristics.
+ ///
cout << "SLAT " << GetID() << " 1/2 DIM = (" << DX() << "," << DY() << ")"
<< " POS = " << Position().X() << "," << Position().Y()
<< " NPADSX = " << GetNofPadsX()
public:
#ifdef WITH_ROOT
+ /// Type def for the array size
typedef Int_t Size_t;
#else
+ /// Type def for the array size
typedef UInt_t Size_t;
#endif
virtual ~AliMpSlat();
TVector2 Dimensions() const;
+
+ /// Return position
TVector2 Position() const { return fPosition; }
const char* GetName() const;
*/
void ForcePosition(const TVector2& pos);
+ /// Return the plane type
AliMp::PlaneType PlaneType() const { return fPlaneType; }
+ /// Return the number of pads in this slat
Int_t NofPads() const { return fNofPads; }
private:
+ /// Not implemented
AliMpSlat(const AliMpSlat& rhs);
+ /// Not implemented
AliMpSlat& operator=(const AliMpSlat& rhs);
TString fId; ///< The name of this slat, e.g. 112233N
void Reset();
private:
- TMap fMotifs; //< collection of motifs
- TMap fMotifTypes; //< collection of motifTypes
+ TMap fMotifs; ///< collection of motifs
+ TMap fMotifTypes; ///< collection of motifTypes
- ClassDef(AliMpSlatMotifMap,1) //
+ ClassDef(AliMpSlatMotifMap,1) // Slat motif map
};
#endif
fCurrentDelegate(0),
fCurrentDelegateIndex(0)
{
- //
- // Empty (default) ctor.
- //
+ ///
+ /// Empty (default) ctor.
+ ///
}
//_____________________________________________________________________________
fCurrentDelegate(0),
fCurrentDelegateIndex(0)
{
- //
- // Normal ctor.
- // The iteration will occur on the given slat over the specified area.
- //
+ ///
+ /// Normal ctor.
+ /// The iteration will occur on the given slat over the specified area.
+ ///
AliDebug(1,Form("this=%p ctor area=(%e,%e,%e,%e)",this,
area.LeftBorder(),area.DownBorder(),
area.RightBorder(),area.UpBorder()));
//_____________________________________________________________________________
AliMpSlatPadIterator::~AliMpSlatPadIterator()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
AliDebug(1,Form("this=%p dtor",this));
Invalidate();
}
AliMpArea
AliMpSlatPadIterator::Intersect(const AliMpArea& a, const AliMpArea& b) const
{
- //
- // Returns the common part of a and b.
- //
+ ///
+ /// Returns the common part of a and b.
+ ///
AliDebug(4,Form("a=(%7.2f,%7.2f;%7.2f,%7.2f) b=(%7.2f,%7.2f;%7.2f,%7.2f)",
a.LeftBorder(),a.DownBorder(),a.RightBorder(),a.UpBorder(),
b.LeftBorder(),b.DownBorder(),b.RightBorder(),b.UpBorder()));
Bool_t
AliMpSlatPadIterator::Prepare(const AliMpArea& area)
{
- //
- // Split area into smaller area intersecting pcbs,
- // and allocate the corresponding delegate iterators.
+ ///
+ /// Split area into smaller area intersecting pcbs,
+ /// and allocate the corresponding delegate iterators.
for ( AliMpSlat::Size_t i = 0; i < fkSlat->GetSize(); ++i )
{
AliMpPad
AliMpSlatPadIterator::CurrentItem() const
{
- //
- // Returns the current pad of the iteration.
- //
+ ///
+ /// Returns the current pad of the iteration.
+ ///
if ( fCurrentDelegate )
{
return fCurrentDelegate->CurrentItem();
void
AliMpSlatPadIterator::First()
{
- //
- // (Re)starts the iteration.
- //
+ ///
+ /// (Re)starts the iteration.
+ ///
if ( fDelegates.GetLast() < 0 )
{
AliError("Iterator is not valid, as it gets no delegates at all !");
void
AliMpSlatPadIterator::Invalidate()
{
- //
- // Make the iterator invalid.
- //
+ ///
+ /// Make the iterator invalid.
+ ///
fDelegates.Delete();
fCurrentDelegate = 0;
fCurrentDelegateIndex = 0;
Bool_t
AliMpSlatPadIterator::IsDone() const
{
- //
- // Returns whether the iteration is ended or not.
- //
+ ///
+ /// Returns whether the iteration is ended or not.
+ ///
return ( !fCurrentDelegate ||
( fCurrentDelegateIndex > fDelegates.GetLast() &&
fCurrentDelegate->IsDone() ) );
void
AliMpSlatPadIterator::Next()
{
- //
- // Next step of the iteration.
- //
+ ///
+ /// Next step of the iteration.
+ ///
if (IsDone()) return;
fCurrentDelegate->Next();
void Invalidate();
private:
+ /// Not implemented
AliMpSlatPadIterator(const AliMpSlatPadIterator&);
- AliMpSlatPadIterator& operator=(const AliMpSlatPadIterator&);
+ /// Not implemented
+ AliMpSlatPadIterator& operator=(const AliMpSlatPadIterator&);
+
Bool_t Prepare(const AliMpArea& area);
AliMpArea Intersect(const AliMpArea& a, const AliMpArea& b) const;
: AliMpVPainter(),
fkSlat(0)
{
- //
- // Empty ctor.
- //
+ ///
+ /// Empty ctor.
+ ///
}
//_____________________________________________________________________________
: AliMpVPainter(),
fkSlat(slat)
{
- //
- // Normal ctor.
- //
+ ///
+ /// Normal ctor.
+ ///
}
//_____________________________________________________________________________
AliMpSlatPainter::~AliMpSlatPainter()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
}
//_____________________________________________________________________________
TVector2
AliMpSlatPainter::GetDimensions() const
{
- //
- // Returns the half-sizes of the slat.
- //
+ ///
+ /// Returns the half-sizes of the slat.
+ ///
return TVector2(fkSlat->DX(),fkSlat->DY());
}
TVector2
AliMpSlatPainter::GetPosition() const
{
- //
- // Returns the (x,y) position of the slat.
- //
+ ///
+ /// Returns the (x,y) position of the slat.
+ ///
return TVector2(fkSlat->DX(),fkSlat->DY());
}
void
AliMpSlatPainter::Draw(Option_t* option)
{
- //
- // Draws the slat.
- //
- // If option[0] is 'P' then PCB are drawn too.
- //
+ ///
+ /// Draws the slat.
+ ///
+ /// If option[0] is 'P' then PCB are drawn too.
+ ///
AliMpGraphContext *gr = AliMpGraphContext::Instance();
gr->Push();
void
AliMpSlatPainter::Paint(Option_t* /*option*/)
{
- //
- // Paint the object.
- //
+ ///
+ /// Paint the object.
+ ///
AliMpGraphContext* gr = AliMpGraphContext::Instance();
Int_t col=gVirtualX->GetFillColor();
void Paint(Option_t* option);
private:
+ /// Not implemented
AliMpSlatPainter(const AliMpSlatPainter& right);
+ /// Not implemented
AliMpSlatPainter& operator = (const AliMpSlatPainter& right);
const AliMpSlat* fkSlat; //!< pointer to the slat to be drawn
fkSlat(0),
fIsOwner(false)
{
- //
- // Default ctor. Not to be used really.
- //
+ ///
+ /// Default ctor. Not to be used really.
+ ///
AliDebug(1,Form("this=%p Empty ctor",this));
}
fkSlat(slat),
fIsOwner(own)
{
- //
- // Normal ctor.
- //
+ ///
+ /// Normal ctor.
+ ///
AliDebug(1,Form("this=%p Normal ctor slat=%p",this,slat));
}
//_____________________________________________________________________________
AliMpSlatSegmentation::~AliMpSlatSegmentation()
{
- //
- // Dtor (empty).
- //
+ ///
+ /// Dtor (empty).
+ ///
if ( fIsOwner ) delete fkSlat;
AliMpVPadIterator*
AliMpSlatSegmentation::CreateIterator(const AliMpArea& area) const
{
- //
- // Returns an iterator to loop over the pad contained within given area.
- //
+ ///
+ /// Returns an iterator to loop over the pad contained within given area.
+ ///
AliMpArea a(area.Position()+fkSlat->Position(),area.Dimensions());
AliDebug(3,Form("Converted input area wrt to slat center : "
"%7.2f,%7.2f->%7.2f,%7.2f to wrt slat lower-left : "
TVector2
AliMpSlatSegmentation::Dimensions() const
{
+ /// Return dimensions
+
return Slat()->Dimensions();
}
void
AliMpSlatSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
{
+ /// Fill the array ecn with all manuIds
+
Slat()->GetAllMotifPositionsIDs(ecn);
}
const char*
AliMpSlatSegmentation::GetName() const
{
- // The name of this segmentation is "SlatSegmentation"+slatName
+ /// The name of this segmentation is "SlatSegmentation"+slatName
TString name("SlatSegmentation");
if ( fkSlat)
Bool_t
AliMpSlatSegmentation::HasPad(const AliMpIntPair& indices) const
{
- //
- // Test if this slat has a pad located at the position referenced
- // by the integer indices.
- //
+ ///
+ /// Test if this slat has a pad located at the position referenced
+ /// by the integer indices.
+ ///
return PadByIndices(indices,kFALSE) != AliMpPad::Invalid();
}
Int_t
AliMpSlatSegmentation::MaxPadIndexX() const
{
- //
- // Returns the value of the largest pad index in x-direction.
- //
+ ///
+ /// Returns the value of the largest pad index in x-direction.
+ ///
return fkSlat->GetMaxPadIndexX();
}
Int_t
AliMpSlatSegmentation::MaxPadIndexY() const
{
- //
- // Returns the value of the largest pad index in y-direction.
- //
+ ///
+ /// Returns the value of the largest pad index in y-direction.
+ ///
return fkSlat->GetMaxNofPadsY()-1;
}
AliMpSlatSegmentation::PadByLocation(const AliMpIntPair& location,
Bool_t warning) const
{
- //
- // Returns the pad specified by its location, where location is the
- // pair (ManuID,ManuChannel).
- // If warning=kTRUE and the pad does not exist, a warning message is
- // printed.
- //
- // AliMpPad::Invalid() is returned if there's no pad at the given location.
- //
+ ///
+ /// Returns the pad specified by its location, where location is the
+ /// pair (ManuID,ManuChannel).
+ /// If warning=kTRUE and the pad does not exist, a warning message is
+ /// printed.
+ ///
+ /// AliMpPad::Invalid() is returned if there's no pad at the given location.
+ ///
Int_t manuID = location.GetFirst();
AliMpMotifPosition* motifPos = fkSlat->FindMotifPosition(manuID);
AliMpSlatSegmentation::PadByIndices(const AliMpIntPair& indices,
Bool_t warning) const
{
- //
- // Returns the pad specified by its integer indices.
- // If warning=kTRUE and the pad does not exist, a warning message is
- // printed.
- //
- // AliMpPad::Invalid() is returned if there's no pad at the given location.
- //
- //
- // FIXME: except for the FindMotifPosition below, this method
- // is exactly as the one in AliMpSectorSegmentation.
- // See if we can merge them somehow.
+ ///
+ /// Returns the pad specified by its integer indices.
+ /// If warning=kTRUE and the pad does not exist, a warning message is
+ /// printed.
+ ///
+ /// AliMpPad::Invalid() is returned if there's no pad at the given location.
+ ///
+ ///
+ /// FIXME: except for the FindMotifPosition below, this method
+ /// is exactly as the one in AliMpSectorSegmentation.
+ /// See if we can merge them somehow.
AliMpMotifPosition* motifPos = fkSlat->FindMotifPosition(indices.GetFirst(),
indices.GetSecond());
AliMpSlatSegmentation::PadByPosition(const TVector2& position,
Bool_t warning) const
{
- //
- // Returns the pad specified by its (floating point) position.
- // If warning=kTRUE and the pad does not exist, a warning message is
- // printed.
- //
- // AliMpPad::Invalid() is returned if there's no pad at the given location.
- //
+ ///
+ /// Returns the pad specified by its (floating point) position.
+ /// If warning=kTRUE and the pad does not exist, a warning message is
+ /// printed.
+ ///
+ /// AliMpPad::Invalid() is returned if there's no pad at the given location.
+ ///
TVector2 blPos(position);
void
AliMpSlatSegmentation::Print(Option_t* opt) const
{
+/// Printing
+
fkSlat->Print(opt);
}
const AliMpSlat*
AliMpSlatSegmentation::Slat() const
{
- //
- // Returns the pointer to the referenced slat.
- //
+ ///
+ /// Returns the pointer to the referenced slat.
+ ///
return fkSlat;
}
TVector2 Dimensions() const;
private:
+ /// Not implemented
AliMpSlatSegmentation(const AliMpSlatSegmentation& right);
+ /// Not implemented
AliMpSlatSegmentation& operator = (const AliMpSlatSegmentation& right);
const AliMpSlat* fkSlat; ///< Slat
TObject(),
fMotifMap(motifMap)
{
- //
- // Default ctor.
- //
+ ///
+ /// Default ctor.
+ ///
}
//_____________________________________________________________________________
AliMpSt345Reader::~AliMpSt345Reader()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
}
//_____________________________________________________________________________
fDX(0),
fDY(0)
{
- // default ctor
+ /// default ctor
AliDebugStream(1) << "this = " << this << endl;
fDX(0),
fDY(0)
{
- // normal ctor
+ /// normal ctor
AliDebugStream(1) << "this = " << this << endl;
//_____________________________________________________________________________
AliMpTrigger::~AliMpTrigger()
{
- // dtor
+ /// dtor
AliDebugStream(1) << "this = " << this << endl;
fSlatSegmentations.Delete();
Bool_t
AliMpTrigger::AdoptLayer(AliMpSlat* slat)
{
- // Adopt (i.e. we become owner of that pointer) a slat, as
- // a layer of this trigger slat.
+ /// Adopt (i.e. we become owner of that pointer) a slat, as
+ /// a layer of this trigger slat.
AliDebug(2,Form("%s is adopting %s ",
GetID(),slat->GetID()));
TVector2
AliMpTrigger::Dimensions() const
{
- // Returns the dimensions (half-sizes) of that slat (cm)
+ /// Returns the dimensions (half-sizes) of that slat (cm)
return TVector2(DX(),DY());
}
Double_t
AliMpTrigger::DX() const
{
- // Returns the half-size in X (cm)
+ /// Returns the half-size in X (cm)
return fDX;
}
Double_t
AliMpTrigger::DY() const
{
- // Returns the half-size in Y (cm)
+ /// Returns the half-size in Y (cm)
return fDY;
}
void
AliMpTrigger::GetAllLocalBoardNumbers(TArrayI& lbn) const
{
- // Fills lbn with the local board numbers we're dealing with
+ /// Fills lbn with the local board numbers we're dealing with
Int_t n(0);
for ( Int_t i = 0; i < GetSize(); ++i )
{
const char*
AliMpTrigger::GetID() const
{
- // returns the id of this slat
+ /// returns the id of this slat
return fId.Data();
}
const char*
AliMpTrigger::GetName() const
{
- // returns the name (=id+bending/non-bending) of this slat
+ /// returns the name (=id+bending/non-bending) of this slat
TString name(GetID());
if ( fPlaneType == AliMp::kBendingPlane )
{
AliMpSlat*
AliMpTrigger::GetLayer(int layer) const
{
- // Returns a given layer
+ /// Returns a given layer
if ( IsLayerValid(layer) )
{
return (AliMpSlat*)fSlats.At(layer);
AliMpVSegmentation*
AliMpTrigger::GetLayerSegmentation(int layer) const
{
- // Returns a given layer
+ /// Returns a given layer
if ( IsLayerValid(layer) )
{
return (AliMpSlatSegmentation*)fSlatSegmentations.At(layer);
Int_t
AliMpTrigger::GetNofPadsX() const
{
- // Returns the number of pad in x direction
+ /// Returns the number of pad in x direction
if ( !GetSize() ) return -1;
if ( GetLayer(0) )
{
Int_t
AliMpTrigger::GetMaxNofPadsY() const
{
- // Maximum number of pads in y direction
+ /// Maximum number of pads in y direction
return fMaxNofPadsY;
}
Int_t
AliMpTrigger::GetSize() const
{
- // Number of layers
+ /// Number of layers
return fSlats.GetEntriesFast();
}
Bool_t
AliMpTrigger::IsLayerValid(int layer) const
{
- // Whether a given layer index is valid or not
+ /// Whether a given layer index is valid or not
if ( layer >= 0 && layer < GetSize() )
{
return kTRUE;
AliMp::PlaneType
AliMpTrigger::PlaneType() const
{
- // Bending or not
+ /// Bending or not
return fPlaneType;
}
TVector2
AliMpTrigger::Position() const
{
- // Slat position (cm)
+ /// Slat position (cm)
return TVector2(DX(),DY());
}
void
AliMpTrigger::Print(Option_t* opt) const
{
- // Dump on screen
+ /// Dump on screen
cout << "AliMpTrigger::" << GetID();
if ( GetSize() == 0 )
{
fMotifMap(motifMap),
fLocalBoardMap()
{
- //
- // Default ctor.
- //
+ ///
+ /// Default ctor.
+ ///
fLocalBoardMap.SetOwner(kTRUE);
}
//_____________________________________________________________________________
AliMpTriggerReader::~AliMpTriggerReader()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
fLocalBoardMap.DeleteAll();
}
TString
AliMpTriggerReader::GetBoardNameFromPCBLine(const TString& s)
{
- // Decode the string to get the board name
+ /// Decode the string to get the board name
TString boardName;
TObjArray* tokens = s.Tokenize(' ');
int LocalBoardNumber(const char* localBoardName);
- AliMpPCB* PCB(const char* pcbType);
+ // AliMpPCB* PCB(const char* pcbType);
void ReadLines(const char* slatType,
AliMp::PlaneType planeType,
fIsOwner(false),
fNofStrips(0)
{
- //
- // Default ctor. Not to be used really.
- //
+ ///
+ /// Default ctor. Not to be used really.
+ ///
AliDebug(1,Form("this=%p Empty ctor",this));
}
fIsOwner(own),
fNofStrips(0)
{
- //
- // Normal ctor.
- //
+ ///
+ /// Normal ctor.
+ ///
AliDebug(1,Form("this=%p Normal ctor slat=%p",this,slat));
// Compute the number of strips.
//_____________________________________________________________________________
AliMpTriggerSegmentation::~AliMpTriggerSegmentation()
{
- //
- // Dtor (empty).
- //
+ ///
+ /// Dtor (empty).
+ ///
if ( fIsOwner ) delete fkSlat;
AliMpVPadIterator*
AliMpTriggerSegmentation::CreateIterator(const AliMpArea&) const
{
- //
- // Returns an iterator to loop over the pad contained within given area.
- // Not implemented for trigger.
+ ///
+ /// Returns an iterator to loop over the pad contained within given area.
+ /// Not implemented for trigger.
AliError("Not implemented for trigger");
return 0;
}
AliMpVPadIterator*
AliMpTriggerSegmentation::CreateIterator() const
{
- //
- // Returns an iterator to loop over all the pads
- // Not implemented for trigger.
+ ///
+ /// Returns an iterator to loop over all the pads
+ /// Not implemented for trigger.
AliError("Not implemented for trigger");
return 0;
TVector2
AliMpTriggerSegmentation::Dimensions() const
{
+/// Return dimensions
+
return Slat()->Dimensions();
}
void
AliMpTriggerSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
{
+/// Fill the array ecn with all manuIds
+
Slat()->GetAllLocalBoardNumbers(ecn);
}
const char*
AliMpTriggerSegmentation::GetName() const
{
- // Name of that segmentation = TriggerSegmentation + slatName
+ /// Name of that segmentation = TriggerSegmentation + slatName
TString name("TriggerSegmentation");
if ( fkSlat)
{
Bool_t
AliMpTriggerSegmentation::HasPad(const AliMpIntPair& indices) const
{
- //
- // Test if this slat has a pad located at the position referenced
- // by the integer indices.
- //
+ ///
+ /// Test if this slat has a pad located at the position referenced
+ /// by the integer indices.
+ ///
return PadByIndices(indices,kFALSE) != AliMpPad::Invalid();
}
Int_t
AliMpTriggerSegmentation::MaxPadIndexX() const
{
- //
- // Returns the value of the largest pad index in x-direction.
- //
+ ///
+ /// Returns the value of the largest pad index in x-direction.
+ ///
return fkSlat->GetNofPadsX()-1;
}
Int_t
AliMpTriggerSegmentation::MaxPadIndexY() const
{
- //
- // Returns the value of the largest pad index in y-direction.
- //
+ ///
+ /// Returns the value of the largest pad index in y-direction.
+ ///
return fkSlat->GetMaxNofPadsY()-1;
}
AliMpTriggerSegmentation::PadByLocation(const AliMpIntPair& location,
Bool_t warning) const
{
- //
- // Returns the pad specified by its location, where location is the
- // pair (ManuID,ManuChannel).
- // If warning=kTRUE and the pad does not exist, a warning message is
- // printed.
- //
- // AliMpPad::Invalid() is returned if there's no pad at the given location.
- //
+ ///
+ /// Returns the pad specified by its location, where location is the
+ /// pair (ManuID,ManuChannel).
+ /// If warning=kTRUE and the pad does not exist, a warning message is
+ /// printed.
+ ///
+ /// AliMpPad::Invalid() is returned if there's no pad at the given location.
+ ///
AliMpPad pad;
AliMpIntPair invloc;
AliMpTriggerSegmentation::PadByIndices(const AliMpIntPair& indices,
Bool_t warning) const
{
- //
- // Returns the pad specified by its integer indices.
- // If warning=kTRUE and the pad does not exist, a warning message is
- // printed.
- //
- // AliMpPad::Invalid() is returned if there's no pad at the given location.
- //
- //
+ ///
+ /// Returns the pad specified by its integer indices.
+ /// If warning=kTRUE and the pad does not exist, a warning message is
+ /// printed.
+ ///
+ /// AliMpPad::Invalid() is returned if there's no pad at the given location.
+ ///
+ ///
AliMpPad pad;
AliMpIntPair invloc;
AliMpTriggerSegmentation::PadByPosition(const TVector2& position,
Bool_t warning) const
{
- //
- // Returns the pad specified by its (floating point) position.
- // If warning=kTRUE and the pad does not exist, a warning message is
- // printed.
- //
- // AliMpPad::Invalid() is returned if there's no pad at the given location.
- //
+ ///
+ /// Returns the pad specified by its (floating point) position.
+ /// If warning=kTRUE and the pad does not exist, a warning message is
+ /// printed.
+ ///
+ /// AliMpPad::Invalid() is returned if there's no pad at the given location.
+ ///
AliMpPad pad;
AliMpIntPair invloc;
AliMp::PlaneType
AliMpTriggerSegmentation::PlaneType() const
{
+ /// Return plane type
+
return Slat()->PlaneType();
}
const AliMpTrigger*
AliMpTriggerSegmentation::Slat() const
{
- //
- // Returns the pointer to the referenced slat.
- //
+ ///
+ /// Returns the pointer to the referenced slat.
+ ///
return fkSlat;
}
TVector2 Dimensions() const;
private:
+ /// Not implemented
AliMpTriggerSegmentation(const AliMpTriggerSegmentation& right);
+ /// Not implemented
AliMpTriggerSegmentation& operator = (const AliMpTriggerSegmentation& right);
const AliMpTrigger* fkSlat; ///< Slat
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff