// inline functions
+ /// Return position
inline TVector2 AliMpArea::Position() const { return fPosition; }
+ /// Return dimensions
inline TVector2 AliMpArea::Dimensions() const { return fDimensions; }
+ /// Return validity
inline Bool_t AliMpArea::IsValid() const { return fValidity; }
#endif //ALI_MP_AREA_H
//_____________________________________________________________________________
AliMpConnection::~AliMpConnection()
{
-//
+/// Destructor
AliDebug(1,Form("this=%p"));
}
// methods
+ //
// accessors
+ //
+ /// Return Berg connector number
Int_t GetBergNum() const {return fBergNum;}
+ /// Return kapton connector number
Int_t GetKaptonNum() const {return fKaptonNum;}
+ /// Return Gassiplex channel number
Int_t GetGassiNum() const {return fGassiNum;}
+ /// Return pad number
Int_t GetPadNum() const {return fPadNum;}
+ /// 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 the motif type which contains this connection
void SetOwner(AliMpMotifType *owner) {fOwner=owner;}
private:
+ /// Not implemented
AliMpConnection(const AliMpConnection& right);
+ /// Not implemented
AliMpConnection& operator=(const AliMpConnection& right);
// data members
// inline functions
+ /// Return the pad number converted to a name
inline TString AliMpConnection::PadName() const
{ return fOwner->PadName(fPadNum); }
+ /// Return the local indices of this pad in the motif
inline AliMpIntPair AliMpConnection::LocalIndices() const
{ return fOwner->FindLocalIndicesByConnection(this);}
Int_t
AliMpConstants::ManuMask(AliMp::PlaneType planeType)
{
- //
- // The manuIDs get an offset if they are in the non-bending plane
- //
+/// The manuIDs get an offset if they are in the non-bending plane
+
return ( planeType == AliMp::kNonBendingPlane ) ? fgkNonBendingManuMask : 0;
}
static Int_t ManuMask(AliMp::PlaneType planeType);
private:
- // unused derived functions
+ /// unused derived functions
virtual Bool_t IsEqual(const TObject*) const { return true; }
// static data members
// inline functions
+ /// Return the length precision for tests
inline Double_t AliMpConstants::LengthTolerance() { return fgkLengthTolerance;}
+ /// Return the step in length used to move from a geometric border
inline Double_t AliMpConstants::LengthStep() { return fgkLengthStep;}
+ /// Return global pad indices start value
inline Int_t AliMpConstants::StartPadIndex() { return fgkStartPadIndex;}
+ /// Return number of chambers
inline Int_t AliMpConstants::NofChambers() { return fgkNofChambers;}
+ /// Return number of geometry modules
inline Int_t AliMpConstants::NofGeomModules() { return fgkNofGeomModules;}
#endif //ALI_MP_CONSTANTS_H
static Int_t GetNofDEInChamber(Int_t chamberId, Bool_t warn = true);
private:
+ /// Not implemented
AliMpDEManager();
+ /// Not implemented
AliMpDEManager(const AliMpDEManager& rhs);
+ /// Not implemented
AliMpDEManager& operator=(const AliMpDEManager& rhs);
// static data members
static void SetTopPath(const TString& topPath);
private:
+ /// Not implemented
AliMpFiles();
+ /// Not implemented
AliMpFiles(const AliMpFiles& right);
-
- // operators
+ /// Not implemented
AliMpFiles& operator=(const AliMpFiles& right);
+
// methods
static TString GetTop();
static TString PlaneDataDir(AliMp::StationType station, AliMp::PlaneType plane);
TVector2 &padPosition,
TVector2 &padDimensions) const
{
- // Transform the real area (position,dimensions) to
- // its equivalent pad area
+ /// Transform the real area (position,dimensions) to
+ /// its equivalent pad area
padPosition = RealToPad(position);
padDimensions =
{
public:
#ifdef WITH_STL
+ /// GraphContextVector type
typedef std::vector<AliMpGraphContext*> GraphContextVector;
#endif
#ifdef WITH_ROOT
+ /// GraphContextVector type
typedef TObjArray GraphContextVector;
#endif
void Pop();
static AliMpGraphContext *Instance();
+ //
// set methods
-
+ //
+ /// Set position of the pad area where to draw
void SetPadPosition(const TVector2 &position){fPadPosition=position;}
+ /// Set dimensions of the pad area where to draw
void SetPadDimensions(const TVector2 &dimensions){fPadDimensions=dimensions;}
+ /// Set position of the real area where to draw
void SetRealPosition(const TVector2 &position){fRealPosition=position;}
+ /// Set dimensions of the real area where to draw
void SetRealDimensions(const TVector2 &dimensions){fRealDimensions=dimensions;}
+ /// Set color to use
void SetColor(Int_t color){fColor=color;}
+ //
// get methods
+ //
+
+ /// Return position of the pad area where to draw
TVector2 GetPadPosition() const {return fPadPosition;}
+ /// Return dimensions of the pad area where to draw
TVector2 GetPadDimensions() const {return fPadDimensions;}
+ /// Return position of the real area where to draw
TVector2 GetRealPosition() const{return fRealPosition;}
+ /// Return dimensions of the real area where to draw
TVector2 GetRealDimensions() const{return fRealDimensions;}
+ /// Return color to use
Int_t GetColor() const {return fColor;}
//methods
//_____________________________________________________________________________
AliMpHelper::AliMpHelper() : TObject()
{
- //
- // Default (empty) ctor.
- //
+ ///
+ /// Default (empty) ctor.
+ ///
}
//_____________________________________________________________________________
AliMpHelper::~AliMpHelper()
{
- //
- // Dtor.
- //
+ ///
+ /// Dtor.
+ ///
}
//_____________________________________________________________________________
void AliMpHelper::DecodeName(const char* name, char sep, TArrayI& theList)
{
- //
- // From a string of the form "i-j;k;l;m-n" returns an integer array
- // containing all the integers from i to j, then k, l and then from m to
- // n.
- //
+ ///
+ /// From a string of the form "i-j;k;l;m-n" returns an integer array
+ /// containing all the integers from i to j, then k, l and then from m to
+ /// n.
+ ///
theList.Set(0);
TString str(name);
AliMpHelper::GetRange(const char* cstr, Int_t& begin, Int_t& end,
Int_t& incr, Int_t& n)
{
- //
- // From a string of the form "m-n" returns a range (begin,end),
- // its ordering (incr=+-1) and its size (abs(begin-end)+1)
- //
+ ///
+ /// From a string of the form "m-n" returns a range (begin,end),
+ /// its ordering (incr=+-1) and its size (abs(begin-end)+1)
+ ///
TString str(cstr);
incr = 1;
//_____________________________________________________________________________
TString AliMpHelper::Normalize(const char* line)
{
- //
- // Remove multiple blanks, and blanks in the begining/end.
- //
+ ///
+ /// Remove multiple blanks, and blanks in the begining/end.
+ ///
TString rv(line);
if ( rv.Length() <= 0 ) return TString();
void operator += (const AliMpIntPair& op);
void operator -= (const AliMpIntPair& op);
+ //
// static get methods
+ //
+ /// Return invalid pair
static AliMpIntPair Invalid() {return AliMpIntPair();}
+ //
// get methods
+ //
+ /// Return first value
Int_t GetFirst() const {return fFirst;}
+ /// Return second value
Int_t GetSecond() const {return fSecond;}
+ /// Return validity
Bool_t IsValid() const {return fValidity;}
+ //
// set methods
+ //
+ /// Set first value
void SetFirst(Int_t ix) {fFirst=ix; fValidity=true; }
+ /// Set second value
void SetSecond(Int_t iy) {fSecond=iy; fValidity=true;}
void Set(Int_t ix, Int_t iy) { fFirst=ix; fSecond=iy; fValidity=true; }
// inline functions
+ /// Return 1 as the number of pad dimensions
inline Int_t AliMpMotif::GetNofPadDimensions() const
{ return 1; }
+ /// Return the pad dimensions
inline TVector2 AliMpMotif::GetPadDimensions(Int_t /*i*/) const
{ return fPadDimensions; }
{
public:
#ifdef WITH_STL
+ /// Motif map type
typedef std::map<TString, AliMpVMotif*> MotifMap;
+ /// Motif map iterator type
typedef MotifMap::const_iterator MotifMapIterator;
+ /// Motif type map type
typedef std::map<TString, AliMpMotifType*> MotifTypeMap;
+ /// Motif type map iterator type
typedef MotifTypeMap::const_iterator MotifTypeMapIterator;
+ /// Motif position map to int type
typedef std::map<Int_t, AliMpMotifPosition*> MotiPositionMap;
+ /// Motif position map to int iterator type
typedef MotiPositionMap::const_iterator MotifPositionMapIterator;
+ /// Motif position map to int pair type
typedef std::map<AliMpIntPair, AliMpMotifPosition*> MotifPositionMap2;
+ /// Motif position map to int pair iterator type
typedef MotifPositionMap2::const_iterator MotifPositionMap2Iterator;
#endif
#ifdef WITH_ROOT
+ /// Motif map type
typedef AliMpExMap MotifMap;
+ /// Motif type map type
typedef AliMpExMap MotifTypeMap;
+ /// Motif position map to int type
typedef AliMpExMap MotifPositionMap;
+ /// Motif position map to int pair iterator type
typedef AliMpExMap MotifPositionMap2;
#endif
virtual TVector2 GetDimensions() const;
private:
+ /// Not implemented
AliMpMotifPainter(const AliMpMotifPainter& right);
+ /// Not implemented
AliMpMotifPainter& operator = (const AliMpMotifPainter& right);
void PaintContour(Option_t* option, Bool_t fill);
void Print(Option_t* option="") const;
private:
+ /// Not implemented
AliMpMotifPosition(const AliMpMotifPosition& right);
+ /// Not implemented
AliMpMotifPosition& operator = (const AliMpMotifPosition& right);
// methods
// inline functions
+/// Return motif position ID = manu id
inline Int_t AliMpMotifPosition::GetID() const
{ return fID; }
+/// Return motif
inline AliMpVMotif* AliMpMotifPosition::GetMotif() const
{ return fMotif; }
+/// Return position
inline TVector2 AliMpMotifPosition::Position() const
{ return fPosition; }
+/// Return dimensions
inline TVector2 AliMpMotifPosition::Dimensions() const
{ return fMotif->Dimensions(); }
{
public:
#ifdef WITH_STL
+ /// Map of int pair to string
typedef std::map<std::string, std::pair<Int_t,Int_t> > PadMapType;
+ /// Map of int pair to string iterator
typedef PadMapType::iterator PadMapTypeIterator;
#endif
#ifdef WITH_ROOT
+ /// Map of int pair to string
typedef TExMap PadMapType;
#endif
TString MotifSpecialName(const TString& motifID, Double_t scale);
private:
+ /// Not implemented
AliMpMotifReader(const AliMpMotifReader& right);
+ /// Not implemented
AliMpMotifReader& operator = (const AliMpMotifReader& right);
// data members
{
public:
#ifdef WITH_STL
+ /// Dimensions map type
typedef std::vector< TVector2 > DimensionsMap;
+ /// Dimensions map iterator type
typedef std::vector< TVector2 > DimensionsMap2;
#endif
#ifdef WITH_ROOT
+ /// Dimensions map type
typedef AliMpExMap DimensionsMap;
+ /// Dimensions map iterator type
typedef TObjArray DimensionsMap2;
#endif
fID(id),
fNofPadsX(0),
fNofPadsY(0),
- fVerboseLevel(0),
#ifdef WITH_STL
fConnections()
#endif
fConnections(true)
#endif
{
- /// Standard constructor
+ /// Standard constructor \n
+ /// Please note that id should be of the form %s for station 1,2,
+ // %s-%e-%e for station345 and %sx%e for stationTrigger
+
AliDebug(1,Form("this=%p id=%s",this,id.Data()));
}
fID(""),
fNofPadsX(0),
fNofPadsY(0),
- fVerboseLevel(0),
fConnections()
{
/// Default constructor
fID(""),
fNofPadsX(0),
fNofPadsY(0),
- fVerboseLevel(0),
fConnections()
{
/// Copy constructor
mt.fID = fID;
mt.fNofPadsX = fNofPadsX;
mt.fNofPadsY = fNofPadsY;
- mt.fVerboseLevel = fVerboseLevel;
mt.fConnections = fConnections;
}
{
public:
#ifdef WITH_STL
+ /// Connection map type
typedef std::map< AliMpIntPair, AliMpConnection* > ConnectionMap;
+ /// Connection map iterator type
typedef ConnectionMap::const_iterator ConnectionMapCIterator;
#endif
#ifdef WITH_ROOT
+ /// Connection map type
typedef AliMpExMap ConnectionMap;
#endif
public:
- /** Please note that id should be of the form %s for station 1,2,
- %s-%e-%e for station345 and %sx%e for stationTrigger
- */
AliMpMotifType(const TString &id);
AliMpMotifType(const AliMpMotifType& rhs);
AliMpMotifType& operator=(const AliMpMotifType& rhs);
// set methods
void SetNofPads(Int_t nofPadsX, Int_t nofPadY);
- void SetVerboseLevel(Int_t level){fVerboseLevel=level;}
// get methods
+ /// Return unique motif ID
TString GetID() const {return fID;}
+ /// Return number of pads in x direction
Int_t GetNofPadsX() const {return fNofPadsX;}
+ /// Return number of pads in y direction
Int_t GetNofPadsY() const {return fNofPadsY;}
Int_t GetNofPads() const;
TString fID; ///< unique motif ID
Int_t fNofPadsX; ///< number of pads in x direction
Int_t fNofPadsY; ///< number of pads in y direction
- Int_t fVerboseLevel; ///< verbose level
ConnectionMap fConnections; ///< Map (ix,iy) of connections
ClassDef(AliMpMotifType,1) // Motif type
// inline functions
+/// Return true if the motif conatins all pads
inline Bool_t AliMpMotifType::IsFull() const
{ return GetNofPads() == fNofPadsX*fNofPadsY; }
{
public:
#ifdef WITH_STL
+ /// Pad vector type
typedef std::vector<AliMpPad> PadVector;
+ /// Pad set type
typedef std::set<AliMpPad> PadSet;
+ /// Pad set iterator type
typedef PadSet::const_iterator PadSetCIterator;
#endif
#ifdef WITH_ROOT
+ /// Pad vector type
typedef TObjArray PadVector;
+ /// Pad set type
typedef TObjArray PadSet;
#endif
private:
// static members
- static const UInt_t fgkInvalidIndex; // invalid index number
+ static const UInt_t fgkInvalidIndex; ///< invalid index number
// private methods
Bool_t IsNeighbour(const AliMpPad& pad) const;
{
public:
#ifdef WITH_STL
+ /// Int pair vector type
typedef std::vector<AliMpIntPair> IntPairVector;
#endif
#ifdef WITH_ROOT
+ /// Int pair vector type
typedef TClonesArray IntPairVector;
#endif
AliMpPad(const AliMpPad& src);
virtual ~AliMpPad();
+ //
// operators
+ //
Bool_t operator == (const AliMpPad& pos2) const;
Bool_t operator != (const AliMpPad& pos2) const;
AliMpPad& operator = (const AliMpPad& src) ;
+ //
// methods
+ //
void PrintOn(ostream& out) const;
virtual void Print(const char* /*option*/ = "") const;
+ //
// static get methods
+ //
+ /// Return invalid pad
static AliMpPad Invalid() {return AliMpPad();}
+ //
// set methods
+ //
Bool_t AddLocation(const AliMpIntPair& location, Bool_t warn = true);
+ //
// get methods
+ //
+ /// Return pad location
AliMpIntPair GetLocation() const {return fLocation;}
+ /// Return pad indices
AliMpIntPair GetIndices() const {return fIndices;}
+ /// Return the pad position (in cm)
TVector2 Position() const {return fPosition ;}
+ /// Return the pad dimensions (in cm)
TVector2 Dimensions() const {return fDimensions;}
+ /// Return validity
Bool_t IsValid() const {return fValidity ;}
Int_t GetNofLocations() const;
{
public:
AliMpPadIteratorPtr(AliMpVPadIterator* it);
- // AliMpPadIteratorPtr(const AliMpPadIteratorPtr& right); --> private
virtual ~AliMpPadIteratorPtr();
+ /// Operator ->
AliMpVPadIterator* operator->() { return fIterator; }
+ /// Operator *
AliMpVPadIterator& operator*() { return *fIterator; }
private:
+ /// Not implemented
AliMpPadIteratorPtr(const AliMpPadIteratorPtr& right);
-
- // operators
+ /// Not implemented
AliMpPadIteratorPtr& operator=(const AliMpPadIteratorPtr& right);
// copy and assignment are disallowed to avoid
// multiple deletion of fIterator
// inline functions
+ /// Return the first pad
inline AliMpPad AliMpPadPair::GetFirst() const { return fPadFirst; }
+ /// Return the second pad
inline AliMpPad AliMpPadPair::GetSecond() const { return fPadSecond; }
{
public:
#ifdef WITH_STL
+ /// Pad row segment vector type
typedef std::vector<AliMpVPadRowSegment*> PadRowSegmentVector;
#endif
#ifdef WITH_ROOT
+ /// Pad row segment vector type
typedef TObjArray PadRowSegmentVector;
#endif
{
public:
#ifdef WITH_STL
+ /// Row segment vector type
typedef std::vector<AliMpVRowSegment*> RowSegmentVector;
#endif
#ifdef WITH_ROOT
+ /// Row segment vector type
typedef TList RowSegmentVector;
#endif
AliMpMotifMap* GetMotifMap() const;
private:
+ /// Not implemented
AliMpRow(const AliMpRow& right);
+ /// Not implemented
AliMpRow& operator = (const AliMpRow& right);
// methods
// inline functions
+/// Return row ID
inline UInt_t AliMpRow::GetID() const { return fID; }
+
+/// Return the motif map associated with its sector
inline AliMpMotifMap* AliMpRow::GetMotifMap() const { return fMotifMap; }
#endif //ALI_MP_ROW_H
virtual TVector2 GetDimensions() const;
private:
+ /// Not implemented
AliMpRowPainter(const AliMpRowPainter& right);
+ /// Not implemented
AliMpRowPainter& operator = (const AliMpRowPainter& right);
- AliMpRow *fRow; ///< the row to paint
+ AliMpRow *fRow; ///< the row to paint
ClassDef(AliMpRowPainter,1) // Row painter
};
virtual Int_t GetMotifPositionId(Int_t i) const;
private:
+ /// Not implemented
AliMpRowSegment(const AliMpRowSegment& right);
+ /// Not implemented
AliMpRowSegment& operator = (const AliMpRowSegment& right);
// methods
virtual TVector2 GetDimensions() const;
private:
+ /// Not implemented
AliMpRowSegmentPainter(const AliMpRowSegmentPainter& right);
+ /// Not implemented
AliMpRowSegmentPainter& operator = (const AliMpRowSegmentPainter& right);
AliMpVRowSegment *fRowSegment; ///< the row segment to draw
virtual ~AliMpRowSegmentRSpecial();
// methods
- virtual void UpdatePadsOffset() {}
+ /// Nothing to be done for outer segments
+ virtual void UpdatePadsOffset() {}
virtual Double_t LeftBorderX() const;
virtual Double_t RightBorderX() const;
{
public:
#ifdef WITH_STL
+ /// Row vector type
typedef std::vector<AliMpRow*> RowVector;
+ /// Zone vector type
typedef std::vector<AliMpZone*> ZoneVector;
#endif
#ifdef WITH_ROOT
+ /// Row vector type
typedef TObjArray RowVector;
+ /// Zone vector type
typedef TObjArray ZoneVector;
#endif
private:
+ /// Not implemented
AliMpSector(const AliMpSector& right);
+ /// Not implemented
AliMpSector& operator = (const AliMpSector& right);
// methods
TVector2 fOffset; ///< sector position
ZoneVector fZones; ///< zones
RowVector fRows; ///< rows
- AliMpMotifMap* fMotifMap; ///< motif map
- AliMp::Direction fDirection;///< the direction of constant pad size
+ AliMpMotifMap* fMotifMap; ///< motif map
+ AliMp::Direction fDirection; ///< the direction of constant pad size
TVector2 fMinPadDimensions; ///< minimum pad dimensions
TVector2 fMaxPadDimensions; ///< miximum pad dimensions
AliMpIntPair fMaxPadIndices; ///< maximum pad indices
Int_t fNofPads; ///< total number of pads
-
ClassDef(AliMpSector,1) // Sector
};
// inline functions
+/// Return the direction of constant pad size
inline AliMp::Direction AliMpSector::GetDirection() const
{ return fDirection; }
+/// Return minimum pad dimensions
inline TVector2 AliMpSector::GetMinPadDimensions() const
{ return fMinPadDimensions; }
+/// Return maxmum pad dimensions
inline TVector2 AliMpSector::GetMaxPadDimensions() const
{ return fMaxPadDimensions; }
+/// Return maximum pad indices
inline AliMpIntPair AliMpSector::GetMaxPadIndices() const
{ return fMaxPadIndices; }
+/// Return total number of pads
inline Int_t AliMpSector::GetNofPads() const
{ return fNofPads; }
+/// Return the motif map
inline AliMpMotifMap* AliMpSector::GetMotifMap() const
{ return fMotifMap; }
//_______________________________________________________________________
void AliMpSectorPainter::DumpObject()
{
-//// Draw the owned object
+/// Draw the owned object
fSector->Dump();
}
//_______________________________________________________________________
TVector2 AliMpSectorPainter::GetPosition() const
{
-//// Get the owned object's position
+/// Get the owned object's position
if (fSector->GetNofRows()<1) return TVector2(0.,0.);
AliMpRow* row = fSector->GetRow(0);
//_______________________________________________________________________
TVector2 AliMpSectorPainter::GetDimensions() const
{
-//// Get the owned object's dimensions
+/// Get the owned object's dimensions
if (fSector->GetNofRows()<1) return TVector2(0.,0.);
AliMpRow* row = fSector->GetRow(0);
//_______________________________________________________________________
void AliMpSectorPainter::Paint(Option_t* /*option*/)
{
-//// Paint the object
+/// Paint the object
AliMpGraphContext *gr = AliMpGraphContext::Instance();
if (!fSector) return;
virtual TVector2 GetDimensions() const;
private:
+ /// Not implemented
AliMpSectorPainter(const AliMpSectorPainter& right);
+ /// Not implemented
AliMpSectorPainter& operator = (const AliMpSectorPainter& right);
AliMpSector *fSector; ///< the sector to draw
fSector(0),
fMotifReader(new AliMpMotifReader(station, plane))
{
-// Standard constructor
+/// Standard constructor
}
//_____________________________________________________________________________
fSector(0),
fMotifReader(0)
{
-// Default constructor
+/// Default constructor
}
//_____________________________________________________________________________
AliMpSector* BuildSector();
private:
+ /// Not implemented
AliMpSectorReader(const AliMpSectorReader& right);
- AliMpSectorReader& operator = (const AliMpSectorReader& right);
+ /// Not implemented
+ AliMpSectorReader& operator = (const AliMpSectorReader& right);
// methods
void ReadSectorData(ifstream& in);
void
AliMpSectorSegmentation::Print(Option_t* opt) const
{
+/// Print the sector
+
fkSector->Print(opt);
}
{
public:
#ifdef WITH_STL
+ /// Pad dimensions map type
typedef std::map<Int_t, TVector2> PadDimensionsMap;
+ /// Pad dimensions map iterator type
typedef PadDimensionsMap::const_iterator PadDimensionsMapCIterator;
#endif
#ifdef WITH_ROOT
+ /// Pad dimensions map type
typedef TExMap PadDimensionsMap;
+ /// Pad dimensions map iterator type
typedef TExMapIter PadDimensionsMapCIterator;
#endif
TVector2 Dimensions() const;
private:
+ /// Not implemented
AliMpSectorSegmentation(const AliMpSectorSegmentation& right);
+ /// Not implemented
AliMpSectorSegmentation& operator = (const AliMpSectorSegmentation& right);
#ifdef WITH_ROOT
- static const Double_t fgkS1; // the separators used for conversion
- static const Double_t fgkS2; // of TVector2 to Long_t
+ static const Double_t fgkS1; ///< the separators used for conversion
+ static const Double_t fgkS2; ///< of TVector2 to Long_t
// methods
Long_t GetIndex(const TVector2& vector2) const;
// inline functions
+/// Return the sector
inline const AliMpSector* AliMpSectorSegmentation::GetSector() const
{ return fkSector; }
Bool_t warn = true) const;
private:
+ /// Not implemented
AliMpSegmentation();
+ /// Not implemented
AliMpSegmentation(const AliMpSegmentation& rhs);
+ /// Not implemented
AliMpSegmentation& operator=(const AliMpSegmentation& rhs);
AliMpVSegmentation* CreateMpSegmentation(
//______________________________________________________________________________
void AliMpStringObjMap::Print(const TString& key, ofstream& out) const
{
-// Prints the map elements
+/// Special printing
for (Int_t i=0; i<fNofItems; i++) {
out << key << " "
void Print(const TString& key, ofstream& out) const;
private:
+ /// Not implemented
AliMpStringObjMap(const AliMpStringObjMap& rhs);
+ /// Not implemented
AliMpStringObjMap& operator = (const AliMpStringObjMap& rhs);
// data members
//_____________________________________________________________________________
AliMpSubZone::~AliMpSubZone()
{
-// Destructor
+/// Destructor
}
//
{
public:
#ifdef WITH_STL
+ /// Row segment vector type
typedef std::vector<AliMpVRowSegment*> RowSegmentVector;
#endif
#ifdef WITH_ROOT
+ /// Row segment vector type
typedef TList RowSegmentVector;
#endif
AliMpVMotif* GetMotif() const;
private:
+ /// Not implemented
AliMpSubZone(const AliMpSubZone& right);
+ /// Not implemented
AliMpSubZone& operator = (const AliMpSubZone& right);
// data members
//_______________________________________________________________________
void AliMpSubZonePainter::DumpObject()
{
- //// Draw the owned object
+ /// Draw the owned object
fSubZone->Dump();
}
//_______________________________________________________________________
TVector2 AliMpSubZonePainter::GetPosition() const
{
- //// Get the owned object's position
+ /// Get the owned object's position
if (fSubZone->GetNofRowSegments()<1) return TVector2(0.,0.);
AliMpVRowSegment* seg = fSubZone->GetRowSegment(0);
//_______________________________________________________________________
TVector2 AliMpSubZonePainter::GetDimensions() const
{
- //// Get the owned object's dimensions
+ /// Get the owned object's dimensions
if (fSubZone->GetNofRowSegments()<1) return TVector2(0.,0.);
AliMpVRowSegment* seg = fSubZone->GetRowSegment(0);
//_______________________________________________________________________
void AliMpSubZonePainter::Paint(Option_t *option)
{
-//// Paint the object
+/// Paint the object
AliMpGraphContext *gr = AliMpGraphContext::Instance();
if (!fSubZone) return;
virtual Int_t DistancetoPrimitive(Int_t x, Int_t y);
private:
+ /// Not implemented
AliMpSubZonePainter(const AliMpSubZonePainter& right);
+ /// Not implemented
AliMpSubZonePainter& operator = (const AliMpSubZonePainter& right);
AliMpSubZone *fSubZone; ///< the subzone to draw
virtual ~AliMpVIndexed();
// methods
+ /// Create iterator over this element
virtual AliMpVPadIterator* CreateIterator() const = 0;
virtual AliMpIntPair GlobalIndices(const AliMpIntPair& localIndices) const;
// inline functions
+/// Set low indices limit
inline void AliMpVIndexed::SetLowIndicesLimit(const AliMpIntPair& limit)
{ fLowIndicesLimit = limit; }
+/// Set high indices limit
inline void AliMpVIndexed::SetHighIndicesLimit(const AliMpIntPair& limit)
{ fHighIndicesLimit = limit; }
+/// Return low indices limit
inline AliMpIntPair AliMpVIndexed::GetLowIndicesLimit() const
{ return fLowIndicesLimit; }
+/// Return high indices limit
inline AliMpIntPair AliMpVIndexed::GetHighIndicesLimit() const
{ return fHighIndicesLimit; }
// Access methods
AliMpMotifType *GetMotifType() const;
TString GetID() const;
+ /// Return the number of pad dimensions
virtual Int_t GetNofPadDimensions() const=0;
+ /// Return the i-th pad dimensions
virtual TVector2 GetPadDimensions(Int_t i) const=0;
+ /// Return the dimensions of the pad specified by localIndices
virtual TVector2 GetPadDimensions(const AliMpIntPair& localIndices) const=0;
// Geometry
+ /// Return dimensions
virtual TVector2 Dimensions() const=0;
// Other methods
AliMpConnection *FindConnectionByLocalPos(const TVector2& localPos) const;
virtual void Print(Option_t *option) const;
- virtual TVector2 PadPositionLocal(const AliMpIntPair& localIndices) const=0;
+ /// Return local position of the pad specified by local indices
+ virtual TVector2 PadPositionLocal(const AliMpIntPair& localIndices) const=0;
+ /// Return local indices of the pad specified by local position
virtual AliMpIntPair PadIndicesLocal(const TVector2& localPos) const=0;
private:
+ /// Not implemented
AliMpVMotif(const AliMpVMotif& right);
+ /// Not implemented
AliMpVMotif& operator = (const AliMpVMotif& right);
// data members
// inline functions
+/// Return the motif type
inline AliMpMotifType* AliMpVMotif::GetMotifType() const {return fMotifType;}
+
+/// Return the motif identifier
inline TString AliMpVMotif::GetID() const {return fID;}
#endif //ALI_MP_V_MOTIF_H
AliMpVPadIterator& operator = (const AliMpVPadIterator& right);
// methods
+ /// Set iterator to the first pad
virtual void First() = 0;
+ /// Set iterator to the next pad
virtual void Next() = 0;
+ /// Is iterator done
virtual Bool_t IsDone() const = 0;
+ /// Return current pad
virtual AliMpPad CurrentItem() const = 0;
+ /// Invalidate iterator (
virtual void Invalidate() = 0;
ClassDef(AliMpVPadIterator,1) // abstract pad iterator
virtual ~AliMpVPadRowSegment();
// methods
+ /// Return the x coordinate of the left border
+ /// in the global coordinate system.
virtual Double_t LeftBorderX() const = 0;
+ /// Return the x coordinate of the right border
+ /// in the global coordinate system.
virtual Double_t RightBorderX() const = 0;
virtual Double_t HalfSizeY() const;
virtual AliMpPadRow* GetPadRow() const;
virtual AliMpMotif* GetMotif() const;
virtual Int_t GetMotifPositionId() const;
+ /// Return number of pads
Int_t GetNofPads() const {return fNofPads;}
// set methods
void SetOffsetX(Double_t offsetX);
protected:
+ /// Return the x position of the right/left border
Double_t GetOffsetX() const { return fOffsetX; }
private:
+ /// Not implemented
AliMpVPadRowSegment(const AliMpVPadRowSegment& right);
+ /// Not implemented
AliMpVPadRowSegment& operator = (const AliMpVPadRowSegment& right);
// data members
virtual ~AliMpVPainter();
void DumpObject() const; // *MENU*
+ /// Paint the associated object
virtual void Paint(Option_t *option)=0;
virtual TObject* Clone(const char* newname="") const;
virtual TObject* DrawClone(Option_t* option) const; // *MENU*
+ //
// get methods
+ //
+ /// Return the position inside the graphics pad
TVector2 GetPadPosition() const {return fPadPosition;}
+ /// Return the dimensions inside the graphics pad
TVector2 GetPadDimensions() const {return fPadDimensions;}
+ /// Return the color
Int_t GetColor() const {return fColor;}
+ //
// set methods
+ //
+ /// Set the position inside the graphics pad
void SetPadPosition(const TVector2 &padPosition){fPadPosition=padPosition;}
+ /// Set the dimensions inside the graphics pad
void SetPadDimension(const TVector2 &padDimensions){fPadDimensions=padDimensions;}
+ /// Set the color
void SetColor(Int_t color){fColor=color;}
+ //
// methods
+ //
Bool_t IsInside(const TVector2 &point,const TVector2& pos,const TVector2& dim);
+ /// Return the owned object's position
virtual TVector2 GetPosition() const=0;
+ /// Return the owned object's dimensions
virtual TVector2 GetDimensions() const=0;
void InitGraphContext();
void PaintWholeBox(Bool_t fill=kTRUE);
static AliMpVPainter *CreatePainter(TObject *object);
protected:
+ /// Not implemented
void AddPainter(AliMpVPainter *painter);
+ /// Not implemented
AliMpVPainter *DrawObject(TObject *object,Option_t *option="");
private:
+ /// Not implemented
AliMpVPainter(const AliMpVPainter& right);
+ /// Not implemented
AliMpVPainter& operator = (const AliMpVPainter& right);
Int_t fColor; ///< color
AliMpVRowSegment();
virtual ~AliMpVRowSegment();
+ //
// methods
+ //
+
+ /// Return the x coordinate of the left border in the global coordinate system.
virtual Double_t LeftBorderX() const = 0;
+ /// Return the x coordinate of the right border in the global coordinate system.
virtual Double_t RightBorderX() const = 0;
+ /// Return the half size in y of this row segment.
virtual Double_t HalfSizeY() const = 0;
virtual AliMpVPadIterator* CreateIterator() const;
+ //
// find methods
+ //
+
+ /// Find the motif in the given positions
virtual AliMpVMotif* FindMotif(const TVector2& position) const = 0;
+ /// Find the motif position Id in the given positions
virtual Int_t FindMotifPositionId(const TVector2& position) const = 0;
+ /// Has the motif position with the given Id ?
virtual Bool_t HasMotifPosition(Int_t motifPositionId) const = 0;
+ /// Return the coordinates of the motif specified with the given motif position Id
virtual TVector2 MotifCenter(Int_t motifPositionId) const = 0;
+ //
// geometry
+ //
+
+ /// Return the position of the row segment centre.
virtual TVector2 Position() const = 0;
+ /// Return the dimensions the row segment centre.
virtual TVector2 Dimensions() const = 0;
+ //
// set methods
+ //
+
+ /// Calculate offset
virtual void SetOffset(const TVector2& offset) = 0;
+ /// Set global indices limits.
virtual void SetGlobalIndices(AliMpRow* rowBefore) = 0;
+ /// Set global indices to i-th motif position and returns next index in x.
virtual Int_t SetIndicesToMotifPosition(Int_t i,
const AliMpIntPair& indices) = 0;
+ //
// get methods
+ //
+
+ /// Return the row.which this row segment belongs to
virtual AliMpRow* GetRow() const = 0;
+ /// Return the number of motifs in this this row segment.
virtual Int_t GetNofMotifs() const = 0;
+ /// Return the i-th motif of this row segment.
virtual AliMpVMotif* GetMotif(Int_t i) const = 0;
+ /// Return the i-th motif position Id of this row segment.
virtual Int_t GetMotifPositionId(Int_t i) const = 0;
ClassDef(AliMpVRowSegment,1) //Row segment
{
public:
#ifdef WITH_STL
+ /// Pad row vector type
typedef std::vector<AliMpPadRow*> PadRowVector;
+ /// Motif vector type
typedef std::vector<AliMpVMotif*> MotifVector;
+ /// Motif position Id vector type
typedef std::vector<Int_t> MotifPositionIdVector;
#endif
#ifdef WITH_ROOT
+ /// Pad row vector type
typedef TObjArray PadRowVector;
+ /// Motif vector type
typedef TObjArray MotifVector;
+ /// Motif position Id vector type
typedef TArrayI MotifPositionIdVector;
#endif
AliMpVRowSegmentSpecial();
virtual ~AliMpVRowSegmentSpecial();
+ //
// methods
+ //
void AddPadRow(AliMpPadRow* padRow);
void UpdateMotifVector();
+ /// Update pads offset
virtual void UpdatePadsOffset() = 0;
+ /// Return the x coordinate of the left border in the global coordinate system.
virtual Double_t LeftBorderX() const = 0;
+ /// Return the x coordinate of the right border in the global coordinate system.
virtual Double_t RightBorderX() const= 0;
+ /// Return the half size in y of this row segment.
virtual Double_t HalfSizeY() const;
+ //
// find methods
+ //
virtual AliMpVMotif* FindMotif(const TVector2& position) const;
virtual Int_t FindMotifPositionId(const TVector2& position) const;
virtual Bool_t HasMotifPosition(Int_t motifPositionId) const;
virtual TVector2 MotifCenter(Int_t motifPositionId) const;
+ //
// geometry
+ //
+ /// Return the position of the row segment centre.
virtual TVector2 Position() const = 0;
virtual TVector2 Dimensions() const;
+ //
// set methods
+ //
+ /// Calculate offset
virtual void SetOffset(const TVector2& /*offset*/) {}
+ /// Set global indices limits.
virtual void SetGlobalIndices(AliMpRow* rowBefore) = 0;
+ /// Set global indices to i-th motif position and returns next index in x.
virtual Int_t SetIndicesToMotifPosition(Int_t i,
const AliMpIntPair& indices) = 0;
+ //
// get methods
+ //
virtual AliMpRow* GetRow() const;
virtual Int_t GetNofMotifs() const;
virtual AliMpVMotif* GetMotif(Int_t i) const;
protected:
// methods
+ /// Return the coordinates of the motif specified with the given motif position Id \n
virtual TVector2 MotifCenterSlow(Int_t motifPositionId) const = 0;
AliMpPadRow* FindPadRow(Double_t y) const;
AliMpVPadRowSegment* FindPadRowSegment(Int_t motifPositionId) const;
Double_t GetOffsetX() const;
private:
+ /// Not implemented
AliMpVRowSegmentSpecial(const AliMpVRowSegmentSpecial& right);
+ /// Not implemented
AliMpVRowSegmentSpecial& operator = (const AliMpVRowSegmentSpecial& right);
#ifdef WITH_ROOT
// static data members
- static const Int_t fgkMaxNofMotifPositionIds; // dimension of fMotifPositionIds
+ static const Int_t fgkMaxNofMotifPositionIds; ///< dimension of fMotifPositionIds
#endif
// data members
// inline functions
+/// Return the x position of the border that touches a standard row segment
inline Double_t AliMpVRowSegmentSpecial::GetOffsetX() const
{ return fOffsetX; }
virtual ~AliMpVSegmentation();
// factory methods
- /// Create a pad iterator over the given area
+ /// Create iterator over pads in the given area
virtual AliMpVPadIterator* CreateIterator(const AliMpArea& area) const = 0;
-
+
/// Create a pad iterator over the whole area
virtual AliMpVPadIterator* CreateIterator() const = 0;
- /** Fills the array with the pads that are neighbours of pad. Returns
- the number of neighbours. */
+ /// Fill the array with the pads that are neighbours of pad. Returns
+ /// the number of neighbours.
virtual Int_t GetNeighbours(const AliMpPad& pad, TObjArray& neighbours,
Bool_t includeSelf=kFALSE,
Bool_t includeVoid=kFALSE) const = 0;
- // methods
+ // methods
+ //
+ /// Find pad by location
virtual AliMpPad PadByLocation(const AliMpIntPair& location,
Bool_t warning = true) const = 0;
+ /// Find pad by indices
virtual AliMpPad PadByIndices (const AliMpIntPair& indices,
Bool_t warning = true) const = 0;
+ /// Find pad by position
virtual AliMpPad PadByPosition(const TVector2& position,
Bool_t warning = true) const = 0;
virtual AliMpPadPair PadsLeft(const AliMpPad& pad) const;
virtual AliMpPadPair PadsRight(const AliMpPad& pad) const;
+ /// Return maximum pad index in X direction
virtual Int_t MaxPadIndexX() const = 0;
+ /// Return maximum pad index in Y direction
virtual Int_t MaxPadIndexY() const = 0;
+ /// Return the number of pads in the detection element
virtual Int_t NofPads() const = 0;
+ /// Return true if the pad with given indices exists
virtual Bool_t HasPad(const AliMpIntPair& indices) const = 0;
+ /// Fill the given array with the electronic card IDs
virtual void GetAllElectronicCardIDs(TArrayI& ecn) const = 0;
+ /// Return the plane type
virtual AliMp::PlaneType PlaneType() const = 0;
- /// Gives the half-sizes (in cm) of the underlying detection element.
+ /// Return the half-sizes of the detection element
virtual TVector2 Dimensions() const = 0;
private:
{
public:
#ifdef WITH_STL
+ /// Sub zone vector type
typedef std::vector<AliMpSubZone*> SubZoneVector;
#endif
#ifdef WITH_ROOT
+ /// Sub zone vector type
typedef TObjArray SubZoneVector;
#endif
// inline functions
+/// Set pad dimensions
inline void AliMpZone::SetPadDimensions(const TVector2& padDimensions)
{ fPadDimensions = padDimensions; }
+/// Return ID
inline UInt_t AliMpZone::GetID() const
{ return fID; }
+/// Return pad dimensions
inline TVector2 AliMpZone::GetPadDimensions() const
{ return fPadDimensions;}
virtual Int_t DistancetoPrimitive(Int_t x, Int_t y);
private:
+ /// Not implemented
AliMpZonePainter(const AliMpZonePainter& right);
+ /// Not implemented
AliMpZonePainter& operator = (const AliMpZonePainter& right);
AliMpZone *fZone; ///< the zone to draw
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff