--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpPadRowLSegment
+// -------------------------
+// Class describing a pad row segment composed of the
+// the identic pads;
+// the pads are placed from the offset (defined in the base class)
+// to the left.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#include <TError.h>
+
+#include "AliMpPadRowLSegment.h"
+#include "AliMpPadRow.h"
+#include "AliMpMotif.h"
+#include "AliMpMotifType.h"
+
+ClassImp(AliMpPadRowLSegment)
+
+//_____________________________________________________________________________
+AliMpPadRowLSegment::AliMpPadRowLSegment(
+ AliMpPadRow* padRow, AliMpMotif* motif,
+ Int_t motifPositionId, Int_t nofPads)
+ : AliMpVPadRowSegment(padRow, motif, motifPositionId, nofPads)
+{
+//
+}
+
+//_____________________________________________________________________________
+AliMpPadRowLSegment::AliMpPadRowLSegment()
+ : AliMpVPadRowSegment()
+{
+//
+}
+
+//_____________________________________________________________________________
+AliMpPadRowLSegment::~AliMpPadRowLSegment() {
+//
+}
+
+//
+// private methods
+//
+
+//_____________________________________________________________________________
+Double_t AliMpPadRowLSegment::FirstPadCenterX() const
+{
+// Returns the x coordinate of the first (the most right) pad center
+// in global coordinate system.
+// ---
+
+ return GetOffsetX() - GetMotif()->GetPadDimensions().X();
+}
+
+//_____________________________________________________________________________
+Double_t AliMpPadRowLSegment::LastPadCenterX() const
+{
+// Returns the x coordinate of the last (the most left) pad center
+// in global coordinate system.
+// !! numbering of pads is in (-x) direction
+// ---
+
+ return GetOffsetX() - (2.*GetNofPads() - 1)*GetMotif()->GetPadDimensions().X();
+}
+
+//_____________________________________________________________________________
+Double_t AliMpPadRowLSegment::FirstPadBorderX() const
+{
+// Returns the x coordinate of the right border of the first (the most right)
+// pad in global coordinate system.
+// ---
+
+ return GetOffsetX();
+ // Also could be
+ // return FirstPadCenterX() + GetMotif()->GetPadDimensions().X();
+}
+
+//_____________________________________________________________________________
+Double_t AliMpPadRowLSegment::LastPadBorderX() const
+{
+// Returns the x coordinate of the left border of the last (the most left)
+// pad in global coordinate system.
+// ---
+
+ return LastPadCenterX() - GetMotif()->GetPadDimensions().X();
+}
+
+//
+// public methods
+//
+
+//_____________________________________________________________________________
+Double_t AliMpPadRowLSegment::LeftBorderX() const
+{
+// Returns the x coordinate of the left row segment border
+// in global coordinate system.
+// ---
+
+ return LastPadBorderX();
+}
+
+//_____________________________________________________________________________
+Double_t AliMpPadRowLSegment::RightBorderX() const
+{
+// Returns the x coordinate of the right row segment border
+// in global coordinate system.
+// ---
+
+ return FirstPadBorderX();
+}
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpPadRowLSegment
+// -------------------------
+// Class describing a pad row segment composed of the
+// the identic pads;
+// the pads are placed from the offset (defined in the base class)
+// to the left.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#ifndef ALI_MP_PAD_ROW_L_SEGMENT_H
+#define ALI_MP_PAD_ROW_L_SEGMENT_H
+
+#include <TObject.h>
+
+#include "AliMpVPadRowSegment.h"
+
+class AliMpPadRow;
+class AliMpMotif;
+
+class AliMpPadRowLSegment : public AliMpVPadRowSegment
+{
+ public:
+ AliMpPadRowLSegment(AliMpPadRow* padRow, AliMpMotif* motif, Int_t motifPositionId,
+ Int_t nofPads);
+ AliMpPadRowLSegment();
+ virtual ~AliMpPadRowLSegment();
+
+ // methods
+ virtual Double_t LeftBorderX() const;
+ virtual Double_t RightBorderX() const;
+
+ private:
+ // methods
+ Double_t FirstPadCenterX() const;
+ Double_t LastPadCenterX() const;
+ Double_t FirstPadBorderX() const;
+ Double_t LastPadBorderX() const;
+
+ ClassDef(AliMpPadRowLSegment,1) //Row segment
+};
+
+#endif //ALI_MP_PAD_ROW_L_SEGMENT_H
+
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpPadRowRSegment
+// -------------------------
+// Class describing a pad row segment composed of the
+// the identic pads;
+// the pads are placed from the offset (defined in the base class)
+// to the right.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#include <TError.h>
+
+#include "AliMpPadRowRSegment.h"
+#include "AliMpPadRow.h"
+#include "AliMpMotif.h"
+#include "AliMpMotifType.h"
+
+ClassImp(AliMpPadRowRSegment)
+
+//______________________________________________________________________________
+AliMpPadRowRSegment::AliMpPadRowRSegment(AliMpPadRow* padRow, AliMpMotif* motif,
+ Int_t motifPositionId, Int_t nofPads)
+ : AliMpVPadRowSegment(padRow, motif, motifPositionId, nofPads)
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpPadRowRSegment::AliMpPadRowRSegment()
+ : AliMpVPadRowSegment()
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpPadRowRSegment::~AliMpPadRowRSegment() {
+//
+}
+
+//
+// private methods
+//
+
+//______________________________________________________________________________
+Double_t AliMpPadRowRSegment::FirstPadCenterX() const
+{
+// Returns the x coordinate of the first (the most left) pad center
+// in global coordinate system.
+// ---
+
+ return GetOffsetX() + GetMotif()->GetPadDimensions().X();
+}
+
+//______________________________________________________________________________
+Double_t AliMpPadRowRSegment::LastPadCenterX() const
+{
+// Returns the x coordinate of the last (the most right) pad center
+// in global coordinate system.
+// !! numbering of pads is in (-x) direction
+// ---
+
+ return GetOffsetX() + (2.*GetNofPads() - 1)*GetMotif()->GetPadDimensions().X();
+}
+
+//______________________________________________________________________________
+Double_t AliMpPadRowRSegment::FirstPadBorderX() const
+{
+// Returns the x coordinate of the left border of the first (the most left)
+// pad in global coordinate system.
+// ---
+
+ return GetOffsetX();
+ // Also could be
+ // return FirstPadCenterX() + GetMotif()->GetPadDimensions().X();
+}
+
+//______________________________________________________________________________
+Double_t AliMpPadRowRSegment::LastPadBorderX() const
+{
+// Returns the x coordinate of the right border of the last (the most right)
+// pad in global coordinate system.
+// ---
+
+ return LastPadCenterX() + GetMotif()->GetPadDimensions().X();
+}
+
+//
+// public methods
+//
+
+//______________________________________________________________________________
+Double_t AliMpPadRowRSegment::LeftBorderX() const
+{
+// Returns the x coordinate of the left row segment border
+// in global coordinate system.
+// ---
+
+ return FirstPadBorderX();
+}
+
+//______________________________________________________________________________
+Double_t AliMpPadRowRSegment::RightBorderX() const
+{
+// Returns the x coordinate of the right row segment border
+// in global coordinate system.
+// ---
+
+ return LastPadBorderX();
+}
+
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpPadRowRSegment
+// -------------------------
+// Class describing a pad row segment composed of the
+// the identic pads;
+// the pads are placed from the offset (defined in the base class)
+// to the right.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#ifndef ALI_MP_PAD_ROW_R_SEGMENT_H
+#define ALI_MP_PAD_ROW_R_SEGMENT_H
+
+#include <TObject.h>
+
+#include "AliMpVPadRowSegment.h"
+
+class AliMpPadRow;
+class AliMpMotif;
+
+class AliMpPadRowRSegment : public AliMpVPadRowSegment
+{
+ public:
+ AliMpPadRowRSegment(AliMpPadRow* padRow, AliMpMotif* motif, Int_t motifPositionId,
+ Int_t nofPads);
+ AliMpPadRowRSegment();
+ virtual ~AliMpPadRowRSegment();
+
+ // methods
+ virtual Double_t LeftBorderX() const;
+ virtual Double_t RightBorderX() const;
+
+ private:
+ // methods
+ Double_t FirstPadCenterX() const;
+ Double_t LastPadCenterX() const;
+ Double_t FirstPadBorderX() const;
+ Double_t LastPadBorderX() const;
+
+ ClassDef(AliMpPadRowRSegment,1) //Row segment
+};
+
+#endif //ALI_MP_PAD_ROW_R_SEGMENT_H
+
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpRowSegmentLSpecial
+// -----------------------------
+// Class describing a special inner row segment composed of the
+// pad rows.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#include <TError.h>
+
+#include "AliMpRowSegmentLSpecial.h"
+#include "AliMpRow.h"
+#include "AliMpPadRow.h"
+#include "AliMpVPadRowSegment.h"
+#include "AliMpMotif.h"
+#include "AliMpMotifType.h"
+#include "AliMpMotifMap.h"
+#include "AliMpMotifPosition.h"
+#include "AliMpConstants.h"
+
+ClassImp(AliMpRowSegmentLSpecial)
+
+//______________________________________________________________________________
+AliMpRowSegmentLSpecial::AliMpRowSegmentLSpecial(AliMpRow* row, Double_t offsetX)
+ : AliMpVRowSegmentSpecial(row, offsetX)
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpRowSegmentLSpecial::AliMpRowSegmentLSpecial()
+ : AliMpVRowSegmentSpecial()
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpRowSegmentLSpecial::~AliMpRowSegmentLSpecial()
+{
+//
+}
+
+//
+// private methods
+//
+
+//______________________________________________________________________________
+AliMpVPadRowSegment*
+AliMpRowSegmentLSpecial::FindMostRightPadRowSegment(Int_t motifPositionId) const
+{
+// Find the most right pad row segment with this motifPositionId.
+// ---
+
+ AliMpVPadRowSegment* found = 0;
+
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+
+ for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
+ AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
+
+ if ( padRowSegment->GetMotifPositionId() == motifPositionId &&
+ (!found || padRowSegment->RightBorderX() > found->RightBorderX()))
+
+ found = padRowSegment;
+ }
+ }
+
+ return found;
+}
+
+//
+// protected methods
+//
+
+//______________________________________________________________________________
+TVector2 AliMpRowSegmentLSpecial::MotifCenterSlow(Int_t motifPositionId) const
+{
+// Returns the coordinates of the motif specified with
+// the given position identifier.
+// !! Applicable only for motifs that have their most down pad in
+// this row segment.
+// ---
+
+ // Find the first (left, down) pad row segment with this motifPositionId.
+ AliMpVPadRowSegment* downPadRowSegment
+ = FindPadRowSegment(motifPositionId);
+ AliMpVPadRowSegment* rightPadRowSegment
+ = FindMostRightPadRowSegment(motifPositionId);
+
+ // Check if the motifPositionId is present
+ if (!downPadRowSegment || !rightPadRowSegment) {
+ Error("MotifCenter", "Outside row segment region");
+ return 0;
+ }
+
+ // Check if both pad row segments have the same motif
+ if (downPadRowSegment->GetMotif() != rightPadRowSegment->GetMotif()) {
+ Fatal("MotifCenter", "Outside row segment region");
+ return 0;
+ }
+
+ // Get position of found row segment
+ Double_t x = rightPadRowSegment->RightBorderX();
+ Double_t y = GetRow()->LowBorderY() ;
+
+ for (Int_t i=0; i<downPadRowSegment->GetPadRow()->GetID(); i++)
+ y += GetPadRow(i)->HalfSizeY()*2.;
+
+ // Add motifs dimensions
+ x -= downPadRowSegment->GetMotif()->Dimensions().X();
+ y += downPadRowSegment->GetMotif()->Dimensions().Y();
+
+ return TVector2(x, y);
+}
+
+//
+// public methods
+//
+
+//______________________________________________________________________________
+void AliMpRowSegmentLSpecial::UpdatePadsOffset()
+{
+// Sets low indices limit to the pad offset calculated
+// from the neighbour normal segment.
+// ---
+
+ // Get the neighbour row segment
+ // (the first normal segment)
+ AliMpVRowSegment* neighbour = GetRow()->GetRowSegment(1);
+
+ // Get the the pads offset of the neighbour row segment
+ // (the first normal segment)
+ AliMpIntPair offset = neighbour->GetLowIndicesLimit();
+
+ // Find max nof pads in a row
+ Int_t maxNofPads = MaxNofPadsInRow();
+
+ // Set limits
+ SetLowIndicesLimit(offset - AliMpIntPair(maxNofPads, 0));
+
+ // Reset limits in the neighbour row segment
+ // (pad offset is now included in the special segment)
+ neighbour->SetLowIndicesLimit(
+ AliMpIntPair(0, neighbour->GetLowIndicesLimit().GetSecond()));
+}
+
+//______________________________________________________________________________
+Double_t AliMpRowSegmentLSpecial::LeftBorderX() const
+{
+// Returns the x coordinate of the left row segment border
+// in global coordinate system.
+// ---
+
+ Double_t leftBorder = DBL_MAX;
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+ Double_t border
+ = padRow->GetPadRowSegment(padRow->GetNofPadRowSegments()-1)->LeftBorderX();
+
+ if (border < leftBorder) leftBorder = border;
+ }
+
+ return leftBorder;
+}
+
+//______________________________________________________________________________
+Double_t AliMpRowSegmentLSpecial::RightBorderX() const
+{
+// Returns the x coordinate of the right row segment border
+// in global coordinate system.
+// ---
+
+ Double_t sameBorder = GetOffsetX();
+
+ // Consistence check
+ Double_t rightBorder = -DBL_MAX;
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+ Double_t border = padRow->GetPadRowSegment(0)->RightBorderX();
+ if (border > rightBorder) rightBorder = border;
+ }
+
+ if (TMath::Abs(GetOffsetX() - rightBorder) > 1.e-04) {
+ Error("RightBorderX", "WrongBorder");
+ return sameBorder;
+ }
+
+ return rightBorder;
+}
+
+//______________________________________________________________________________
+TVector2 AliMpRowSegmentLSpecial::Position() const
+{
+// Returns the position of the row segment centre.
+// The centre is defined as the centre of the rectangular
+// row segment envelope.
+// ---
+
+ Double_t x = GetOffsetX() - Dimensions().X();
+ Double_t y = GetRow()->Position().Y();
+
+ return TVector2(x, y);
+}
+
+//______________________________________________________________________________
+Int_t AliMpRowSegmentLSpecial::SetIndicesToMotifPosition(Int_t i,
+ const AliMpIntPair& indices)
+{
+// Sets global indices to i-th motif position and returns next index in x.
+// ---
+
+ // Get motif position
+ AliMpMotifPosition* motifPosition
+ = GetRow()->GetMotifMap()->FindMotifPosition(GetMotifPositionId(i));
+
+ // Low limit
+ AliMpIntPair low
+ = AliMpIntPair(GetLowIndicesLimit().GetFirst() + AliMpConstants::StartPadIndex(),
+ indices.GetSecond())
+ + FindRelativeLowIndicesOf(GetMotifPositionId(i));
+
+ if (! motifPosition->GetHighIndicesLimit().IsValid()) {
+ motifPosition->SetLowIndicesLimit(low);
+ }
+ else {
+ if (motifPosition->GetLowIndicesLimit().GetFirst() > low.GetFirst())
+ motifPosition->SetLowIndicesLimit(
+ AliMpIntPair(low.GetFirst(),
+ motifPosition->GetLowIndicesLimit().GetSecond()));
+
+ if (motifPosition->GetLowIndicesLimit().GetSecond() > low.GetSecond())
+ motifPosition->SetLowIndicesLimit(
+ AliMpIntPair(motifPosition->GetLowIndicesLimit().GetFirst(),
+ low.GetSecond()));
+ }
+
+ // High limit
+ AliMpMotifType* motifType = motifPosition->GetMotif()->GetMotifType();
+ AliMpIntPair high
+ = motifPosition->GetLowIndicesLimit()
+ + AliMpIntPair(motifType->GetNofPadsX()-1, motifType->GetNofPadsY()-1);
+ motifPosition->SetHighIndicesLimit(high);
+
+ // Increment index only if last motif position is processed
+ if (i != GetNofMotifs()-1)
+ return indices.GetFirst();
+ //return 0;
+ else
+ return indices.GetFirst() + MaxNofPadsInRow();
+ //return MaxNofPadsInRow();
+}
+
+
+
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpRowSegmentLSpecial
+// -----------------------------
+// Class describing a special inner row segment composed of the
+// pad rows.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#ifndef ALI_MP_ROW_SEGMENT_L_SPECIAL_H
+#define ALI_MP_ROW_SEGMENT_L_SPECIAL_H
+
+#include <TVector2.h>
+
+#include "AliMpSectorTypes.h"
+#include "AliMpVRowSegmentSpecial.h"
+
+class AliMpRow;
+class AliMpPadRow;
+class AliMpVPadRowSegment;
+class AliMpIntPair;
+
+class AliMpRowSegmentLSpecial : public AliMpVRowSegmentSpecial
+{
+ public:
+ AliMpRowSegmentLSpecial(AliMpRow* row, Double_t offsetX);
+ AliMpRowSegmentLSpecial();
+ virtual ~AliMpRowSegmentLSpecial();
+
+ // methods
+ virtual void UpdatePadsOffset();
+ virtual Double_t LeftBorderX() const;
+ virtual Double_t RightBorderX() const;
+
+ // geometry
+ virtual TVector2 Position() const;
+
+ // set methods
+ virtual Int_t SetIndicesToMotifPosition(Int_t i,
+ const AliMpIntPair& indices);
+
+ protected:
+ // methods
+ virtual TVector2 MotifCenterSlow(Int_t motifPositionId) const;
+
+ private:
+ // methods
+ AliMpVPadRowSegment* FindMostRightPadRowSegment(Int_t motifPositionId) const;
+
+ ClassDef(AliMpRowSegmentLSpecial,1) //Row segment
+};
+
+#endif //ALI_MP_ROW_SEGMENT_L_SPECIAL_H
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpRowSegmentRSpecial
+// -----------------------------
+// Class describing a special outer row segment composed of the
+// pad rows.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#include <TError.h>
+#include <Riostream.h>
+
+#include "AliMpRowSegmentRSpecial.h"
+#include "AliMpRow.h"
+#include "AliMpPadRow.h"
+#include "AliMpVPadRowSegment.h"
+#include "AliMpMotif.h"
+#include "AliMpMotifType.h"
+#include "AliMpMotifMap.h"
+#include "AliMpMotifPosition.h"
+
+ClassImp(AliMpRowSegmentRSpecial)
+
+//______________________________________________________________________________
+AliMpRowSegmentRSpecial::AliMpRowSegmentRSpecial(AliMpRow* row, Double_t offsetX)
+ : AliMpVRowSegmentSpecial(row, offsetX)
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpRowSegmentRSpecial::AliMpRowSegmentRSpecial()
+ : AliMpVRowSegmentSpecial()
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpRowSegmentRSpecial::~AliMpRowSegmentRSpecial()
+{
+//
+}
+
+//
+// private methods
+//
+
+//______________________________________________________________________________
+AliMpVPadRowSegment*
+AliMpRowSegmentRSpecial::FindMostLeftPadRowSegment(Int_t motifPositionId) const
+{
+// Find the most left pad row segment with this motifPositionId.
+// ---
+
+ AliMpVPadRowSegment* found = 0;
+
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+
+ for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
+ AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
+
+ if ( padRowSegment->GetMotifPositionId() == motifPositionId &&
+ (!found || padRowSegment->LeftBorderX() < found->LeftBorderX()))
+
+ found = padRowSegment;
+ }
+ }
+
+ return found;
+}
+
+//______________________________________________________________________________
+void AliMpRowSegmentRSpecial::SetGlobalIndicesLow()
+{
+// ...
+
+ // Last normal row segment in the row
+ // (preceding this special row segment)
+ AliMpVRowSegment* rowSegment
+ = GetRow()->GetRowSegment(GetRow()->GetNofRowSegments()-2);
+
+ // Set low indices limit to continue indices of the
+ // preceding row segment
+ Int_t ix = rowSegment->GetHighIndicesLimit().GetFirst() + 1;
+ Int_t iy = rowSegment->GetLowIndicesLimit().GetSecond();
+
+ SetLowIndicesLimit(AliMpIntPair(ix, iy));
+}
+
+//
+// protected methods
+//
+
+//______________________________________________________________________________
+TVector2 AliMpRowSegmentRSpecial::MotifCenterSlow(Int_t motifPositionId) const
+{
+// Returns the coordinates of the motif specified with
+// the given position identifier.
+// !! Applicable only for motifs that have their most down pad in
+// this row segment.
+// ---
+
+ // Find the first (left, down) pad row segment with this motifPositionId.
+ AliMpVPadRowSegment* downPadRowSegment
+ = FindPadRowSegment(motifPositionId);
+ AliMpVPadRowSegment* leftPadRowSegment
+ = FindMostLeftPadRowSegment(motifPositionId);
+
+ // Check if the motifPositionId is present
+ if (!downPadRowSegment || !leftPadRowSegment) {
+ Error("MotifCenter", "Outside row segment region");
+ return 0;
+ }
+
+ // Check if both pad row segments have the same motif
+ if (downPadRowSegment->GetMotif() != leftPadRowSegment->GetMotif()) {
+ Fatal("MotifCenter", "Outside row segment region");
+ return 0;
+ }
+
+ // Get position of found row segment
+ Double_t x = leftPadRowSegment->LeftBorderX();
+ Double_t y = GetRow()->LowBorderY() ;
+
+ for (Int_t i=0; i<downPadRowSegment->GetPadRow()->GetID(); i++)
+ y += GetPadRow(i)->HalfSizeY()*2.;
+
+ // Add motifs dimensions
+ x += downPadRowSegment->GetMotif()->Dimensions().X();
+ y += downPadRowSegment->GetMotif()->Dimensions().Y();
+
+ return TVector2(x, y);
+}
+
+//
+// public methods
+//
+
+//______________________________________________________________________________
+Double_t AliMpRowSegmentRSpecial::LeftBorderX() const
+{
+// Returns the x coordinate of the left row segment border
+// in global coordinate system.
+// ---
+
+ // The right edge of the last normal segment
+ Double_t sameBorder = GetOffsetX();
+
+ // Consistence check
+ Double_t leftBorder = DBL_MAX;
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+ Double_t border = padRow->GetPadRowSegment(0)->LeftBorderX();
+ if (border < leftBorder) leftBorder = border;
+ }
+
+ if (TMath::Abs(sameBorder - leftBorder) > 1.e-04) {
+ Error("LeftBorderX", "WrongBorder");
+ return sameBorder;
+ }
+
+ return leftBorder;
+
+}
+
+//______________________________________________________________________________
+Double_t AliMpRowSegmentRSpecial::RightBorderX() const
+{
+// Returns the x coordinate of the right row segment border
+// in global coordinate system.
+// ---
+
+ Double_t rightBorder = -DBL_MAX;
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+ Double_t border
+ = padRow->GetPadRowSegment(padRow->GetNofPadRowSegments()-1)
+ ->RightBorderX();
+
+ if (border > rightBorder) rightBorder = border;
+ }
+
+ return rightBorder;
+}
+
+//______________________________________________________________________________
+TVector2 AliMpRowSegmentRSpecial::Position() const
+{
+// Returns the position of the row segment centre.
+// The centre is defined as the centre of the rectangular
+// row segment envelope.
+// ---
+
+ // The right edge of the last normal segment
+ Double_t x = GetOffsetX() + Dimensions().X();
+ Double_t y = GetRow()->Position().Y();
+
+ return TVector2(x, y);
+}
+
+//______________________________________________________________________________
+Int_t AliMpRowSegmentRSpecial::SetIndicesToMotifPosition(Int_t i,
+ const AliMpIntPair& indices)
+{
+// Sets global indices to i-th motif position and returns next index in x.
+// ---
+
+ // Update low indices limit for this row segment
+ SetGlobalIndicesLow();
+
+ // Check for consistence
+ if (GetLowIndicesLimit().GetFirst() != indices.GetFirst())
+ Fatal("SetIndicesToMotifPosition", "Inconsistent indices");
+
+ // Get motif position
+ AliMpMotifPosition* motifPosition
+ = GetRow()->GetMotifMap()->FindMotifPosition(GetMotifPositionId(i));
+
+ // Low limit
+ AliMpIntPair low = GetLowIndicesLimit();
+
+ if (! motifPosition->GetHighIndicesLimit().IsValid()) {
+ motifPosition->SetLowIndicesLimit(low);
+ }
+ else {
+ if (motifPosition->GetLowIndicesLimit().GetFirst() > low.GetFirst())
+ motifPosition->SetLowIndicesLimit(
+ AliMpIntPair(low.GetFirst(),
+ motifPosition->GetLowIndicesLimit().GetSecond()));
+
+ if (motifPosition->GetLowIndicesLimit().GetSecond() > low.GetSecond())
+ motifPosition->SetLowIndicesLimit(
+ AliMpIntPair(motifPosition->GetLowIndicesLimit().GetFirst(),
+ low.GetSecond()));
+ }
+
+ // High limit
+ AliMpMotifType* motifType = motifPosition->GetMotif()->GetMotifType();
+ AliMpIntPair high
+ = motifPosition->GetLowIndicesLimit()
+ + AliMpIntPair(motifType->GetNofPadsX()-1, motifType->GetNofPadsY()-1);
+ motifPosition->SetHighIndicesLimit(high);
+
+ // No increment index needed (this is always the last element)
+ return indices.GetFirst();
+}
+
+
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpRowSegmentRSpecial
+// -----------------------------
+// Class describing a special outer row segment composed of the
+// pad rows.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#ifndef ALI_MP_ROW_SEGMENT_R_SPECIAL_H
+#define ALI_MP_ROW_SEGMENT_R_SPECIAL_H
+
+#include <TVector2.h>
+
+#include "AliMpSectorTypes.h"
+#include "AliMpVRowSegmentSpecial.h"
+
+class AliMpRow;
+class AliMpPadRow;
+class AliMpVPadRowSegment;
+class AliMpIntPair;
+
+class AliMpRowSegmentRSpecial : public AliMpVRowSegmentSpecial
+{
+ public:
+ AliMpRowSegmentRSpecial(AliMpRow* row, Double_t offsetX);
+ AliMpRowSegmentRSpecial();
+ virtual ~AliMpRowSegmentRSpecial();
+
+ // methods
+ virtual void UpdatePadsOffset() {}
+ virtual Double_t LeftBorderX() const;
+ virtual Double_t RightBorderX() const;
+
+ // geometry
+ virtual TVector2 Position() const;
+
+ // set methods
+ virtual Int_t SetIndicesToMotifPosition(Int_t i,
+ const AliMpIntPair& indices);
+
+ protected:
+ // methods
+ virtual TVector2 MotifCenterSlow(Int_t motifPositionId) const;
+
+ private:
+ // methods
+ AliMpVPadRowSegment* FindMostLeftPadRowSegment(Int_t motifPositionId) const;
+ void SetGlobalIndicesLow();
+
+ ClassDef(AliMpRowSegmentRSpecial,1) //Row segment
+};
+
+#endif //ALI_MP_ROW_SEGMENT_R_SPECIAL_H
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpVPadRowSegment
+// --------------------
+// The abstract base class for a pad row segment composed of the
+// the identic pads.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#include <TError.h>
+
+#include "AliMpVPadRowSegment.h"
+#include "AliMpPadRow.h"
+#include "AliMpMotif.h"
+#include "AliMpMotifType.h"
+
+ClassImp(AliMpVPadRowSegment)
+
+//_____________________________________________________________________________
+AliMpVPadRowSegment::AliMpVPadRowSegment(AliMpPadRow* padRow, AliMpMotif* motif,
+ Int_t motifPositionId, Int_t nofPads)
+ : TObject(),
+ fNofPads(nofPads),
+ fOffsetX(0.),
+ fPadRow(padRow),
+ fMotif(motif),
+ fMotifPositionId(motifPositionId)
+{
+//
+}
+
+//_____________________________________________________________________________
+AliMpVPadRowSegment::AliMpVPadRowSegment()
+ : TObject(),
+ fNofPads(0),
+ fOffsetX(0.),
+ fPadRow(0),
+ fMotif(0),
+ fMotifPositionId(0)
+{
+//
+}
+
+//_____________________________________________________________________________
+AliMpVPadRowSegment::~AliMpVPadRowSegment() {
+//
+}
+
+//
+// public methods
+//
+
+//_____________________________________________________________________________
+Double_t AliMpVPadRowSegment::HalfSizeY() const
+{
+// Returns the size in y of this row segment.
+// ---
+
+ return fMotif->GetPadDimensions().Y();
+}
+
+//_____________________________________________________________________________
+AliMpPadRow* AliMpVPadRowSegment::GetPadRow() const
+{
+// Returns the pad row.which this pad row segment belongs to.
+// ---
+
+ return fPadRow;
+}
+
+//_____________________________________________________________________________
+AliMpMotif* AliMpVPadRowSegment::GetMotif() const
+{
+// Returns the motif of this pad row segment.
+// ---
+
+ return fMotif;
+}
+
+//_____________________________________________________________________________
+Int_t AliMpVPadRowSegment::GetMotifPositionId() const
+{
+// Returns the motif of this pad row segment.
+// ---
+
+ return fMotifPositionId;
+}
+
+//_____________________________________________________________________________
+void AliMpVPadRowSegment::SetOffsetX(Double_t offsetX)
+{
+// Sets the x offset.
+// ---
+
+ fOffsetX = offsetX;
+}
+
--- /dev/null
+// $Id$
+// ---------------------------------------------------------------
+// Category: sector
+//
+// Class AliMpVPadRowSegment
+// -------------------------
+// The abstract base class for a pad row segment composed of the
+// the identic pads.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#ifndef ALI_MP_V_PAD_ROW_SEGMENT_H
+#define ALI_MP_V_PAD_ROW_SEGMENT_H
+
+#include <TObject.h>
+
+class AliMpPadRow;
+class AliMpMotif;
+
+class AliMpVPadRowSegment : public TObject
+{
+ public:
+ AliMpVPadRowSegment(AliMpPadRow* padRow, AliMpMotif* motif,
+ Int_t motifPositionId, Int_t nofPads);
+ AliMpVPadRowSegment();
+ virtual ~AliMpVPadRowSegment();
+
+ // methods
+ virtual Double_t LeftBorderX() const = 0;
+ virtual Double_t RightBorderX() const = 0;
+ virtual Double_t HalfSizeY() const;
+
+ // get methods
+ virtual AliMpPadRow* GetPadRow() const;
+ virtual AliMpMotif* GetMotif() const;
+ virtual Int_t GetMotifPositionId() const;
+ Int_t GetNofPads() const {return fNofPads;}
+
+ // set methods
+ void SetOffsetX(Double_t offsetX);
+
+ protected:
+ Double_t GetOffsetX() const { return fOffsetX; }
+
+ private:
+ // data members
+ Int_t fNofPads; //number of pads
+ Double_t fOffsetX; //the x position of the right/left border
+ AliMpPadRow* fPadRow; //the pad row containing this segment
+ AliMpMotif* fMotif; //the motif
+ Int_t fMotifPositionId; // the motif position id
+
+ ClassDef(AliMpVPadRowSegment,1) //Row segment
+};
+
+#endif //ALI_MP_V_PAD_ROW_SEGMENT_H
+
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpVRowSegmentSpecial
+// ----------------------------
+// Class describing a special row segment composed of the
+// pad rows.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#include <TError.h>
+#include <Riostream.h>
+
+#include "AliMpVRowSegmentSpecial.h"
+#include "AliMpRow.h"
+#include "AliMpPadRow.h"
+#include "AliMpVPadRowSegment.h"
+#include "AliMpMotif.h"
+#include "AliMpMotifType.h"
+#include "AliMpMotifMap.h"
+#include "AliMpMotifPosition.h"
+#include "AliMpConstants.h"
+
+ClassImp(AliMpVRowSegmentSpecial)
+
+//______________________________________________________________________________
+AliMpVRowSegmentSpecial::AliMpVRowSegmentSpecial(AliMpRow* row, Double_t offsetX)
+ : AliMpVRowSegment(),
+ fRow(row),
+ fOffsetX(offsetX),
+ fPadRows(),
+ fMotifs(),
+ fMotifPositionIds()
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpVRowSegmentSpecial::AliMpVRowSegmentSpecial()
+ : AliMpVRowSegment(),
+ fRow(0),
+ fOffsetX(0.),
+ fPadRows(),
+ fMotifs(),
+ fMotifPositionIds()
+{
+//
+}
+
+//______________________________________________________________________________
+AliMpVRowSegmentSpecial::~AliMpVRowSegmentSpecial()
+{
+//
+ for (Int_t i=0; i<GetNofPadRows(); i++)
+ delete fPadRows[i];
+}
+
+//
+// protected methods
+//
+
+//______________________________________________________________________________
+AliMpPadRow* AliMpVRowSegmentSpecial::FindPadRow(Double_t y) const
+{
+// Finds the pad row in the given y coordinate.
+// ---
+
+ Double_t lowBorder = fRow->LowBorderY();
+ Double_t highBorder = fRow->LowBorderY();
+
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+
+ AliMpPadRow* padRow = GetPadRow(i);
+ highBorder += 2.*padRow->HalfSizeY();
+
+ if ( y >= lowBorder && y <= highBorder)
+ return padRow;
+
+ lowBorder = highBorder;
+ }
+
+ return 0;
+}
+
+//______________________________________________________________________________
+AliMpVPadRowSegment*
+AliMpVRowSegmentSpecial::FindPadRowSegment(Int_t motifPositionId) const
+{
+// Find the most down pad row segment with this motifPositionId.
+// ---
+
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+
+ for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
+ AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
+
+ if (padRowSegment->GetMotifPositionId() == motifPositionId)
+ return padRowSegment;
+ }
+ }
+ return 0;
+}
+
+//______________________________________________________________________________
+AliMpIntPair
+AliMpVRowSegmentSpecial::FindRelativeLowIndicesOf(Int_t motifPositionId) const
+{
+// Returns the lowest pad indices where the motif of the given position ID
+// exists in this segment.
+// ---
+
+ AliMpIntPair ans(0,1000);
+ AliMpIntPair ans0 = ans;
+ Int_t maxNofPadsX=0;
+
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+
+ Int_t nofPadsX=0;
+ for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
+ AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
+ nofPadsX += padRowSegment->GetNofPads();
+ if (padRowSegment->GetMotifPositionId() == motifPositionId) {
+ if (ans.GetFirst() < nofPadsX) ans.SetFirst(nofPadsX);
+ if (ans.GetSecond()>i) ans.SetSecond(i);
+ // ans.First = max (nof pads of this pos ID)
+ // ans.Second = min of pad row number
+ }
+ }
+ if (nofPadsX > maxNofPadsX) maxNofPadsX = nofPadsX;
+ }
+ if (ans == ans0) return AliMpIntPair::Invalid();
+
+ return AliMpIntPair(maxNofPadsX-ans.GetFirst(), ans.GetSecond());
+}
+
+//______________________________________________________________________________
+Int_t AliMpVRowSegmentSpecial::MaxNofPadsInRow() const
+{
+// Returns the maximum number of pads in this row segment along the X direction
+// ---
+
+ Int_t maxNofPads = 0;
+
+ for (Int_t i=0; i<GetNofPadRows(); i++){
+ Int_t nofPads = GetPadRow(i)->GetNofPads();
+
+ // Find maximum
+ if (nofPads > maxNofPads) maxNofPads = nofPads;
+ }
+
+ return maxNofPads;
+}
+
+//______________________________________________________________________________
+Bool_t AliMpVRowSegmentSpecial::HasMotif(const AliMpVMotif* motif) const
+{
+// Returns true if the specified motif is already in fMotifs vector,
+// returns false otherwise.
+// ---
+
+ for (UInt_t i=0; i<fMotifs.size(); i++)
+ if (fMotifs[i] == motif) return true;
+
+ return false;
+}
+
+//______________________________________________________________________________
+Int_t AliMpVRowSegmentSpecial::GetNofPadRows() const
+{
+// Returns number of pad rows.
+// ---
+
+ return fPadRows.size();
+}
+
+//______________________________________________________________________________
+AliMpPadRow* AliMpVRowSegmentSpecial::GetPadRow(Int_t i) const
+{
+// Returns number of pad rows.
+// ---
+
+ return fPadRows[i];
+}
+
+//
+// public methods
+//
+
+//______________________________________________________________________________
+void AliMpVRowSegmentSpecial::AddPadRow(AliMpPadRow* padRow)
+{
+// Adds a pad row.
+// ---
+
+ padRow->SetOffsetX(fOffsetX);
+ padRow->SetID(GetNofPadRows());
+ fPadRows.push_back(padRow);
+}
+
+//______________________________________________________________________________
+void AliMpVRowSegmentSpecial::UpdateMotifVector()
+{
+// Add motifs associated with the pad row segments in the specified
+// pad row in the fMotifs vector.
+// ---
+
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+
+ for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
+ AliMpVMotif* motif = padRow->GetPadRowSegment(j)->GetMotif();
+
+ if (!HasMotif(motif)) {
+ fMotifs.push_back(motif);
+ fMotifPositionIds.push_back(
+ padRow->GetPadRowSegment(j)->GetMotifPositionId());
+ }
+ }
+ }
+}
+
+//______________________________________________________________________________
+Double_t AliMpVRowSegmentSpecial::HalfSizeY() const
+{
+// Returns the size in y of this row segment.
+// ---
+
+ Double_t halfSizeY = 0.;
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ halfSizeY += GetPadRow(i)->HalfSizeY();
+ }
+
+ return halfSizeY;
+}
+
+//______________________________________________________________________________
+AliMpVMotif* AliMpVRowSegmentSpecial::FindMotif(const TVector2& position) const
+{
+// Returns the motif of this row;
+// ---
+
+ AliMpPadRow* padRow
+ = FindPadRow(position.Y());
+
+ if (!padRow) return 0;
+
+ AliMpVPadRowSegment* padRowSegment
+ = padRow->FindPadRowSegment(position.X());
+
+ if (!padRowSegment) return 0;
+
+ return padRowSegment->GetMotif();
+}
+
+//______________________________________________________________________________
+Int_t AliMpVRowSegmentSpecial::FindMotifPositionId(const TVector2& position) const
+{
+// Returns the motif position identified for the given
+// geometric position.
+// ---
+
+ AliMpPadRow* padRow
+ = FindPadRow(position.Y());
+
+ if (!padRow) return 0;
+
+ AliMpVPadRowSegment* padRowSegment
+ = padRow->FindPadRowSegment(position.X());
+
+ if (!padRowSegment) return 0;
+
+ return padRowSegment->GetMotifPositionId();
+}
+
+//______________________________________________________________________________
+Bool_t AliMpVRowSegmentSpecial::HasMotifPosition(Int_t motifPositionId) const
+{
+// Returns true if the motif specified with the given position identifier
+// is in this segment.
+// ---
+
+ if (FindPadRowSegment(motifPositionId))
+ return true;
+ else
+ return false;
+}
+
+//______________________________________________________________________________
+TVector2 AliMpVRowSegmentSpecial::MotifCenter(Int_t motifPositionId) const
+{
+// Returns the coordinates of the motif specified with
+// the given position identifier.
+// ---
+
+ // Try to get the motif position from the motif map first
+ AliMpMotifPosition* motifPosition
+ = GetRow()->GetMotifMap()->FindMotifPosition(motifPositionId);
+ if (motifPosition) return motifPosition->Position();
+
+ // Use slow method otherwise
+ return MotifCenterSlow(motifPositionId);
+}
+
+//______________________________________________________________________________
+TVector2 AliMpVRowSegmentSpecial::Dimensions() const
+{
+// Returns the halflengths in x, y of the row segment rectangular envelope.
+// ---
+
+ Double_t x = 0.;
+ Double_t y = 0.;
+ for (Int_t i=0; i<GetNofPadRows(); i++) {
+ AliMpPadRow* padRow = GetPadRow(i);
+
+ // Add all pad rows y halfsizes
+ y += padRow->HalfSizeY();
+
+ // Find the biggest pad rows x halfsize
+ Double_t xx
+ = (padRow->GetPadRowSegment(0)->RightBorderX() -
+ padRow->GetPadRowSegment(padRow->GetNofPadRowSegments()-1)->LeftBorderX())/2.;
+ if (xx > x) x = xx;
+ }
+
+ return TVector2(x, y);
+}
+
+//______________________________________________________________________________
+void AliMpVRowSegmentSpecial::SetGlobalIndices()
+{
+// Sets indices limits.
+// ---
+
+ AliMpMotifPosition* firstPos = 0;
+ AliMpMotifPosition* lastPos = 0;
+
+ for (Int_t i=0;i<GetNofMotifs();i++) {
+ AliMpMotifPosition* mPos
+ = GetRow()->GetMotifMap()
+ ->FindMotifPosition(GetMotifPositionId(i));
+
+ if (!firstPos ||
+ mPos->GetLowIndicesLimit().GetFirst()
+ < firstPos->GetLowIndicesLimit().GetFirst())
+ firstPos = mPos;
+
+ if (!lastPos ||
+ mPos->GetHighIndicesLimit().GetFirst()
+ >lastPos->GetHighIndicesLimit().GetFirst())
+ lastPos = mPos;
+ }
+
+ // Check if the motif positions has the limits set
+ if ( !firstPos->HasValidIndices() || !lastPos->HasValidIndices())
+ Fatal("SetGlobalIndices", "Indices of motif positions have to be set first.");
+
+ SetLowIndicesLimit(firstPos->GetLowIndicesLimit());
+ SetHighIndicesLimit(lastPos->GetHighIndicesLimit());
+}
+
+//______________________________________________________________________________
+AliMpRow* AliMpVRowSegmentSpecial::GetRow() const
+{
+// Returns the row.which this row segment belongs to.
+// ---
+
+ return fRow;
+}
+
+//______________________________________________________________________________
+Int_t AliMpVRowSegmentSpecial::GetNofMotifs() const
+{
+// Returns the number of different motifs present in this row segment.
+// ---
+
+ return fMotifs.size();
+}
+
+//______________________________________________________________________________
+AliMpVMotif* AliMpVRowSegmentSpecial::GetMotif(Int_t i) const
+{
+// Returns the i-th motif present in this row segment.
+// ---
+
+ return fMotifs[i];
+}
+
+//______________________________________________________________________________
+Int_t AliMpVRowSegmentSpecial::GetMotifPositionId(Int_t i) const
+{
+// Returns the i-th motif position Id present in this row segment.
+// ---
+
+ return fMotifPositionIds[i];
+}
+
--- /dev/null
+// $Id$
+// Category: sector
+//
+// Class AliMpVRowSegmentSpecial
+// -----------------------------
+// Abstract base class for a special row segment composed of the
+// pad rows.
+//
+// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
+
+#ifndef ALI_MP_V_ROW_SEGMENT_SPECIAL_H
+#define ALI_MP_V_ROW_SEGMENT_SPECIAL_H
+
+#include <TVector2.h>
+
+#include "AliMpSectorTypes.h"
+#include "AliMpVRowSegment.h"
+#include "AliMpVMotif.h"
+
+class AliMpRow;
+class AliMpPadRow;
+class AliMpVPadRowSegment;
+class AliMpIntPair;
+
+class AliMpVRowSegmentSpecial : public AliMpVRowSegment
+{
+ public:
+ AliMpVRowSegmentSpecial(AliMpRow* row, Double_t offsetX);
+ AliMpVRowSegmentSpecial();
+ virtual ~AliMpVRowSegmentSpecial();
+
+ // methods
+ void AddPadRow(AliMpPadRow* padRow);
+ void UpdateMotifVector();
+ virtual void UpdatePadsOffset() = 0;
+ virtual Double_t LeftBorderX() const = 0;
+ virtual Double_t RightBorderX() const= 0;
+ 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
+ virtual TVector2 Position() const = 0;
+ virtual TVector2 Dimensions() const;
+
+ // set methods
+ virtual void SetOffset(const TVector2& /*offset*/) {}
+ virtual void SetGlobalIndices();
+ 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;
+ virtual Int_t GetMotifPositionId(Int_t i) const;
+
+ protected:
+ // methods
+ virtual TVector2 MotifCenterSlow(Int_t motifPositionId) const = 0;
+ AliMpPadRow* FindPadRow(Double_t y) const;
+ AliMpVPadRowSegment* FindPadRowSegment(Int_t motifPositionId) const;
+ AliMpIntPair FindRelativeLowIndicesOf(Int_t motifPositionId) const;
+ Int_t MaxNofPadsInRow() const;
+ Bool_t HasMotif(const AliMpVMotif* motif) const;
+
+ // get methods
+ Int_t GetNofPadRows() const;
+ AliMpPadRow* GetPadRow(Int_t i) const;
+ Double_t GetOffsetX() const;
+
+ private:
+ // data members
+ AliMpRow* fRow; //the row containing this segment
+ Double_t fOffsetX; //the x position of the border that touches a standard
+ //row segment
+ PadRowVector fPadRows; //pad rows vector
+ MotifVector fMotifs; //motifs vector
+ MotifPositionIdVector fMotifPositionIds; //motifs position Ids vector
+
+ ClassDef(AliMpVRowSegmentSpecial,1) //Row segment
+};
+
+// inline functions
+
+inline Double_t AliMpVRowSegmentSpecial::GetOffsetX() const
+{ return fOffsetX; }
+
+#endif //ALI_MP_V_ROW_SEGMENT_SPECIAL_H
--- /dev/null
+// $Id$
+// Category: basic
+//
+// Enum AliMpDirection
+// -------------------
+// Enumeration for the directions in a plane.
+//
+// Authors: David Guez, IPN Orsay
+
+#ifndef ALI_MP_X_DIRECTION_H
+#define ALI_MP_X_DIRECTION_H
+
+enum AliMpXDirection
+{
+ kLeft, // special row segments built from right to left
+ kRight // special row segments built from left to right
+};
+
+#endif //ALI_MP_X_DIRECTION_H
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff