+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
// $Id$
+// $MpId: AliMpSectorSegmentation.cxx,v 1.15 2006/05/24 13:58:46 ivana Exp $
// Category: sector
-//
+
+//-----------------------------------------------------------------------------
// Class AliMpSectorSegmentation
// -----------------------------
// Class describing the segmentation of the sector.
// finding pad neighbour.
//
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
-
-#include <Riostream.h>
-#include <TMath.h>
+//-----------------------------------------------------------------------------
#include "AliMpSectorSegmentation.h"
#include "AliMpSector.h"
#include "AliMpVMotif.h"
#include "AliMpMotifPosition.h"
#include "AliMpConnection.h"
-#include "AliMpNeighboursPadIterator.h"
#include "AliMpSectorAreaHPadIterator.h"
#include "AliMpSectorAreaVPadIterator.h"
-#include "AliMpIntPair.h"
+#include "AliMpSectorPadIterator.h"
#include "AliMpArea.h"
#include "AliMpConstants.h"
+#include "AliMpEncodePair.h"
-ClassImp(AliMpSectorSegmentation)
+#include "AliLog.h"
-#ifdef WITH_ROOT
-const Double_t AliMpSectorSegmentation::fgkSeparator = 10000.;
-#endif
+#include <Riostream.h>
+#include <TMath.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMpSectorSegmentation)
+/// \endcond
//______________________________________________________________________________
-AliMpSectorSegmentation::AliMpSectorSegmentation(const AliMpSector* sector)
+AliMpSectorSegmentation::AliMpSectorSegmentation(
+ const AliMpSector* sector, Bool_t own)
: AliMpVSegmentation(),
- fkSector(sector)
+ fkSector(sector),
+ fIsOwner(own),
+ fPadBuffer(0),
+ fMaxIndexInX(0),
+ fMaxIndexInY(0)
{
-//
+/// Standard constructor
+
+ AliDebugStream(1) << "this = " << this << endl;
+
fPadBuffer = new AliMpPad(AliMpPad::Invalid());
- FillPadDimensionsMap();
+ //FillPadDimensionsMap();
}
//______________________________________________________________________________
AliMpSectorSegmentation::AliMpSectorSegmentation()
: AliMpVSegmentation(),
fkSector(0),
+ fIsOwner(false),
fPadBuffer(0),
- fPadDimensionsMap()
+ fMaxIndexInX(0),
+ fMaxIndexInY(0)
{
-//
-}
+/// Default constructor
-//______________________________________________________________________________
-AliMpSectorSegmentation::~AliMpSectorSegmentation() {
-//
- delete fPadBuffer;
+ AliDebugStream(1) << "this = " << this << endl;
}
-//
-// private methods
-//
-
-#ifdef WITH_ROOT
-//______________________________________________________________________________
-Long_t AliMpSectorSegmentation::GetIndex(const TVector2& vector2) const
-{
-// Converts the twovector to long.
-// ---
-
- if (vector2.X() >= fgkSeparator || vector2.Y() >= fgkSeparator)
- Fatal("GetIndex", "Index out of limit.");
-
- return Long_t(vector2.X()*fgkSeparator + vector2.Y() + 1.);
-}
-
//______________________________________________________________________________
-TVector2 AliMpSectorSegmentation::GetVector(Long_t index) const
+AliMpSectorSegmentation::~AliMpSectorSegmentation()
{
-// Converts the long index to twovector.
-// ---
+/// Destructor
- return TVector2(TMath::Floor((index-1.)/fgkSeparator),
- (index-1.) - TMath::Floor((index-1.)/fgkSeparator)*fgkSeparator);
-}
-#endif
+ AliDebugStream(1) << "this = " << this << endl;
-//______________________________________________________________________________
-void AliMpSectorSegmentation::FillPadDimensionsMap()
-{
-// Fills the maps between zone ids and pad dimensions.
-// ---
+ if ( fIsOwner ) delete fkSector;
- for (Int_t i=0; i<fkSector->GetNofZones(); i++) {
- AliMpZone* zone = fkSector->GetZone(i+1);
- Int_t zoneID = zone->GetID();
-
- if (!AliMpConstants::IsEqual(zone->GetPadDimensions(), TVector2())) {
-
- // regular zone
-#ifdef WITH_STL
- fPadDimensionsMap[zoneID*10] = zone->GetPadDimensions();
-#endif
-#ifdef WITH_ROOT
- fPadDimensionsMap.Add((Long_t)(zoneID*10),
- GetIndex(zone->GetPadDimensions()));
-#endif
- }
- else {
- // special zone
- Int_t subIndex = 0;
- for (Int_t j=0; j<zone->GetNofSubZones(); j++) {
- AliMpSubZone* subZone = zone->GetSubZone(j);
- AliMpVMotif* motif = subZone->GetMotif();
-
- for (Int_t k=0; k<motif->GetNofPadDimensions(); k++) {
- Int_t index = zoneID*10 + subIndex++;
-#ifdef WITH_STL
- fPadDimensionsMap[index] = motif->GetPadDimensions(k);
-#endif
-#ifdef WITH_ROOT
- fPadDimensionsMap.Add((Long_t)(index),
- GetIndex(motif->GetPadDimensions(k)));
-#endif
- }
- }
- }
- }
+ delete fPadBuffer;
+
}
+//
+// private methods
+//
+
//______________________________________________________________________________
AliMpMotifPosition*
-AliMpSectorSegmentation::FindMotifPosition(const AliMpIntPair& indices) const
+AliMpSectorSegmentation::FindMotifPosition(Int_t ix, Int_t iy) const
{
-// Find the motif position which contains the given pad indices
-// return 0 if not found
-// ---
+/// Find the motif position which contains the given pad indices
+/// return 0 if not found
- switch (fkSector->GetDirection()) {
- case kX : {
+ switch ( fkSector->GetDirection() ) {
+ case AliMp::kX : {
// Case where all the pads have the same size along X direction
- for (Int_t irow=0; irow<fkSector->GetNofRows(); ++irow) {
+ for ( Int_t irow=0; irow<fkSector->GetNofRows(); ++irow ) {
AliMpRow* row = fkSector->GetRow(irow);
- if (row->GetLowIndicesLimit().GetFirst()<=indices.GetFirst() &&
- row->GetHighIndicesLimit().GetFirst()>=indices.GetFirst()) {
+ if ( row->GetLowLimitIx() <= ix &&
+ row->GetHighLimitIx()>= ix ) {
- for (Int_t iseg=0;iseg<row->GetNofRowSegments();++iseg){
+ for ( Int_t iseg=0;iseg<row->GetNofRowSegments();++iseg ) {
AliMpVRowSegment* seg = row->GetRowSegment(iseg);
- if (seg->GetLowIndicesLimit().GetFirst()<=indices.GetFirst() &&
- seg->GetHighIndicesLimit().GetFirst()>=indices.GetFirst()) {
+ if ( seg->GetLowLimitIx() <= ix &&
+ seg->GetHighLimitIx() >= ix ) {
AliMpMotifPosition* motifPos;
- for (Int_t imot=0;imot<seg->GetNofMotifs();++imot) {
+ for ( Int_t imot=0;imot<seg->GetNofMotifs();++imot ) {
motifPos
= fkSector->GetMotifMap()
->FindMotifPosition(seg->GetMotifPositionId(imot));
- if (motifPos && motifPos->HasPad(indices)) return motifPos;
+ if (motifPos && motifPos->HasPadByIndices(AliMp::Pair(ix,iy))) return motifPos;
}
}
}
}
break;
////////////////////////////////////////////////////////////////////////////////
- case kY : {
+ case AliMp::kY : {
// Case where all the pads have the same size along Y direction
// look for the row which contains the indices
AliMpRow* row=0;
Int_t irow;
- for (irow=0; irow<fkSector->GetNofRows(); ++irow) {
+ for ( irow=0; irow<fkSector->GetNofRows(); ++irow ) {
row = fkSector->GetRow(irow);
AliMpVRowSegment* lastSeg = row->GetRowSegment(row->GetNofRowSegments()-1);
- if (lastSeg->GetLowIndicesLimit().GetSecond()<=indices.GetSecond() &&
- lastSeg->GetHighIndicesLimit().GetSecond()>=indices.GetSecond()) break;
+ if ( lastSeg->GetLowLimitIy() <= iy &&
+ lastSeg->GetHighLimitIy() >= iy ) break;
// NOTE : We use the last row segment in order to ensure that
// we are not on a special motif
}
- if (irow==fkSector->GetNofRows()) return 0;
+ if ( irow==fkSector->GetNofRows() ) return 0;
// look for the row segment, in the found row, which contains the indices
AliMpVRowSegment* seg=0;
Int_t iseg;
- for (iseg=0;iseg<row->GetNofRowSegments();++iseg){
+ for ( iseg=0;iseg<row->GetNofRowSegments();++iseg ) {
seg = row->GetRowSegment(iseg);
- if (seg->HasIndices(indices)) break;
+ if (seg->HasIndices(AliMp::Pair(ix, iy))) break;
}
- if (iseg==row->GetNofRowSegments()) return 0;
+ if ( iseg==row->GetNofRowSegments() ) return 0;
// look for the motif position which contains the indices
AliMpMotifPosition* motifPos=0;
Int_t imot=0;
- for (imot=0;imot<seg->GetNofMotifs();++imot) {
+ for ( imot=0;imot<seg->GetNofMotifs();++imot ) {
motifPos
= fkSector->GetMotifMap()
->FindMotifPosition(seg->GetMotifPositionId(imot));
- if (motifPos && motifPos->HasPad(indices)) break;
+ if (motifPos && motifPos->HasPadByIndices(AliMp::Pair(ix, iy))) break;
}
if (imot==seg->GetNofMotifs()) return 0;
//______________________________________________________________________________
AliMpPad
-AliMpSectorSegmentation::PadByXDirection(const TVector2& startPosition,
+AliMpSectorSegmentation::PadByXDirection(Double_t startx, Double_t starty,
Double_t maxX) const
{
-// Find the first valid pad from starting position in the
-// direction of pad lines up to distance dx.
-// ---
+/// Find the first valid pad from starting position in the
+/// direction of pad lines up to distance dx.
// Define step limits
- Double_t stepX = fkSector->GetMinPadDimensions().X();
+ Double_t stepX = fkSector->GetMinPadDimensionX();
// Search in X direction
AliMpPad pad;
- TVector2 position(startPosition);
+ Double_t posx = startx;
do {
- pad = PadByPosition(position, false);
- position += TVector2(stepX, 0.);
+ pad = PadByPosition(posx, starty, false);
+ posx += stepX;
}
- while ( !pad.IsValid() && position.X() < maxX );
+ while ( ! pad.IsValid() &&
+ posx - fkSector->GetMaxPadDimensionX() < maxX );
// Invalidate pad if it is outside limits
- if ((pad.Position().X() - pad.Dimensions().X()) > maxX)
+ if ( ( pad.GetPositionX() - pad.GetDimensionX()) > maxX )
pad = AliMpPad::Invalid();
return pad;
//______________________________________________________________________________
AliMpPad
-AliMpSectorSegmentation::PadByYDirection(const TVector2& startPosition,
+AliMpSectorSegmentation::PadByYDirection(Double_t startx, Double_t starty,
Double_t maxY) const
{
-// Find the first valid pad from starting position in the
-// direction of pad columns up to distance dx.
-// ---
+/// Find the first valid pad from starting position in the
+/// direction of pad columns up to distance dx.
// Define step limits
- Double_t stepY = fkSector->GetMinPadDimensions().Y();
+ Double_t stepY = fkSector->GetMinPadDimensionY();
// Search in Y direction
AliMpPad pad;
- TVector2 position(startPosition);
+ Double_t posy = starty;
do {
- pad = PadByPosition(position, false);
- position += TVector2(0., stepY);
+ pad = PadByPosition(startx, posy, false);
+ posy += stepY;
}
- while ( !pad.IsValid() && position.Y() < maxY );
+ while ( ! pad.IsValid() &&
+ posy - fkSector->GetMaxPadDimensionY()< maxY );
// Invalidate pad if it is outside limits
- if ((pad.Position().Y() - pad.Dimensions().Y()) > maxY)
+ if (( pad.GetPositionY() - pad.GetDimensionY()) > maxY )
pad = AliMpPad::Invalid();
return pad;
}
-//______________________________________________________________________________
-AliMpVPadIterator* AliMpSectorSegmentation::CreateIterator() const
-{
-// The inherited method cannot be used
-
- Fatal("CreateIterator", "Center pad has to be specified.");
- return 0;
-}
-
-
//
// public methods
//
AliMpVPadIterator*
AliMpSectorSegmentation::CreateIterator(const AliMpArea& area) const
{
-// Creates the are iterator.
-// (The inherited method cannot be used)
-// ---
+/// Create the area iterator.
switch (fkSector->GetDirection()) {
- case kX: return new AliMpSectorAreaVPadIterator(this, area);
+ case AliMp::kX: return new AliMpSectorAreaVPadIterator(this, area);
;;
- case kY: return new AliMpSectorAreaHPadIterator(this, area);
+ case AliMp::kY: return new AliMpSectorAreaHPadIterator(this, area);
;;
}
//______________________________________________________________________________
AliMpVPadIterator*
-AliMpSectorSegmentation::CreateIterator(const AliMpPad& centerPad,
- Bool_t includeCenter) const
+AliMpSectorSegmentation::CreateIterator() const
{
-// Creates the neighbours pad iterator.
-// (The inherited method cannot be used)
+/// Create the sector iterator
+
+ return new AliMpSectorPadIterator(fkSector);
+}
+
+//______________________________________________________________________________
+Int_t
+AliMpSectorSegmentation::GetNeighbours(const AliMpPad& pad, TObjArray& neighbours,
+ Bool_t includeSelf,
+ Bool_t includeVoid) const
+{
+ /// Uses default implementation
+ return AliMpVSegmentation::GetNeighbours(pad,neighbours,includeSelf,includeVoid);
+}
- return new AliMpNeighboursPadIterator(this, centerPad, includeCenter);
-}
-
//______________________________________________________________________________
AliMpPad
-AliMpSectorSegmentation::PadByLocation(const AliMpIntPair& location,
+AliMpSectorSegmentation::PadByLocation(Int_t manuId, Int_t manuChannel,
Bool_t warning) const
{
-// Find the pad which corresponds to the given location
-
- if ((*fPadBuffer).GetLocation()==location) return (*fPadBuffer);
+/// Find the pad which corresponds to the given location
+
+ if ( fPadBuffer->GetManuId() == manuId &&
+ fPadBuffer->GetManuChannel() == manuChannel ) return (*fPadBuffer);
AliMpMotifPosition* motifPos =
- fkSector->GetMotifMap()->FindMotifPosition(location.GetFirst());
+ fkSector->GetMotifMap()->FindMotifPosition(manuId);
if (!motifPos){
if (warning) Warning("PadByLocation","The pad motif position ID doesn't exists");
return AliMpPad::Invalid();
}
AliMpVMotif* motif = motifPos->GetMotif();
- AliMpIntPair localIndices =
- motif->GetMotifType()->FindLocalIndicesByGassiNum(location.GetSecond());
- if (! localIndices.IsValid()) {
+ MpPair_t localIndices =
+ motif->GetMotifType()->FindLocalIndicesByGassiNum(manuChannel);
+ if ( localIndices < 0 ) {
if (warning) Warning("PadByLocation","The pad number doesn't exists");
return AliMpPad::Invalid();
}
- TVector2 delta = motif->PadPositionLocal(localIndices);
- return (*fPadBuffer) = AliMpPad(location,
- motifPos->GlobalIndices(localIndices),
- motifPos->Position()+delta,
- motif->GetPadDimensions(localIndices));
+ Double_t posx, posy;
+ motif->PadPositionLocal(localIndices, posx, posy);
+ posx += motifPos->GetPositionX();
+ posy += motifPos->GetPositionY();
+
+ Double_t dx, dy;
+ motif->GetPadDimensionsByIndices(localIndices, dx, dy);
+
+ return (*fPadBuffer) = AliMpPad(manuId, manuChannel,
+ motifPos->GlobalIndices(localIndices),
+ posx, posy, dx, dy);
}
//______________________________________________________________________________
AliMpPad
-AliMpSectorSegmentation::PadByIndices(const AliMpIntPair& indices,
- Bool_t warning ) const
+AliMpSectorSegmentation::PadByIndices(Int_t ix, Int_t iy, Bool_t warning ) const
{
-// Find the pad which corresponds to the given indices
+/// Find the pad which corresponds to the given indices
- if ((*fPadBuffer).GetIndices()==indices) return (*fPadBuffer);
-
- AliMpMotifPosition* motifPos = FindMotifPosition(indices);
+ if ( fPadBuffer->GetIx() == ix &&
+ fPadBuffer->GetIy() == iy ) return (*fPadBuffer);
+
+ MpPair_t indices = AliMp::Pair(ix, iy);
+ AliMpMotifPosition* motifPos = FindMotifPosition(ix, iy);
if (!motifPos) {
- if (warning) Warning("PadByIndices","Pad indices not contained in any motif!");
+ if (warning)
+ Warning("PadByIndices","Pad indices not contained in any motif!");
return AliMpPad::Invalid();
}
// retrieve the local indices in the found motif
AliMpVMotif* motif = motifPos->GetMotif();
- AliMpIntPair localIndices = indices - motifPos->GetLowIndicesLimit();
+ MpPair_t localIndices = indices - motifPos->GetLowIndicesLimit();
AliMpConnection* connection=
motif->GetMotifType()->FindConnectionByLocalIndices(localIndices);
return AliMpPad::Invalid();
}
- TVector2 localPos = motif->PadPositionLocal(localIndices);
+ Double_t posx, posy;
+ motif->PadPositionLocal(localIndices, posx, posy);
+ posx += motifPos->GetPositionX();
+ posy += motifPos->GetPositionY();
- return (*fPadBuffer)
- = AliMpPad(AliMpIntPair(motifPos->GetID(),connection->GetGassiNum()),
- indices,
- motifPos->Position()+localPos,
- motif->GetPadDimensions(localIndices));
+ Double_t dx, dy;
+ motif->GetPadDimensionsByIndices(localIndices, dx, dy);
+ return (*fPadBuffer)
+ = AliMpPad(motifPos->GetID(),connection->GetManuChannel(),
+ ix, iy, posx, posy, dx, dy);
}
+
//______________________________________________________________________________
AliMpPad
-AliMpSectorSegmentation::PadByPosition(const TVector2& position,
+AliMpSectorSegmentation::PadByPosition(Double_t x, Double_t y,
Bool_t warning) const
{
-// Find the pad which corresponds to the given position
+/// Find the pad which corresponds to the given position
- if ((*fPadBuffer).Position().X()==position.X() &&
- (*fPadBuffer).Position().Y()==position.Y()) return (*fPadBuffer);
+ if (fPadBuffer->GetPositionX()==x &&
+ fPadBuffer->GetPositionY()==y) return (*fPadBuffer);
- Int_t motifPosID = fkSector->FindMotifPositionId(position);
+ Int_t motifPosID = fkSector->FindMotifPositionId(x,y);
AliMpMotifPosition* motifPos
= fkSector->GetMotifMap()
->FindMotifPosition(motifPosID);
}
AliMpVMotif* motif = motifPos->GetMotif();
- AliMpIntPair localIndices
- = motif->PadIndicesLocal(position-motifPos->Position());
+ MpPair_t localIndices
+ = motif->PadIndicesLocal(x-motifPos->GetPositionX(),
+ y-motifPos->GetPositionY());
+
+ if ( localIndices < 0 ) {
+ if (warning) Warning("PadByPosition","Position outside motif limits");
+ return AliMpPad::Invalid();
+ }
AliMpConnection* connect =
motif->GetMotifType()->FindConnectionByLocalIndices(localIndices);
- if (!connect){
+ if ( ! connect ) {
if (warning) Warning("PadByPosition","Position outside motif limits");
return AliMpPad::Invalid();
}
+
+ Double_t posx, posy;
+ motif->PadPositionLocal(localIndices, posx, posy);
+ posx += motifPos->GetPositionX();
+ posy += motifPos->GetPositionY();
+
+ Double_t dx, dy;
+ motif->GetPadDimensionsByIndices(localIndices, dx, dy);
return (*fPadBuffer)
- = AliMpPad(AliMpIntPair(motifPosID,connect->GetGassiNum()),
+ = AliMpPad(motifPosID, connect->GetManuChannel(),
motifPos->GlobalIndices(localIndices),
- motifPos->Position()+motif->PadPositionLocal(localIndices),
- motif->GetPadDimensions(localIndices));
-
+ posx, posy, dx, dy);
}
//______________________________________________________________________________
AliMpPad
-AliMpSectorSegmentation::PadByDirection(const TVector2& startPosition,
+AliMpSectorSegmentation::PadByDirection(Double_t startx, Double_t starty,
Double_t distance) const
{
-// Find the first valid pad from starting position in the
-// direction of pad lines/columns up to the specified distance.
-// Pad lines are the lines of pads in the sector with constant pad y size,
-// pad columns are the columns of pads in the sector with constant pad x size.
-// ---
+/// Find the first valid pad from starting position in the
+/// direction of pad lines/columns up to the specified distance.
+/// Pad lines are the lines of pads in the sector with constant pad y size,
+/// pad columns are the columns of pads in the sector with constant pad x size.
switch (fkSector->GetDirection()) {
- case kX: return PadByYDirection(startPosition, distance);
+ case AliMp::kX: return PadByYDirection(startx, starty, distance);
;;
- case kY: return PadByXDirection(startPosition, distance);
+ case AliMp::kY: return PadByXDirection(startx, starty, distance);
;;
}
return AliMpPad::Invalid();
}
+//_____________________________________________________________________________
+Bool_t
+AliMpSectorSegmentation::HasPadByIndices(Int_t ix, Int_t iy) const
+{
+ /// Whether or not we have a pad at indices=(ix,iy)
+
+ MpPair_t indices = AliMp::Pair(ix, iy);
+
+ AliMpMotifPosition* motifPos = FindMotifPosition(ix, iy);
+
+ if (motifPos) return motifPos->HasPadByIndices(indices);
+
+ return kFALSE;
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMpSectorSegmentation::HasPadByLocation(Int_t manuId, Int_t manuChannel) const
+{
+ /// Whether or not we have a pad at location=(manuId,manuChannel)
+
+ AliMpMotifPosition* motifPos
+ = fkSector->GetMotifMap()->FindMotifPosition(manuId);
+
+ if ( motifPos ) return motifPos->HasPadByManuChannel(manuChannel);
+
+ return kFALSE;
+}
+
//______________________________________________________________________________
-Bool_t AliMpSectorSegmentation::HasPad(const AliMpIntPair& indices) const
+Int_t AliMpSectorSegmentation::MaxPadIndexX() const
{
-// Does the pad specified by <indices> exist ?
-// ---
+/// Return maximum pad index in x
- return PadByIndices(indices,kFALSE) != AliMpPad::Invalid();
+ return AliMp::PairFirst(fkSector->GetMaxPadIndices());
}
//______________________________________________________________________________
-Bool_t AliMpSectorSegmentation::HasMotifPosition(Int_t motifPositionID) const
+Int_t AliMpSectorSegmentation::MaxPadIndexY() const
{
-// Does the motif position specified by motifPositionID exist ?
-// ---
+/// Return maximum pad index in y
- return (fkSector->GetMotifMap()->FindMotifPosition(motifPositionID) != 0);
+ return AliMp::PairSecond(fkSector->GetMaxPadIndices());
}
//______________________________________________________________________________
-TVector2 AliMpSectorSegmentation::GetMinPadDimensions() const
+Int_t AliMpSectorSegmentation::NofPads() const
{
-// Returnes the dimensions of the smallest pad.
-// ---
+/// Return number of pads defined in the sector
- return fkSector->GetMinPadDimensions();
-}
+ return fkSector->GetNofPads();
+}
+
+//_____________________________________________________________________________
+void
+AliMpSectorSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
+{
+ /// Fill the array ecn with all manuIds
+
+ GetSector()->GetAllMotifPositionsIDs(ecn);
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMpSectorSegmentation::GetNofElectronicCards() const
+{
+ /// Get the number of manus of this sector
+
+ return fkSector->GetNofMotifPositions();
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMpSectorSegmentation::HasMotifPosition(Int_t manuId) const
+{
+ /// Whether we get a given manu. Uses default implementation
+ return (AliMpVSegmentation::HasMotifPosition(manuId) != 0x0);
+}
+
+//_____________________________________________________________________________
+AliMpMotifPosition*
+AliMpSectorSegmentation::MotifPosition(Int_t manuId) const
+{
+ /// Return a given manu
+ return fkSector->GetMotifMap()->FindMotifPosition(manuId);
+}
//______________________________________________________________________________
-Int_t AliMpSectorSegmentation::Zone(const AliMpPad& pad, Bool_t warning) const
+AliMp::PlaneType
+AliMpSectorSegmentation::PlaneType() const
{
-// Returns the zone index of the zone containing the specified pad.
-// This zone index is different from the zone ID,
-// as it is unique for each pad dimensions.
-// It is composed in this way:
-// zoneID*10 + specific index
-// Specific index is present only for zones containing special motifs.
-// ---
-
- if (!pad.IsValid()) {
- if (warning) Warning("Zone(AliMpPad)", "Invalid pad");
- return 0;
- }
-
-#ifdef WITH_STL
- PadDimensionsMapCIterator it;
- for (it = fPadDimensionsMap.begin(); it != fPadDimensionsMap.end(); ++it) {
- if (AliMpConstants::IsEqual(it->second, pad.Dimensions()))
- return it->first;
- }
-#endif
-
-#ifdef WITH_ROOT
- PadDimensionsMapCIterator it(&fPadDimensionsMap);
- Long_t key, value;
- while ( it.Next(key, value) ) {
- TVector2 dimensions = GetVector(value);
- if (AliMpConstants::IsEqual(dimensions, pad.Dimensions()))
- return (Int_t)key;
- }
- return 0;
-
-#endif
-
- // Should never happen
- Fatal("Zone(AliMpPad)", "not found");
- return 0;
-}
+ return GetSector()->GetPlaneType();
+}
+
+//_____________________________________________________________________________
+Double_t
+AliMpSectorSegmentation::GetDimensionX() const
+{
+/// Return sector x dimensions
+ return GetSector()->GetDimensionX();
+}
+
+//_____________________________________________________________________________
+Double_t
+AliMpSectorSegmentation::GetDimensionY() const
+{
+/// Return sector y dimensions
+ return GetSector()->GetDimensionY();
+}
+
+//_____________________________________________________________________________
+Double_t
+AliMpSectorSegmentation::GetPositionX() const
+{
+/// Return x position
+ return 0.;
+}
+
+//_____________________________________________________________________________
+Double_t
+AliMpSectorSegmentation::GetPositionY() const
+{
+/// Return y position
+ return 0.;
+}
+
+//______________________________________________________________________________
+void
+AliMpSectorSegmentation::Print(Option_t* opt) const
+{
+/// Print the sector
+
+ fkSector->Print(opt);
+}
//______________________________________________________________________________
-TVector2
-AliMpSectorSegmentation::PadDimensions(Int_t zone, Bool_t warning) const
+Double_t AliMpSectorSegmentation::GetMinPadDimensionX() const
{
-// Returns the pad dimensions for the zone with the specified zone index.
-// ---
+/// Return the x dimension of the smallest pad.
+
+ return fkSector->GetMinPadDimensionX();
+}
-#ifdef WITH_STL
- PadDimensionsMapCIterator it = fPadDimensionsMap.find(zone);
- if (it != fPadDimensionsMap.end()) return it->second;
-#endif
-#ifdef WITH_ROOT
- Long_t value = fPadDimensionsMap.GetValue(zone);
- if (value) return GetVector(value);
-#endif
+//______________________________________________________________________________
+Double_t AliMpSectorSegmentation::GetMinPadDimensionY() const
+{
+/// Return the y dimension of the smallest pad.
- if (warning) Warning("PadDimensions(zone)", "not found");
- return TVector2();
+ return fkSector->GetMinPadDimensionY();
}
+
//______________________________________________________________________________
-Bool_t AliMpSectorSegmentation::CircleTest(const AliMpIntPair& indices) const
+Bool_t AliMpSectorSegmentation::CircleTest(Int_t ix, Int_t iy) const
{
-// Verifies that all methods for retrieving pads are consistents between them.
-// Returns true if the pad with specified indices was found and verified,
-// false otherwise.
-// ---
+/// Verify that all methods for retrieving pads are consistents between them.
+/// Return true if the pad with specified indices was found and verified,
+/// false otherwise.
- if (!HasPad(indices)) return false;
+ if ( ! HasPadByIndices(ix, iy) ) return false;
// Verify the indice->location->position->indice way
- AliMpIntPair location = PadByIndices(indices).GetLocation();
- TVector2 position = PadByLocation(location).Position();
- AliMpIntPair retIndices = PadByPosition(position).GetIndices();
+ AliMpPad pad1 = PadByIndices(ix, iy);
+ AliMpPad pad2 = PadByLocation(pad1.GetManuId(), pad1.GetManuChannel());
+ AliMpPad pad3 = PadByPosition(pad2.GetPositionX(),pad2.GetPositionY());
+
+ MpPair_t retIndices = pad3.GetIndices();
- if (retIndices != indices) {
- cout << "Pad " << indices << " lead to inconsistency" << endl;
+ if ( retIndices != AliMp::Pair(ix, iy) ) {
+ cout << "Pad (" << ix << ',' << iy << ") lead to inconsistency" << endl;
cout << "in indice->location->position->indice way..." << endl;
- cout << "starting from " << indices << "-->" << location << "-->"
- << '(' << position.X() << ',' << position.Y() << ')'
- << " and retIndices: " << retIndices << endl;
+ cout << "starting from indices " << pad1 << endl
+ << "--> location " << pad2 << endl
+ << "--> position "
+ << '(' << pad3.GetPositionX() << ',' << pad3.GetPositionY() << ')'
+ << endl << endl;
}
-
- // Verify the indice->position->location->indice way
- position = PadByIndices(indices).Position();
- location = PadByPosition(position).GetLocation();
- retIndices = PadByLocation(location).GetIndices();
-
- if (retIndices != indices) {
- cout << "Pad " << indices << " lead to inconsistency" << endl;
- cout << "in indice->position->location->indice way..." <<endl;
- cout << "starting from " << indices
- << " and retIndices: " << retIndices << endl;
+ // Verify the indice->position->location->indice way
+ AliMpPad pad2bis = PadByPosition(pad1.GetPositionX(),pad1.GetPositionY());
+ AliMpPad pad3bis = PadByLocation(pad2bis.GetManuId(), pad2bis.GetManuChannel());
+
+ retIndices = pad3bis.GetIndices();
+
+ if ( retIndices != AliMp::Pair(ix, iy) ) {
+ cout << "Pad (" << ix << ',' << iy << ") lead to inconsistency" << endl;
+ cout << "in indice->position->location->indice way..." << endl;
+ cout << "starting from indices " << pad1 << endl
+ << "--> position "
+ << '(' << pad2bis.GetPositionX() << ',' << pad2bis.GetPositionY() << ')' << endl
+ << "--> location " << pad3bis
+ << endl << endl;
}
return true;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff