ClassImp(AliMUONChamberTrigger)
+///
+/// \class AliMUONChamberTrigger
+///
+/// Implementation of AliMUONChamber for the trigger
+///
+/// This class is to be deprecated.
+///
+
//-------------------------------------------
AliMUONChamberTrigger::AliMUONChamberTrigger()
/// \class AliMUONChamberTrigger
/// \brief Muon trigger chamber class
-#include <TRef.h>
-
#include "AliMUONChamber.h"
-
class AliMUONClusterFinder;
class AliMUONSegmentationTrigger;
class AliMUONResponseTrigger;
Int_t GetNPads(Int_t cath) const { return fnPads[cath]; }
Int_t GetIJ(Int_t indx, Int_t iPad) const { return fPadIJ[indx][iPad]; }
Float_t GetXyq(Int_t indx, Int_t iPad) const { return fXyq[indx][iPad]; }
- Float_t GetZpad() { return fZpad; }
+ Float_t GetZpad() const { return fZpad; }
Bool_t GetUsed(Int_t cath, Int_t dig) const { return fUsed[cath][dig]; }
void SetUsed(Int_t cath, Int_t dig) { fUsed[cath][dig] = kTRUE; } // mark used digits
void SetUnused(Int_t cath, Int_t dig) { fUsed[cath][dig] = kFALSE; } // unmark digits
delete fDigitsCath1;
}
-//______________________________________________________________________________
-void
-AliMUONClusterReconstructor::CheckSize(TClonesArray& a)
-{
-/// Check if one can adds a new element, or if a is already full.
-/// If full, it is resized.
-
- if ( a.GetLast()+1 >= a.GetSize() )
- {
- AliInfo(Form("Increasing array size from %d to %d",
- a.GetSize(),a.GetSize()*2));
- a.Expand(a.GetSize()*2);
- }
-}
-
//______________________________________________________________________________
void
AliMUONClusterReconstructor::ClusterizeOneDE(Int_t detElemId)
// Add the digit to the array with the right cathode number.
if (digit->Cathode() == 0)
{
- CheckSize(*fDigitsCath0);
new((*fDigitsCath0)[fDigitsCath0->GetLast()+1]) AliMUONDigit(*digit);
}
else
{
- CheckSize(*fDigitsCath1);
new((*fDigitsCath1)[fDigitsCath1->GetLast()+1]) AliMUONDigit(*digit);
}
} // end of loop on chamber digits
void ClusterizeOneDE(Int_t detElemId);
- void CheckSize(TClonesArray&);
-
private:
AliMUONData* fMUONData; //! Data container for MUON subsystem
#include "AliRawDataHeader.h"
ClassImp(AliMUONDDLTracker)
+
+///
+/// \class AliMUONDDLTracker
+///
+/// A wrapper object for 1 DDL of the MUON tracking chambers.
+///
+/// \author C. Finck
+
const Int_t AliMUONDDLTracker::fgkBlkHeaderLength = 8;
const Int_t AliMUONDDLTracker::fgkDspHeaderLength = 8;
const Int_t AliMUONDDLTracker::fgkEndOfDDL = 0x0FFFFFFFF;
Int_t* GetBlkHeader() {return &fTotalBlkLength;}
Int_t* GetDspHeader() {return &fTotalDspLength;}
- AliRawDataHeader GetHeader(){return fHeader;}
- Int_t GetHeaderSize() {return sizeof(AliRawDataHeader)/4;} // in words
+ AliRawDataHeader GetHeader() const {return fHeader;}
+ Int_t GetHeaderSize() const {return sizeof(AliRawDataHeader)/4;} // in words
Int_t GetEoD() const {return fgkEndOfDDL;}
#include "AliMUONDDLTrigger.h"
ClassImp(AliMUONDDLTrigger)
-
- const Int_t AliMUONDDLTrigger::fgkHeaderLength = 6;
+
+///
+/// \class AliMUONDDLTrigger
+///
+/// One DDL for trigger part of the MUON spectrometer.
+///
+/// \author C. Finck
+///
+
+const Int_t AliMUONDDLTrigger::fgkHeaderLength = 6;
//___________________________________________
AliMUONDDLTrigger::AliMUONDDLTrigger()
Int_t* GetGlobalInput() {return &fGlobalInput[0];}
- AliRawDataHeader GetHeader(){return fHeader;}
- Int_t GetHeaderSize() {return sizeof(AliRawDataHeader)/4;} // in words
+ AliRawDataHeader GetHeader() const {return fHeader;}
+ Int_t GetHeaderSize() const {return sizeof(AliRawDataHeader)/4;} // in words
private:
#include "AliMUONDataDigitIterator.h"
#include "AliMUONData.h"
-#include "AliMUONDigit.h"
#include "TClonesArray.h"
+///
+/// \class AliMUONDataDigitIterator
///
/// An iterator to access digits (stored into AliMUONData).
///
/// Iteration can occur on tracking chambers only, trigger chambers only,
/// or both.
///
+/// \author L. Aphecetche
+///
//_____________________________________________________________________________
AliMUONDataDigitIterator::AliMUONDataDigitIterator(const AliMUONData* data,
void
AliMUONDataDigitIterator::CopyTo(AliMUONDataDigitIterator& destination) const
{
+ // Copy *this to destination
destination.fData=fData;
destination.fFirstChamber=fFirstChamber;
destination.fLastChamber=fLastChamber;
void
AliMUONDataDigitIterator::Reset()
{
+ // Resets the iterator
fData->GetDigits();
fCurrentDigit = 0;
fCurrentChamber = fFirstChamber;
ClassImp(AliMUONDataInterface)
+///
+/// \class AliMUONDataInterface
+///
+/// An easy to use interface to the MUON module data stored in
+/// TreeK, TreeH, TreeS, TreeD and TreeR
+/// One can fetch any of the data objects with all the calls to runloader,
+/// muon loader and AliMUONData done behind the scenes and automatically.
+///
+/// This interface in not necessarily the fastest way to fetch the data but
+/// it is the easiest.
+/// Note: If independant calls to the run loader, muon loader or
+/// AliMUONData objects are interspersed with calls to the
+/// AliMUONDataInterface to fetch data, one might need to call the Reset
+/// method between these method calls at some point to prevent
+/// AliMUONDataInterface from getting confused.
+/// This is necessary since this object assumes the state of runloader,
+/// muon loader nor AliMUONData has not changed between calls.
+/// If the state has changes then one must call Reset so that
+/// AliMUONDataInterface refreshes what it knows about the state
+/// of the loader and AliMUONData objects.
+///
+/// \deprecated We have to revisit all this AliMUONData stuff anyway,
+/// and probably make a real AliMUONLoader instead...
+///
AliMUONDataInterface::AliMUONDataInterface()
: TObject(), fData(NULL, "MUON", "MUON")
Bool_t AliMUONDataInterface::FetchMuonLoader(TString filename, TString foldername)
{
+ // fetches the muon loader for the given filename/foldername
+
fMuonloader = fRunloader->GetLoader("MUONLoader");
if (fMuonloader == NULL)
{
class AliMUONDigit;
class AliMUONTrack;
-// An easy to use interface to the MUON module data stored in TreeK, TreeH, TreeS, TreeD and TreeR
-// One can fetch any of the data objects with all the calls to runloader, muon loader and AliMUONData
-// done behind the scenes and automatically.
-// This interface in not necessarily the fastest way to fetch the data but it is the easiest.
-// Note: If independant calls to the run loader, muon loader or AliMUONData objects are interspersed
-// with calls to the AliMUONDataInterface to fetch data, one might need to call the Reset method
-// between these method calls at some point to prevent AliMUONDataInterface from getting confused.
-// This is necessary since this object assumes the state of runloader, muon loader nor AliMUONData
-// has not changed between calls. If the state has changes then one must call Reset so that
-// AliMUONDataInterface refreshes what it knows about the state of the loader and AliMUONData objects.
-//
+/// An easy to use interface to the MUON module data stored.
+/// \deprecated
+
class AliMUONDataInterface : public TObject
{
public:
AliMUONDataIterator();
AliMUONDataIterator(AliMUONData* data, const char* onWhatToIterate,
EIterationStyle howToIterate);
-
virtual ~AliMUONDataIterator();
TObject* Next();
void Reset();
private:
- AliMUONVDataIterator* fIterator;
+ AliMUONVDataIterator* fIterator; //! the real worker
+
+private:
+ AliMUONDataIterator(const AliMUONDataIterator& rhs);
+ AliMUONDataIterator& operator=(const AliMUONDataIterator& rhs);
ClassDef(AliMUONDataIterator,0) //
};
#include "AliMUONSegmentation.h"
#include "AliMUONDigit.h"
#include "AliMUONHitMapA1.h"
-#include "AliMUONData.h"
#include "AliMUONRawCluster.h"
#include "AliMUONHitForRec.h"
#include "AliMUONClusterInput.h"
#include "AliLog.h"
ClassImp(AliMUONDetElement) // Class implementation in ROOT context
- FILE *lun = 0x0; //fopen("hitmap.dat","w");
//_________________________________________________________________________
AliMUONDetElement::AliMUONDetElement()
if (!fRecModel->GetUsed(cath1,j)) continue;
if (fHitMap[cath1]->TestHit(dig->PadX(), dig->PadY()) == kUsed) continue;
fHitMap[cath1]->FlagHit(dig->PadX(), dig->PadY());
- if (lun) fprintf(lun," %d %d %d %d \n", cath1, fidDE, dig->PadX(), dig->PadY());
+ AliDebug(10,Form(" %d %d %d %d \n", cath1, fidDE, dig->PadX(), dig->PadY()));
fLeft[cath1]--;
}
}
return (index <0) ? 0 : fDigits->UncheckedAt(GetHitIndex(ix,iy));
}
//_________________________________________________
-FlagType AliMUONDigitMapA1::TestHit(Int_t ix, Int_t iy)
+FlagType AliMUONDigitMapA1::TestHit(Int_t ix, Int_t iy) const
{
/// Check if hit cell is empty, used or unused
// Flag a hit as used
virtual void FlagHit(Int_t ix, Int_t iy);
// Test hit status
- virtual FlagType TestHit(Int_t ix, Int_t iy);
+ virtual FlagType TestHit(Int_t ix, Int_t iy) const;
protected:
AliMUONDigitMapA1(const AliMUONDigitMapA1 & hitMap);
//_____________________________________________________________________________
AliMUONDigit*
AliMUONDigitizerV3::FindCorrespondingDigit(AliMUONDigit& digit,
- AliMUONData* data)
+ AliMUONData* data) const
{
AliMUONDataIterator it(data,"D",AliMUONDataIterator::kTriggerChambers);
AliMUONDigit* cd;
void ApplyResponseToTriggerDigit(AliMUONDigit& digit, AliMUONData* data);
private:
- AliMUONDigit* FindCorrespondingDigit(AliMUONDigit& digit,AliMUONData* data);
+ AliMUONDigit* FindCorrespondingDigit(AliMUONDigit& digit,AliMUONData* data) const;
Int_t FindDigitIndex(TClonesArray& array, const AliMUONDigit& digit) const;
}
// -------------------------------------------
-Float_t AliMUONMathieson::IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation)
+Float_t AliMUONMathieson::IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation) const
{
/// Calculate charge on current pad according to Mathieson distribution
/// using Detection elt
// Mathieson Ky4
void SetKy4(Float_t p1) {fKy4 = p1;};
/// \deprecated To be removed when old (s)digitizers go off.
- Float_t IntXY(Int_t id, AliMUONGeometrySegmentation* segmentation);
+ Float_t IntXY(Int_t id, AliMUONGeometrySegmentation* segmentation) const;
/// Charge integration on region (x1,y1,x2,y2).
Float_t IntXY(Float_t xi1, Float_t yi1, Float_t xi2, Float_t yi2) const;
}
//-------------------------------------------------------------------
-void AliMUONRecoTrack::TrackInfo()
+void AliMUONRecoTrack::TrackInfo() const
{
// Prints momentum info for this track
cout << "Px=" << GetMomReconstr(0) << " Py=" << GetMomReconstr(1) <<
void SetFlag(Int_t flag) {fFlag = flag;};
Double_t Theta() const;
- void TrackInfo();
+ void TrackInfo() const;
private:
Int_t fSign; // charge sign
#include "AliESD.h"
#include "AliESDMuonTrack.h"
-#include "AliGenEventHeader.h"
-#include "AliHeader.h"
#include "AliLog.h"
#include "AliMUON.h"
#include "AliMUONCalibrationData.h"
#include "AliRun.h"
#include "AliRunLoader.h"
#include "TTask.h"
-#include <TArrayF.h>
-#include <TParticle.h>
#include "TStopwatch.h"
ClassImp(AliMUONReconstructor)
//
// Chamber response methods
// Pulse height from scored quantity (eloss)
- virtual Float_t IntPH(Float_t) {return 1.;}
+ virtual Float_t IntPH(Float_t) const {return 1.;}
// Charge disintegration
- virtual Float_t IntXY(Int_t, AliMUONGeometrySegmentation*) {return 1.;}
+ virtual Float_t IntXY(Int_t, AliMUONGeometrySegmentation*) const {return 1.;}
// Noise, zero-suppression, adc saturation
//virtual Int_t DigitResponse(Int_t ) {return kTRUE;}
virtual Int_t DigitResponse(Int_t ,
- AliMUONTransientDigit* ) {return kTRUE;}
+ AliMUONTransientDigit* ) const {return kTRUE;}
/// Go from one hit to several digits, applying charge spreading.
virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
namespace
{
- Float_t TOFLIMIT = 75E-9;
-
AliMUON* muon()
{
return static_cast<AliMUON*>(gAlice->GetModule("MUON"));
}
}
+const Float_t
+AliMUONResponseTrigger::fgkTofLimit = 75E-9;
+
//------------------------------------------------------------------
AliMUONResponseTrigger::AliMUONResponseTrigger()
: AliMUONResponse()
//------------------------------------------------------------------
Int_t AliMUONResponseTrigger::DigitResponse(Int_t digit,
- AliMUONTransientDigit* /*where*/){
+ AliMUONTransientDigit* /*where*/) const
+{
// only digital (0/1) information available
if (digit)
Float_t tof = hit.Age();
Int_t twentyNano(100);
- if (tof<TOFLIMIT)
+ if (tof<fgkTofLimit)
{
twentyNano=1;
}
AliMUONResponseTrigger();
virtual ~AliMUONResponseTrigger(){}
- virtual Int_t DigitResponse(Int_t digit, AliMUONTransientDigit* where);
+ virtual Int_t DigitResponse(Int_t digit, AliMUONTransientDigit* where) const;
// Set the GenerCluster parameter
virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
+ private:
+ static const Float_t fgkTofLimit; // particle above this threshold are discarded
ClassDef(AliMUONResponseTrigger,1) // Implementation of RPC response
};
}
//------------------------------------------------------------------
-Float_t AliMUONResponseTriggerV1::IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation){
+Float_t AliMUONResponseTriggerV1::IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation) const
+{
// Returns 1 or 0 if the current strip is fired or not
// get the "parameters" needed to evaluate the strip response
// x1 : hit x(y) position
}
//------------------------------------------------------------------
-Float_t AliMUONResponseTriggerV1::FireStripProb(Float_t x4, Float_t theta){
+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 Alice/note xxx)
// WARNING : need to convert x4 from cm to mm
AliMUONResponseTriggerV1(Float_t hv);
virtual ~AliMUONResponseTriggerV1(){}
// Charge disintegration
- virtual Float_t IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation);
+ virtual Float_t IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation) const;
// Set the GenerCluster parameter
virtual Int_t SetGenerCluster();
// initialize parameters
void SetParameters(Float_t hv);
// parametrization of the cluster-size
- Float_t FireStripProb(Float_t x4, Float_t theta);
+ Float_t FireStripProb(Float_t x4, Float_t theta) const;
ClassDef(AliMUONResponseTriggerV1,1) // Implementation of RPC response
fMathieson->SetSqrtKy3AndDeriveKy2Ky4(SqrtKy3);
}
//__________________________________________________________________________
-Float_t AliMUONResponseV0::IntPH(Float_t eloss)
+Float_t AliMUONResponseV0::IntPH(Float_t eloss) const
{
// Calculate charge from given ionization energy loss
Int_t nel;
}
//-------------------------------------------
-Float_t AliMUONResponseV0::IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation)
+Float_t AliMUONResponseV0::IntXY(Int_t idDE,
+ AliMUONGeometrySegmentation* segmentation)
+const
{
// Calculate charge on current pad according to Mathieson distribution
//-------------------------------------------
-Int_t AliMUONResponseV0::DigitResponse(Int_t digit, AliMUONTransientDigit* /*where*/)
+Int_t AliMUONResponseV0::DigitResponse(Int_t digit,
+ AliMUONTransientDigit* /*where*/)
+const
{
// \deprecated method
// Now part of the digitizer (where it belongs really), e.g. DigitizerV3
//
// Chamber response methods
// Pulse height from scored quantity (eloss)
- virtual Float_t IntPH(Float_t eloss);
+ virtual Float_t IntPH(Float_t eloss) const;
// Charge disintegration
- virtual Float_t IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation);
+ virtual Float_t IntXY(Int_t idDE,
+ AliMUONGeometrySegmentation* segmentation) const;
// Noise, zero-suppression, adc saturation
- virtual Int_t DigitResponse(Int_t digit, AliMUONTransientDigit* where);
+ virtual Int_t DigitResponse(Int_t digit,
+ AliMUONTransientDigit* where) const;
virtual Float_t GetAnod(Float_t x) const;
#include "AliMUONTriggerDecision.h"
#include "AliMUONTrigger.h"
+///
+/// \class AliMUONTrigger
+///
+/// Implementation of AliTriggerDetector for MUON detector
+///
+/// So far, the inputs are taken from AliMUONTriggerDecision object
+///
+
//----------------------------------------------------------------------
ClassImp(AliMUONTrigger)
//----------------------------------------------------------------------
void AliMUONTrigger::Trigger()
{
-
+ // sets the trigger inputs
AliRunLoader* runLoader = gAlice->GetRunLoader();
#include "AliMUONVCalibParam.h"
-#include "Riostream.h"
+///
+/// \class AliMUONVCalibParam
+///
+/// Defines an interface for a calibration container object.
+///
+/// \author Laurent Aphecetche
ClassImp(AliMUONVCalibParam)
+//_____________________________________________________________________________
+ AliMUONVCalibParam::AliMUONVCalibParam() : TObject()
+{
+ // ctor
+}
+
//_____________________________________________________________________________
AliMUONVCalibParam::~AliMUONVCalibParam()
{
class AliMUONVCalibParam : public TObject
{
public:
+ AliMUONVCalibParam();
virtual ~AliMUONVCalibParam();
/// j indices in following methods are valid from 0 to Dimension()-1.
ClassImp(AliMUONVDataIterator)
+///
+/// \class AliMUONVDataIterator
+///
+/// Defines an interface of an iterator over muon data structure(s).
+///
+/// \author L. Aphecetche
+
+//_____________________________________________________________________________
+AliMUONVDataIterator::AliMUONVDataIterator() : TObject()
+{
+}
+
//_____________________________________________________________________________
AliMUONVDataIterator::~AliMUONVDataIterator()
{
class AliMUONVDataIterator : public TObject
{
public:
+ AliMUONVDataIterator();
virtual ~AliMUONVDataIterator();
virtual TObject* Next() = 0;
#include "AliLog.h"
-#include <TArrayI.h>
-#include <Riostream.h>
+#include "TArrayI.h"
+#include "Riostream.h"
ClassImp(AliMpBusPatch)
}
//____________________________________________________________________
-void AliMpBusPatch::GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP)
+void AliMpBusPatch::GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP)
+const
{
/// calculates the number of DSP & buspatch per block
// methods
void ReadBusPatchFile();
- void GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP);
+ void GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP) const;
Int_t GetDEfromBus(Int_t busPatchId);
TArrayI* GetBusfromDE(Int_t idDE);
#include "AliMpHelper.h"
-#include "AliLog.h"
#include "TArrayI.h"
-#include "TClass.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TString.h"
+///
+/// \class AliMpHelper
+///
+/// Helper class used to parse mapping files for St345 slats.
+///
+/// \author L. Aphecetche
+
ClassImp(AliMpHelper)
//_____________________________________________________________________________
#include "TMath.h"
#include <sstream>
+///
+/// \class AliMpPCB
+///
+/// A PCB for station 3,4 or 5
+///
+/// A PCB is a group of pads having the same size
+/// Pads are grouped in motifs, where 1 motif = 1 MANU
+///
+/// The notion of PCB enveloppe is due to the fact that not all PCBs are
+/// "full" of pads, e.g. the rounded or short ones miss some pads,
+/// but the enveloppe is a virtual size that should be constant
+/// across the slats, and is 400x400 mm.
+/// It's a usefull notion to compute e.g. slat center in a uniform way,
+/// considering that a slat is N PCBs, of the same "virtual" size, that of
+/// the enveloppe.
+///
+/// \author L. Aphecetche
+
ClassImp(AliMpPCB)
//_____________________________________________________________________________
void
AliMpPCB::Copy(TObject& o) const
{
+ // Copy *this into o
+
TObject::Copy(o);
AliMpPCB& pcb = static_cast<AliMpPCB&>(o);
pcb.fId = fId;
AliMpPCB();
/** Ctor. The sizes are given in mm.
- enveloppe is due to the fact that not all PCBs are "full" of pads,
- e.g. the rounded or short ones miss some pads, but the enveloppe
- is a virtual size that should be constant across the slats,
- and is 400x400 mm.
- It's a usefull notion to compute e.g. slat center in a uniform way,
- considering that a slat is N PCBs, of the same "virtual" size, that of
- the enveloppe.
+ See full doc for the meaning of enveloppe parameters.
*/
AliMpPCB(const char* id, Double_t padSizeX, Double_t padSizeY,
Double_t enveloppeSizeX, Double_t enveloppeSizeY);
Int_t NofPads() const { return fNofPads; }
private:
- TString fId;
- Double_t fPadSizeX;
- Double_t fPadSizeY;
- Double_t fEnveloppeSizeX;
- Double_t fEnveloppeSizeY;
- Double_t fXoffset;
- Double_t fActiveXmin;
- Double_t fActiveXmax;
- Int_t fIxmin;
- Int_t fIxmax;
- Int_t fIymin;
- Int_t fIymax;
+ TString fId; // PCB name
+ 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 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)
+ Int_t fIxmin; // min pad index in x
+ Int_t fIxmax; // max pad index in x
+ Int_t fIymin; // min pad index in y
+ Int_t fIymax; // max pad index in y
#ifdef WITH_ROOT
- TObjArray fMotifs;
+ TObjArray fMotifs; // array of motifs
#else
- std::vector<AliMpMotifPosition*> fMotifs;
+ std::vector<AliMpMotifPosition*> fMotifs; // array of motifs
#endif
- Int_t fNofPads;
+ Int_t fNofPads; // number of pads in this PCB
ClassDef(AliMpPCB,2) // A PCB for Stations 3,4,5
};
// $Id$
// $MpId: AliMpPCBPainter.cxx,v 1.4 2005/09/19 18:56:46 ivana Exp $
-// Category: graphics
-//
-// Class AliMpSlatPainter
-// -----------------------
-// Class for drawing a PCB into canvas
-// Authors: Laurent Aphecetche
+
+///
+/// \class AliMpSlatPainter
+///
+/// Class for drawing a PCB into canvas
+///
+/// \author L. Aphecetche
#include "AliMpPCBPainter.h"
/// \class AliMpPCBPainter
/// \brief Class for drawing a PCB into canvas
///
-/// Authors: Laurent Aphecetche
+/// \author Laurent Aphecetche
#ifndef ALIMPPCBPAINTER_H
#define ALIMPPCBPAINTER_H
AliMpPCBPainter& operator = (const AliMpPCBPainter& right);
private:
- AliMpPCB* fPCB;
+ AliMpPCB* fPCB; //! PCB to be plotted.
ClassDef(AliMpPCBPainter,1) // A painter for a PCB of stations 3,4,5
};
mutable AliMpExMap fManuMap; // map of int to AliMpMotifPosition*
#ifdef WITH_ROOT
TObjArray fPCBs; // array of AliMpPCB*
- //mutable AliMpExMap fManuMap; // map of int to AliMpMotifPosition*
#else
std::vector<AliMpPCB*> fPCBs; // array of AliMpPCB*
- //std::map<int,AliMpMotifPosition*> fManuMap;
#endif
TVector2 fPosition; // Position of the slat center.
- Int_t fNofPads;
+ Int_t fNofPads; // number of pads in this slat
ClassDef(AliMpSlat,2) // A slat for stations 3,4,5
};
#include <limits>
#include <cassert>
-ClassImp(AliMpSlatPadIterator)
+///
+/// \class AliMpSlatPadIterator
+///
+/// Implementation of AliMpVPadIterator for slats.
+///
+/// This class first split the input area (upon which to iterate)
+/// into a set of areas of constant pad size.
+/// Then each of those areas is iterated over, using
+/// AliMpSlatZonePadIterator objects.
+///
+/// \author L. Aphecetche
+///
+ClassImp(AliMpSlatPadIterator)
-namespace
-{
- Double_t DMAX(std::numeric_limits<Double_t>::max());
-}
+//const Double_t
+//AliMpSlatPadIterator::fgkDmax = std::numeric_limits<Double_t>::max();
//_____________________________________________________________________________
AliMpSlatPadIterator::AliMpSlatPadIterator()
AliMpArea Intersect(const AliMpArea& a, const AliMpArea& b) const;
private:
- const AliMpSlat* fkSlat;
- std::vector<AliMpVPadIterator*> fDelegates;
- AliMpVPadIterator* fCurrentDelegate;
- UInt_t fCurrentDelegateIndex;
+ const AliMpSlat* fkSlat; // pointer to the slat being iterated over
+ std::vector<AliMpVPadIterator*> fDelegates; // iterators we do use
+ AliMpVPadIterator* fCurrentDelegate; // current iterator
+ UInt_t fCurrentDelegateIndex; // current iterator index
ClassDef(AliMpSlatPadIterator,1) // Pad iterator for St 345 Slats
};
// $Id$
// $MpId: AliMpSlatPainter.cxx,v 1.6 2005/09/19 18:56:46 ivana Exp $
-// Category: graphics
-//
-// Class AliMpSlatPainter
-// -----------------------
-// Class for drawing a slat into canvas
-// Authors: Laurent Aphecetche
+
+///
+/// \class AliMpSlatPainter
+///
+/// Class for drawing a slat into canvas
+///
+/// \author Laurent Aphecetche
#include "AliMpSlatPainter.h"
private:
- const AliMpSlat* fkSlat;
+ const AliMpSlat* fkSlat; //! pointer to the slat to be drawn
ClassDef(AliMpSlatPainter,1) // A painter for a slat of stations 3,4,5
};
#include "AliMpMotif.h"
#include "AliMpMotifPosition.h"
#include "AliMpMotifType.h"
-#include "AliMpPCB.h"
#include "AliMpSlat.h"
#include "AliMpSlatPadIterator.h"
const char*
AliMpSlatSegmentation::GetName() const
{
+ // The name of this segmentation is "SlatSegmentation"+slatName
+
TString name("SlatSegmentation");
if ( fkSlat)
{
virtual AliMpPad PadByPosition(const TVector2& position,
Bool_t warning) const;
- virtual void Print(Option_t*) const;
+ virtual void Print(Option_t* opt) const;
const AliMpSlat* Slat() const;
#include "Riostream.h"
#include <algorithm>
#include <limits>
-#include <cassert>
ClassImp(AliMpSlatZonePadIterator)
-// This iterator only works within a region of constant density.
+///
+/// \class AliMpSlatZonePadIterator
+///
+/// Iterates over slat pads within a region of constant pad size.
+///
+/// \author Laurent Aphecetche
-namespace
-{
- const Double_t epsilon = 1E-4; // cm
- Double_t DMAX(std::numeric_limits<Double_t>::max());
-}
+const Double_t AliMpSlatZonePadIterator::fgkEpsilon = 1E-4; // cm
+const Double_t AliMpSlatZonePadIterator::fgkDmax = std::numeric_limits<Double_t>::max();
//_____________________________________________________________________________
AliMpSlatZonePadIterator::AliMpSlatZonePadIterator(const AliMpSlat* slat,
// Left and right x-limits have to come from first and last pcbs
// to deal with short and rounded pcbs cases.
AliMpPCB* first = fkSlat->FindPCB(fArea.LeftBorder(),fArea.DownBorder());
- AliMpPCB* last = fkSlat->FindPCB(fArea.RightBorder()-epsilon,
+ AliMpPCB* last = fkSlat->FindPCB(fArea.RightBorder()-fgkEpsilon,
fArea.DownBorder());
AliDebug(3,Form("First PCB %s Ixmin %2d Last PCB %s Ixmax %2d",
last->GetID(),last->Ixmax()));
Double_t xleft = first->ActiveXmin();
- Double_t xright = last->ActiveXmax() - epsilon;
+ Double_t xright = last->ActiveXmax() - fgkEpsilon;
AliDebug(3,Form("xleft,xright=%e,%e",xleft,xright));
Double_t xmin = std::max(fArea.LeftBorder(),xleft);
Double_t xmax = std::min(fArea.RightBorder(),xright);
Double_t ymin = std::max(fArea.DownBorder(),0.0);
- Double_t ymax = std::min(fArea.UpBorder(),fkSlat->DY()*2.0-epsilon);
+ Double_t ymax = std::min(fArea.UpBorder(),fkSlat->DY()*2.0-fgkEpsilon);
AliDebug(3,Form("Cropped area (%e,%e)->(%e,%e)",
xmin,ymin,xmax,ymax));
// Invalidate the iterator.
//
- fOffset = TVector2(DMAX,DMAX);
+ fOffset = TVector2(fgkDmax,fgkDmax);
fCurrentPad = AliMpPad::Invalid();
fIsDone = kTRUE;
}
+#ifndef ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
+#define ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
+
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
/// \ingroup slat
/// \class AliMpSlatZonePadIterator
-/// \brief To be added ...
-///
-/// Author: Laurent Aphecetche
-
-#ifndef ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
-#define ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
+/// \brief Iterates over slat pads within a region of constant pad size.
+/// \author Laurent Aphecetche
#include "AliMpVPadIterator.h"
#include "AliMpArea.h"
void SetPad(AliMpPad& pad, const TVector2& pos);
private:
- const AliMpSlat* fkSlat;
- AliMpSlatSegmentation* fSlatSegmentation;
- AliMpArea fArea;
- TVector2 fOffset;
- TVector2 fStep;
- AliMpPad fCurrentPad;
- Bool_t fIsDone;
+ const AliMpSlat* fkSlat; //! the slat we're iterating over
+ AliMpSlatSegmentation* fSlatSegmentation; //! segmentation pointer
+ AliMpArea fArea; //! area we're iterating over
+ TVector2 fOffset; //! current position (relative to bottom-left of area)
+ TVector2 fStep; //! step sizes
+ AliMpPad fCurrentPad; //! current pad
+ Bool_t fIsDone; //! whether we've finished or not
+
+ static const Double_t fgkDmax; // maximum double
+ static const Double_t fgkEpsilon; // comparison precision
ClassDef(AliMpSlatZonePadIterator,1) // Pad iterator for a zone of constant density, for St345.
};
#include <sstream>
#include <assert.h>
-TMap AliMpSt345Reader::fgPCBMap;
+///
+/// \class AliMpSt345Reader
+//
+/// Read slat and pcb ASCII files.
+///
+/// Basically this class provides 2 static methods :
+/// - AliMpSlat* ReadSlat()
+/// - AliMpPCB ReadPCB()
+///
+/// \author Laurent Aphecetche
ClassImp(AliMpSt345Reader)
+TMap AliMpSt345Reader::fgPCBMap;
+
//_____________________________________________________________________________
AliMpSt345Reader::AliMpSt345Reader() : TObject()
{
/// \class AliMpSt345Reader
/// \brief Read slat and pcb ASCII files
///
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
#ifndef ALI_MP_ST345_READER_H
#define ALI_MP_ST345_READER_H
#include "TArrayI.h"
#include "TObjArray.h"
+///
+/// \class AliMpTrigger
+///
+/// A trigger 'slat' object.
+/// It is to be viewed as a superposition of
+/// virtual layers of AliMpSlat objects. The need for more than one layer
+/// arise from the fact that a given local board deals with strips
+/// located in different detelem. So a given strip (pad) can have several
+/// "locations".
+///
+/// \author Laurent Aphecetche
+
ClassImp(AliMpTrigger)
namespace
: TObject(), fId(""), fPlaneType(kNonBendingPlane),
fMaxNofPadsY(0), fDX(0), fDY(0)
{
+ // default ctor
}
//_____________________________________________________________________________
: TObject(), fId(slatType), fPlaneType(bendingOrNot),
fMaxNofPadsY(0), fDX(0), fDY(0)
{
+ // normal ctor
}
//_____________________________________________________________________________
AliMpTrigger::~AliMpTrigger()
{
+ // dtor
AliDebug(1,Form("this=%p before fSlats.Delete()",this));
fSlats.Delete();
AliDebug(1,Form("this=%p after fSlats.Delete()",this));
Bool_t
AliMpTrigger::AdoptLayer(AliMpSlat* slat)
{
+ // Adopt (i.e. we become owner of that pointer) a slat, as
+ // a layer of this trigger slat.
+
AliDebug(1,Form("%s is adopting %s :\n",
GetID(),slat->GetID()));
TVector2
AliMpTrigger::Dimensions() const
{
+ // 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)
return fDX;
}
Double_t
AliMpTrigger::DY() const
{
+ // 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
Int_t n(0);
for ( Int_t i = 0; i < GetSize(); ++i )
{
const char*
AliMpTrigger::GetID() const
{
+ // returns the id of this slat
return fId.Data();
}
const char*
AliMpTrigger::GetName() const
{
+ // returns the name (=id+bending/non-bending) of this slat
TString name(GetID());
if ( fPlaneType == kBendingPlane )
{
AliMpSlat*
AliMpTrigger::GetLayer(int layer) const
{
+ // Returns a given layer
if ( IsLayerValid(layer) )
{
return (AliMpSlat*)fSlats.At(layer);
Int_t
AliMpTrigger::GetNofPadsX() const
{
+ // 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
return fMaxNofPadsY;
}
Int_t
AliMpTrigger::GetSize() const
{
+ // Number of layers
return fSlats.GetEntriesFast();
}
Bool_t
AliMpTrigger::IsLayerValid(int layer) const
{
+ // Whether a given layer index is valid or not
if ( layer >= 0 && layer < GetSize() )
{
return kTRUE;
AliMpPlaneType
AliMpTrigger::PlaneType() const
{
+ // Bending or not
return fPlaneType;
}
TVector2
AliMpTrigger::Position() const
{
+ // Slat position (cm)
return TVector2(DX(),DY());
}
void
AliMpTrigger::Print(Option_t* opt) const
{
+ // Dump on screen
cout << "AliMpTrigger::" << GetID();
if ( GetSize() == 0 )
{
/// \ingroup trigger
/// \class AliMpTrigger
/// \brief A trigger slat
-///
-/// A trigger 'slat' object. It is to be viewed as a superposition of
-/// virtual layers of AliMpSlat objects. The need for more than one layer
-/// arise from the fact that a given local board deals with strips
-/// located in different detelem. So a given strip (pad) can have several
-/// "locations".
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
#ifndef ALI_MP_TRIGGER_H
#define ALI_MP_TRIGGER_H
Bool_t IsLayerValid(int layer) const;
- TString fId;
- AliMpPlaneType fPlaneType;
- TObjArray fSlats;
- Int_t fMaxNofPadsY;
- Double_t fDX;
- Double_t fDY;
+ TString fId; //! name of that slat
+ AliMpPlaneType fPlaneType; //! bending or non-bending
+ TObjArray fSlats; //! virtual slat composing this trigger slat
+ Int_t fMaxNofPadsY; //! max number of pads in y direction
+ Double_t fDX; //! half-size in x (cm)
+ Double_t fDY; //! half-size in y (cm)
ClassDef(AliMpTrigger,1) // Slat for trigger
};
#include <sstream>
#include <cassert>
+///
+/// \class AliMpTriggerReader
+/// Read trigger slat ASCII files
+/// Basically provides 2 static methods:
+/// - AliMpTrigger* ReadSlat()
+/// - AliMpPCB* ReadPCB()
+///
+/// \author Laurent Aphecetche
+
TMap AliMpTriggerReader::fgPCBMap;
TMap AliMpTriggerReader::fgLocalBoardMap;
-namespace
-{
- const TString KEYWORD_LAYER("LAYER");
- const TString KEYWORD_SCALE("SCALE");
- const TString KEYWORD_PCB("PCB");
- const TString KEYWORD_FLIPX("FLIP_X");
- const TString KEYWORD_FLIPY("FLIP_Y");
-}
+const TString AliMpTriggerReader::fgkKeywordLayer("LAYER");
+const TString AliMpTriggerReader::fgkKeywordScale("SCALE");
+const TString AliMpTriggerReader::fgkKeywordPcb("PCB");
+const TString AliMpTriggerReader::fgkKeywordFlipX("FLIP_X");
+const TString AliMpTriggerReader::fgkKeywordFlipY("FLIP_Y");
ClassImp(AliMpTriggerReader)
const TList& lines,
Double_t scale)
{
+ // Construct a slat from the list of lines, taking into account
+ // the scale factor
+
AliMpSlat* slat = new AliMpSlat(slatName, planeType);
TIter it(&lines);
TString& keyword = ((TObjString*)tokens->At(0))->String();
- if ( keyword == KEYWORD_PCB )
+ if ( keyword == fgkKeywordPcb )
{
if ( tokens->GetEntriesFast() != 3 )
{
TString
AliMpTriggerReader::GetBoardNameFromPCBLine(const TString& s)
{
+ // Decode the string to get the board name
TString boardName;
TObjArray* tokens = s.Tokenize(' ');
TString& keyword = ((TObjString*)tokens->At(0))->String();
- if ( keyword == KEYWORD_PCB &&
+ if ( keyword == fgkKeywordPcb &&
tokens->GetEntriesFast() == 3 )
{
boardName = ((TObjString*)tokens->At(2))->String();
// from top to bottom
//
-// cout << "--- Original lines (flipX=" << flipX << " flipY=" << flipY
-// << " srcLine=" << srcLine << " destLine=" << destLine << " : " << endl;
-// lines.Print();
-//
+
if ( flipX )
{
- // Simply swaps R(ight) and L(eft) in the first character of local board names
+ // Simply swaps R(ight) and L(eft) in the first character of
+ // local board names
TObjString* oline;
TIter it(&lines);
}
}
-// cout << "*** After flipX :" << endl;
-// lines.Print();
-
if ( flipY )
{
// Change line number, according to parameters srcLine and destLine
TString& s = oline->String();
- if ( !s.Contains(KEYWORD_PCB) )
+ if ( !s.Contains(fgkKeywordPcb) )
{
// Only consider PCB lines.
continue;
}
}
}
-// cout << "*** After flipY :" << endl;
-// lines.Print();
}
//___________________________________________________________________________
Int_t
AliMpTriggerReader::IsLayerLine(const TString& sline)
{
- if ( sline.BeginsWith(KEYWORD_LAYER) )
+ // Whether sline contains LAYER keyword
+
+ if ( sline.BeginsWith(fgkKeywordLayer) )
{
return 1;
}
TString& slatType2,
Bool_t& flipX, Bool_t& flipY)
{
+ // Decode a line containing FLIP_X and/or FLIP_Y keywords
+
Ssiz_t blankPos = sline.First(' ');
if ( blankPos < 0 ) return 0;
TString keyword(sline(0,blankPos));
- if ( keyword == KEYWORD_FLIPX )
+ if ( keyword == fgkKeywordFlipX )
{
flipX = kTRUE;
- } else if ( keyword == KEYWORD_FLIPY )
+ } else if ( keyword == fgkKeywordFlipY )
{
flipY = kTRUE;
}
AliMpTriggerReader::DecodeScaleLine(const TString& sline,
Double_t& scale, TString& slatType)
{
- if ( sline(0,KEYWORD_SCALE.Length()) == KEYWORD_SCALE )
+ // Decode sline containing SCALE keyword
+
+ if ( sline(0,fgkKeywordScale.Length()) == fgkKeywordScale )
{
- TString tmp(sline(KEYWORD_SCALE.Length()+1,
- sline.Length()-KEYWORD_SCALE.Length()-1));
+ TString tmp(sline(fgkKeywordScale.Length()+1,
+ sline.Length()-fgkKeywordScale.Length()-1));
Ssiz_t blankPos = tmp.First(' ');
if ( blankPos < 0 )
{
int
AliMpTriggerReader::LocalBoardNumber(const char* localBoardName)
{
+ // From local board name to local board number
+
if ( !fgLocalBoardMap.GetSize() )
{
ReadLocalBoardMapping();
Bool_t& flipX, Bool_t& flipY,
Int_t& srcLine, Int_t& destLine)
{
+ //
+ // Reads in lines from file for a given slat
+ // Returns the list of lines (lines), together with some global
+ // information as the scale, whether to flip the lines, etc...
+ //
AliDebugClass(1,Form("SlatType %s Scale %e FlipX %d FlipY %d srcLine %d"
" destLine %d\n",slatType,scale,flipX,flipY,
srcLine,destLine));
if ( sline.Length() == 0 || sline[0] == '#' ) continue;
Bool_t isKeywordThere =
- sline.Contains(KEYWORD_PCB) ||
- sline.Contains(KEYWORD_LAYER) ||
- sline.Contains(KEYWORD_SCALE) ||
- sline.Contains(KEYWORD_FLIPY) || sline.Contains(KEYWORD_FLIPX);
+ sline.Contains(fgkKeywordPcb) ||
+ sline.Contains(fgkKeywordLayer) ||
+ sline.Contains(fgkKeywordScale) ||
+ sline.Contains(fgkKeywordFlipX) ||
+ sline.Contains(fgkKeywordFlipY);
if ( !isKeywordThere )
{
if ( isScaleLine < 0 )
{
- AliFatalClass(Form("Syntax error near %s keyword\n",KEYWORD_SCALE.Data()));
+ AliFatalClass(Form("Syntax error near %s keyword\n",fgkKeywordScale.Data()));
}
else if ( isScaleLine > 0 && slatType2 != slatType )
{
void
AliMpTriggerReader::ReadLocalBoardMapping()
{
+ // Reads the file that contains the mapping local board name <-> number
+
TString filename(AliMpFiles::LocalTriggerBoardMapping());
AliDebugClass(1,Form("Reading from %s\n",filename.Data()));
if ( !IsLayerLine(firstLine) )
{
std::ostringstream s;
- s << KEYWORD_LAYER;
+ s << fgkKeywordLayer;
lines.AddFirst(new TObjString(s.str().c_str()));
}
void
AliMpTriggerReader::Reset()
{
+ // Resets the PCB internal map
fgPCBMap.Delete();
}
/// \ingroup trigger
/// \class AliMpTriggerReader
/// \brief Read trigger slat ASCII files
-///
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
#ifndef ALI_MP_TRIGGER_READER_H
#define ALI_MP_TRIGGER_READER_H
static void Reset();
-//private:
+private:
static AliMpSlat* BuildSlat(const char* slatName,
AliMpPlaneType planeType,
static void FlipLines(TList& lines, Bool_t flipX, Bool_t flipY,
Int_t srcLine, Int_t destLine);
- static TString GetBoardNameFromPCBLine(const TString&);
+ static TString GetBoardNameFromPCBLine(const TString& sline);
static Int_t GetLine(const TString& slatType);
static TMap fgPCBMap; //! map of TObjString to AliMpPCB*
static TMap fgLocalBoardMap; //! map of TObjString to TObjString
+
+ static const TString fgkKeywordLayer; //! Keyword: LAYER
+ static const TString fgkKeywordScale; //! Keyword: SCALE
+ static const TString fgkKeywordPcb; //! Keyword : PCB
+ static const TString fgkKeywordFlipX; //! Keyword : FLIPX
+ static const TString fgkKeywordFlipY; //! Keyword : FLIPY
ClassDef(AliMpTriggerReader,1) // Reader for trigger slats mapping files
};
#include "AliMpSlatSegmentation.h"
#include "AliMpTrigger.h"
+///
+/// \class AliMpTriggerSegmentation
+///
+/// Implementation of AliMpVSegmentation for trigger slats.
+///
+/// \todo Implement CreateIterator method, if needed.
+///
+/// \author Laurent Aphecetche
+
ClassImp(AliMpTriggerSegmentation)
//_____________________________________________________________________________
const char*
AliMpTriggerSegmentation::GetName() const
{
+ // Name of that segmentation = TriggerSegmentation + slatName
TString name("TriggerSegmentation");
if ( fkSlat)
{
{
const AliMpSlat* slat = fkSlat->GetLayer(i);
AliMpSlatSegmentation seg(slat);
- AliMpPad p_i = seg.PadByLocation(location,kFALSE);
- if ( p_i.IsValid() )
+ AliMpPad pi = seg.PadByLocation(location,kFALSE);
+ if ( pi.IsValid() )
{
if ( !pad.IsValid() )
{
- pad = AliMpPad(invloc,p_i.GetIndices(),p_i.Position(),p_i.Dimensions());
- pad.AddLocation(p_i.GetLocation());
+ pad = AliMpPad(invloc,pi.GetIndices(),pi.Position(),pi.Dimensions());
+ pad.AddLocation(pi.GetLocation());
}
else
{
- pad.AddLocation(p_i.GetLocation());
+ pad.AddLocation(pi.GetLocation());
}
}
}
{
const AliMpSlat* slat = fkSlat->GetLayer(i);
AliMpSlatSegmentation seg(slat);
- AliMpPad p_i = seg.PadByIndices(indices,kFALSE);
- if ( p_i.IsValid() )
+ AliMpPad pi = seg.PadByIndices(indices,kFALSE);
+ if ( pi.IsValid() )
{
if ( !pad.IsValid() )
{
- pad = AliMpPad(invloc,p_i.GetIndices(),p_i.Position(),p_i.Dimensions());
- pad.AddLocation(p_i.GetLocation());
+ pad = AliMpPad(invloc,pi.GetIndices(),pi.Position(),pi.Dimensions());
+ pad.AddLocation(pi.GetLocation());
}
else
{
- pad.AddLocation(p_i.GetLocation());
+ pad.AddLocation(pi.GetLocation());
}
}
}
{
const AliMpSlat* slat = fkSlat->GetLayer(i);
AliMpSlatSegmentation seg(slat);
- AliMpPad p_i = seg.PadByPosition(position,kFALSE);
- if ( p_i.IsValid() )
+ AliMpPad pi = seg.PadByPosition(position,kFALSE);
+ if ( pi.IsValid() )
{
if ( !pad.IsValid() )
{
- pad = AliMpPad(invloc,p_i.GetIndices(),p_i.Position(),p_i.Dimensions());
- pad.AddLocation(p_i.GetLocation());
+ pad = AliMpPad(invloc,pi.GetIndices(),pi.Position(),pi.Dimensions());
+ pad.AddLocation(pi.GetLocation());
}
else
{
- pad.AddLocation(p_i.GetLocation());
+ pad.AddLocation(pi.GetLocation());
}
}
}
/// \ingroup trigger
/// \class AliMpTriggerSegmentation
/// \brief Implementation of AliMpVSegmentation for trigger slats.
-///
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
#ifndef ALI_MP_TRIGGER_SEGMENTATION_H
#define ALI_MP_TRIGGER_SEGMENTATION_H
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff