+++ /dev/null
-/**************************************************************************
- * 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.
-// Provides methods related to pads:
-// conversion between pad indices, pad location, pad position;
-// finding pad neighbour.
-//
-// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
-//-----------------------------------------------------------------------------
-
-#include "AliMpSectorSegmentation.h"
-#include "AliMpSector.h"
-#include "AliMpZone.h"
-#include "AliMpSubZone.h"
-#include "AliMpRow.h"
-#include "AliMpVRowSegment.h"
-#include "AliMpMotifMap.h"
-#include "AliMpVMotif.h"
-#include "AliMpMotifPosition.h"
-#include "AliMpConnection.h"
-#include "AliMpSectorAreaHPadIterator.h"
-#include "AliMpSectorAreaVPadIterator.h"
-#include "AliMpSectorPadIterator.h"
-#include "AliMpArea.h"
-#include "AliMpConstants.h"
-#include "AliMpEncodePair.h"
-
-#include "AliLog.h"
-
-#include <Riostream.h>
-#include <TMath.h>
-
-using std::cout;
-using std::endl;
-/// \cond CLASSIMP
-ClassImp(AliMpSectorSegmentation)
-/// \endcond
-
-//______________________________________________________________________________
-AliMpSectorSegmentation::AliMpSectorSegmentation(
- const AliMpSector* sector, Bool_t own)
- : AliMpVSegmentation(),
- fkSector(sector),
- fIsOwner(own),
- fPadBuffer(0),
- fMaxIndexInX(0),
- fMaxIndexInY(0)
-{
-/// Standard constructor
-
- AliDebugStream(1) << "this = " << this << endl;
-
- fPadBuffer = new AliMpPad(AliMpPad::Invalid());
-
- //FillPadDimensionsMap();
-}
-
-//______________________________________________________________________________
-AliMpSectorSegmentation::AliMpSectorSegmentation()
- : AliMpVSegmentation(),
- fkSector(0),
- fIsOwner(false),
- fPadBuffer(0),
- fMaxIndexInX(0),
- fMaxIndexInY(0)
-{
-/// Default constructor
-
- AliDebugStream(1) << "this = " << this << endl;
-}
-
-//______________________________________________________________________________
-AliMpSectorSegmentation::~AliMpSectorSegmentation()
-{
-/// Destructor
-
- AliDebugStream(1) << "this = " << this << endl;
-
- if ( fIsOwner ) delete fkSector;
-
- delete fPadBuffer;
-
-}
-
-//
-// private methods
-//
-
-//______________________________________________________________________________
-AliMpMotifPosition*
-AliMpSectorSegmentation::FindMotifPosition(Int_t ix, Int_t iy) const
-{
-/// Find the motif position which contains the given pad indices
-/// return 0 if not found
-
- 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 ) {
- AliMpRow* row = fkSector->GetRow(irow);
- if ( row->GetLowLimitIx() <= ix &&
- row->GetHighLimitIx()>= ix ) {
-
- for ( Int_t iseg=0;iseg<row->GetNofRowSegments();++iseg ) {
- AliMpVRowSegment* seg = row->GetRowSegment(iseg);
- if ( seg->GetLowLimitIx() <= ix &&
- seg->GetHighLimitIx() >= ix ) {
-
- AliMpMotifPosition* motifPos;
- for ( Int_t imot=0;imot<seg->GetNofMotifs();++imot ) {
- motifPos
- = fkSector->GetMotifMap()
- ->FindMotifPosition(seg->GetMotifPositionId(imot));
- if (motifPos && motifPos->HasPadByIndices(AliMp::Pair(ix,iy))) return motifPos;
- }
- }
- }
- }
- }
- return 0;
- }
- break;
- ////////////////////////////////////////////////////////////////////////////////
- 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 ) {
- row = fkSector->GetRow(irow);
- AliMpVRowSegment* lastSeg = row->GetRowSegment(row->GetNofRowSegments()-1);
- 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;
- // 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 ) {
- seg = row->GetRowSegment(iseg);
- if (seg->HasIndices(AliMp::Pair(ix, iy))) break;
- }
- 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 ) {
- motifPos
- = fkSector->GetMotifMap()
- ->FindMotifPosition(seg->GetMotifPositionId(imot));
- if (motifPos && motifPos->HasPadByIndices(AliMp::Pair(ix, iy))) break;
- }
- if (imot==seg->GetNofMotifs()) return 0;
-
- return motifPos;
- }
- default: return 0;
- }
-}
-
-//______________________________________________________________________________
-AliMpPad
-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.
-
- // Define step limits
- Double_t stepX = fkSector->GetMinPadDimensionX();
-
- // Search in X direction
- AliMpPad pad;
- Double_t posx = startx;
- do {
- pad = PadByPosition(posx, starty, false);
- posx += stepX;
- }
- while ( ! pad.IsValid() &&
- posx - fkSector->GetMaxPadDimensionX() < maxX );
-
- // Invalidate pad if it is outside limits
- if ( ( pad.GetPositionX() - pad.GetDimensionX()) > maxX )
- pad = AliMpPad::Invalid();
-
- return pad;
-}
-
-//______________________________________________________________________________
-AliMpPad
-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.
-
- // Define step limits
- Double_t stepY = fkSector->GetMinPadDimensionY();
-
- // Search in Y direction
- AliMpPad pad;
- Double_t posy = starty;
- do {
- pad = PadByPosition(startx, posy, false);
- posy += stepY;
- }
- while ( ! pad.IsValid() &&
- posy - fkSector->GetMaxPadDimensionY()< maxY );
-
- // Invalidate pad if it is outside limits
- if (( pad.GetPositionY() - pad.GetDimensionY()) > maxY )
- pad = AliMpPad::Invalid();
-
- return pad;
-}
-
-//
-// public methods
-//
-
-//______________________________________________________________________________
-AliMpVPadIterator*
-AliMpSectorSegmentation::CreateIterator(const AliMpArea& area) const
-{
-/// Create the area iterator.
-
- switch (fkSector->GetDirection()) {
-
- case AliMp::kX: return new AliMpSectorAreaVPadIterator(this, area);
- ;;
- case AliMp::kY: return new AliMpSectorAreaHPadIterator(this, area);
- ;;
- }
-
- Fatal("CreateIterator", "Incomplete switch on Sector direction");
- return 0;
-}
-
-//______________________________________________________________________________
-AliMpVPadIterator*
-AliMpSectorSegmentation::CreateIterator() const
-{
-/// 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);
-}
-
-//______________________________________________________________________________
-AliMpPad
-AliMpSectorSegmentation::PadByLocation(Int_t manuId, Int_t manuChannel,
- Bool_t warning) const
-{
-/// Find the pad which corresponds to the given location
-
- if ( fPadBuffer->GetManuId() == manuId &&
- fPadBuffer->GetManuChannel() == manuChannel ) return (*fPadBuffer);
-
- AliMpMotifPosition* motifPos =
- 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();
- MpPair_t localIndices =
- motif->GetMotifType()->FindLocalIndicesByGassiNum(manuChannel);
- if ( localIndices < 0 ) {
- if (warning) Warning("PadByLocation","The pad number doesn't exists");
- 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(manuId, manuChannel,
- motifPos->GlobalIndices(localIndices),
- posx, posy, dx, dy);
-}
-//______________________________________________________________________________
-AliMpPad
-AliMpSectorSegmentation::PadByIndices(Int_t ix, Int_t iy, Bool_t warning ) const
-{
-/// Find the pad which corresponds to the given 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!");
- return AliMpPad::Invalid();
- }
-
- // retrieve the local indices in the found motif
- AliMpVMotif* motif = motifPos->GetMotif();
- MpPair_t localIndices = indices - motifPos->GetLowIndicesLimit();
-
- AliMpConnection* connection=
- motif->GetMotifType()->FindConnectionByLocalIndices(localIndices);
-
- if (!connection){
- if (warning) Warning("PadByIndices","No connection with the given indices!");
- 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(motifPos->GetID(),connection->GetManuChannel(),
- ix, iy, posx, posy, dx, dy);
-}
-
-//______________________________________________________________________________
-AliMpPad
-AliMpSectorSegmentation::PadByPosition(Double_t x, Double_t y,
- Bool_t warning) const
-{
-/// Find the pad which corresponds to the given position
-
- if (fPadBuffer->GetPositionX()==x &&
- fPadBuffer->GetPositionY()==y) return (*fPadBuffer);
-
- Int_t motifPosID = fkSector->FindMotifPositionId(x,y);
- AliMpMotifPosition* motifPos
- = fkSector->GetMotifMap()
- ->FindMotifPosition(motifPosID);
-
- if (!motifPos){
- if (warning) Warning("PadByPosition","Position outside limits");
- return AliMpPad::Invalid();
- }
-
- AliMpVMotif* motif = motifPos->GetMotif();
- 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 (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(motifPosID, connect->GetManuChannel(),
- motifPos->GlobalIndices(localIndices),
- posx, posy, dx, dy);
-}
-
-//______________________________________________________________________________
-AliMpPad
-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.
-
- switch (fkSector->GetDirection()) {
-
- case AliMp::kX: return PadByYDirection(startx, starty, distance);
- ;;
- case AliMp::kY: return PadByXDirection(startx, starty, distance);
- ;;
- }
-
- Fatal("PadByDirection", "Incomplete switch on Sector direction");
- 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;
-}
-
-//______________________________________________________________________________
-Int_t AliMpSectorSegmentation::MaxPadIndexX() const
-{
-/// Return maximum pad index in x
-
- return AliMp::PairFirst(fkSector->GetMaxPadIndices());
-}
-
-//______________________________________________________________________________
-Int_t AliMpSectorSegmentation::MaxPadIndexY() const
-{
-/// Return maximum pad index in y
-
- return AliMp::PairSecond(fkSector->GetMaxPadIndices());
-}
-
-//______________________________________________________________________________
-Int_t AliMpSectorSegmentation::NofPads() const
-{
-/// Return number of pads defined in the sector
-
- 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);
-}
-
-//______________________________________________________________________________
-AliMp::PlaneType
-AliMpSectorSegmentation::PlaneType() const
-{
- 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);
-}
-
-//______________________________________________________________________________
-Double_t AliMpSectorSegmentation::GetMinPadDimensionX() const
-{
-/// Return the x dimension of the smallest pad.
-
- return fkSector->GetMinPadDimensionX();
-}
-
-
-//______________________________________________________________________________
-Double_t AliMpSectorSegmentation::GetMinPadDimensionY() const
-{
-/// Return the y dimension of the smallest pad.
-
- return fkSector->GetMinPadDimensionY();
-}
-
-
-//______________________________________________________________________________
-Bool_t AliMpSectorSegmentation::CircleTest(Int_t ix, Int_t iy) const
-{
-/// 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 ( ! HasPadByIndices(ix, iy) ) return false;
-
- // Verify the indice->location->position->indice way
- 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 != AliMp::Pair(ix, iy) ) {
- cout << "Pad (" << ix << ',' << iy << ") lead to inconsistency" << endl;
- cout << "in indice->location->position->indice way..." << endl;
- cout << "starting from indices " << pad1 << endl
- << "--> location " << pad2 << endl
- << "--> position "
- << '(' << pad3.GetPositionX() << ',' << pad3.GetPositionY() << ')'
- << endl << 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