/************************************************************************** * 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: AliMpSlatSegmentation.cxx,v 1.12 2006/05/24 13:58:50 ivana Exp $ //----------------------------------------------------------------------------- // Caution !! // Implementation note. // The position(s) used in the interface are supposed to be relative // to the slat center (AliMpSlat::Position()), whereas internally // the x,y are relative to bottom-left corner. //----------------------------------------------------------------------------- #include "AliMpSlatSegmentation.h" #include "AliLog.h" #include "AliMpArea.h" #include "AliMpConnection.h" #include "AliMpConstants.h" #include "AliLog.h" #include "AliMpMotif.h" #include "AliMpMotifPosition.h" #include "AliMpMotifType.h" #include "AliMpSlat.h" #include "AliMpSlatPadIterator.h" #include "AliMpEncodePair.h" /// \cond CLASSIMP ClassImp(AliMpSlatSegmentation) /// \endcond //_____________________________________________________________________________ AliMpSlatSegmentation::AliMpSlatSegmentation() : AliMpVSegmentation(), fkSlat(0), fIsOwner(false) { /// /// Default ctor. Not to be used really. /// AliDebug(1,Form("this=%p Empty ctor",this)); } //_____________________________________________________________________________ AliMpSlatSegmentation::AliMpSlatSegmentation(const AliMpSlat* slat, Bool_t own) : AliMpVSegmentation(), fkSlat(slat), fIsOwner(own) { /// /// Normal ctor. /// AliDebug(1,Form("this=%p Normal ctor slat=%p",this,slat)); } //_____________________________________________________________________________ AliMpSlatSegmentation::~AliMpSlatSegmentation() { /// /// Dtor (empty). /// if ( fIsOwner ) delete fkSlat; // Int_t i(0);//just to be able to put a breakpoint in gdb AliDebug(1,Form("this=%p",this)); } //_____________________________________________________________________________ AliMpVPadIterator* AliMpSlatSegmentation::CreateIterator(const AliMpArea& area) const { /// /// Returns an iterator to loop over the pad contained within given area. /// AliMpArea a(area.GetPositionX()+fkSlat->GetPositionX(), area.GetPositionY()+fkSlat->GetPositionY(), area.GetDimensionX(), area.GetDimensionY()); AliDebug(3,Form("Converted input area wrt to slat center : " "%7.2f,%7.2f->%7.2f,%7.2f to wrt slat lower-left : " "%7.2f,%7.2f->%7.2f,%7.2f ", area.LeftBorder(),area.DownBorder(), area.RightBorder(),area.UpBorder(), a.LeftBorder(),a.DownBorder(), a.RightBorder(),a.UpBorder())); return new AliMpSlatPadIterator(fkSlat,a); } //_____________________________________________________________________________ AliMpVPadIterator* AliMpSlatSegmentation::CreateIterator() const { /// Returns an iterator to loop over all pads of that segmentation /// /// FIXME: we currently just forward this to the other CreateIterator, /// with the proper region. Might be more efficient to write a dedicated /// iterator ? Test that idea. AliMpArea area(0.0,0.0,fkSlat->DX(),fkSlat->DY()); return CreateIterator(area); } //_____________________________________________________________________________ Int_t AliMpSlatSegmentation::GetNeighbours(const AliMpPad& pad, TObjArray& neighbours, Bool_t includeSelf, Bool_t includeVoid) const { /// Uses default implementation return AliMpVSegmentation::GetNeighbours(pad,neighbours,includeSelf,includeVoid); } //_____________________________________________________________________________ Double_t AliMpSlatSegmentation::GetDimensionX() const { /// Return slat x dimensions return Slat()->DX(); } //_____________________________________________________________________________ Double_t AliMpSlatSegmentation::GetDimensionY() const { /// Return slat y dimensions return Slat()->DY(); } //_____________________________________________________________________________ void AliMpSlatSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const { /// Fill the array ecn with all manuIds Slat()->GetAllMotifPositionsIDs(ecn); } //_____________________________________________________________________________ const char* AliMpSlatSegmentation::GetName() const { /// The name of this segmentation is "SlatSegmentation"+slatName TString name("SlatSegmentation"); if ( fkSlat) { name += "."; name += fkSlat->GetName(); } return name.Data(); } //_____________________________________________________________________________ Int_t AliMpSlatSegmentation::MaxPadIndexX() const { /// /// Returns the value of the largest pad index in x-direction. /// return fkSlat->GetMaxPadIndexX(); } //_____________________________________________________________________________ Int_t AliMpSlatSegmentation::MaxPadIndexY() const { /// /// Returns the value of the largest pad index in y-direction. /// return fkSlat->GetMaxNofPadsY()-1; } //_____________________________________________________________________________ Int_t AliMpSlatSegmentation::NofPads() const { /// Return number of pads defined in the slat return fkSlat->NofPads(); } //_____________________________________________________________________________ AliMpPad AliMpSlatSegmentation::PadByLocation(Int_t manuId, Int_t manuChannel, Bool_t warning) const { /// /// Returns the pad specified by its location, where location is the /// pair (ManuID,ManuChannel). /// If warning=kTRUE and the pad does not exist, a warning message is /// printed. /// /// AliMpPad::Invalid() is returned if there's no pad at the given location. /// AliMpMotifPosition* motifPos = fkSlat->FindMotifPosition(manuId); if (!motifPos) { if (warning) { AliWarning(Form("Manu ID %d not found in slat %s", manuId, fkSlat->GetID())); } return AliMpPad::Invalid(); } AliMpVMotif* motif = motifPos->GetMotif(); MpPair_t localIndices = motif->GetMotifType()->FindLocalIndicesByGassiNum(manuChannel); if ( localIndices < 0 ) { if (warning) { AliWarning(Form("The pad number %d doesn't exists", manuChannel)); } return AliMpPad::Invalid(); } Double_t posx, posy; motif->PadPositionLocal(localIndices, posx, posy); posx += motifPos->GetPositionX() - fkSlat->GetPositionX(); posy += motifPos->GetPositionY() - fkSlat->GetPositionY(); Double_t dx, dy; motif->GetPadDimensionsByIndices(localIndices, dx, dy); return AliMpPad(manuId, manuChannel, motifPos->GlobalIndices(localIndices), posx, posy, dx, dy); } //_____________________________________________________________________________ AliMpPad AliMpSlatSegmentation::PadByIndices(Int_t ix, Int_t iy, Bool_t warning) const { /// /// Returns the pad specified by its integer indices. /// If warning=kTRUE and the pad does not exist, a warning message is /// printed. /// /// AliMpPad::Invalid() is returned if there's no pad at the given location. /// /// /// FIXME: except for the FindMotifPosition below, this method /// is exactly as the one in AliMpSectorSegmentation. /// See if we can merge them somehow. AliMpMotifPosition* motifPos = fkSlat->FindMotifPosition(ix,iy); if (!motifPos) { if ( warning ) { AliWarning(Form("No motif found containing pad location (%d,%d)",ix,iy)); } return AliMpPad::Invalid(); } AliMpVMotif* motif = motifPos->GetMotif(); AliMpMotifType* motifType = motif->GetMotifType(); MpPair_t localIndices = AliMp::Pair(ix,iy) - motifPos->GetLowIndicesLimit(); AliMpConnection* connection = motifType->FindConnectionByLocalIndices(localIndices); if (!connection) { if ( warning ) { AliWarning(Form("No connection for pad location (%d,%d)",ix,iy)); } return AliMpPad::Invalid(); } Double_t posx, posy; motif->PadPositionLocal(localIndices, posx, posy); posx += motifPos->GetPositionX() - fkSlat->GetPositionX(); posy += motifPos->GetPositionY() - fkSlat->GetPositionY(); Double_t dx, dy; motif->GetPadDimensionsByIndices(localIndices, dx, dy); return AliMpPad(motifPos->GetID(),connection->GetManuChannel(), ix, iy, posx, posy, dx, dy); } //_____________________________________________________________________________ AliMpPad AliMpSlatSegmentation::PadByPosition(Double_t x, Double_t y, Bool_t warning) const { /// /// Returns the pad specified by its (floating point) position. /// If warning=kTRUE and the pad does not exist, a warning message is /// printed. /// /// AliMpPad::Invalid() is returned if there's no pad at the given location. /// Double_t blPosX(x); Double_t blPosY(y); blPosX += fkSlat->GetPositionX(); blPosY += fkSlat->GetPositionY(); // position relative to bottom-left of the slat. AliMpMotifPosition* motifPos = fkSlat->FindMotifPosition(blPosX,blPosY); if (!motifPos) { if (warning) { AliWarning(Form("Slat %s Position (%e,%e)/center (%e,%e)/bottom-left cm " " outside limits",fkSlat->GetID(),x,y, blPosX,blPosY)); } return AliMpPad::Invalid(); } AliMpVMotif* motif = motifPos->GetMotif(); blPosX -= motifPos->GetPositionX(); blPosY -= motifPos->GetPositionY(); MpPair_t localIndices = motif->PadIndicesLocal(blPosX, blPosY); AliMpConnection* connect = motif->GetMotifType()->FindConnectionByLocalIndices(localIndices); if (!connect) { if (warning) { AliWarning(Form("Slat %s localIndices (%d,%d) outside motif %s limits", fkSlat->GetID(),AliMp::PairFirst(localIndices), AliMp::PairSecond(localIndices),motif->GetID().Data())); } return AliMpPad::Invalid(); } Double_t posx, posy; motif->PadPositionLocal(localIndices, posx, posy); posx += motifPos->GetPositionX() - fkSlat->GetPositionX(); posy += motifPos->GetPositionY() - fkSlat->GetPositionY(); Double_t dx, dy; motif->GetPadDimensionsByIndices(localIndices, dx, dy); return AliMpPad(motifPos->GetID(),connect->GetManuChannel(), motifPos->GlobalIndices(localIndices), posx, posy, dx, dy); } //_____________________________________________________________________________ AliMp::PlaneType AliMpSlatSegmentation::PlaneType() const { return Slat()->PlaneType(); } //_____________________________________________________________________________ void AliMpSlatSegmentation::Print(Option_t* opt) const { /// Printing fkSlat->Print(opt); } //_____________________________________________________________________________ const AliMpSlat* AliMpSlatSegmentation::Slat() const { /// /// Returns the pointer to the referenced slat. /// return fkSlat; } //_____________________________________________________________________________ Bool_t AliMpSlatSegmentation::HasPadByIndices(Int_t ix, Int_t iy) const { /// Tell whether we have a pad at indices=(ix,iy) AliMpMotifPosition* motifPos = Slat()->FindMotifPosition(ix, iy); if (motifPos) return motifPos->HasPadByIndices(AliMp::Pair(ix, iy)); return kFALSE; } //_____________________________________________________________________________ Bool_t AliMpSlatSegmentation::HasPadByLocation(Int_t manuId, Int_t manuChannel) const { /// Tell whether we have a pad at location=(manuId,manuChannel) AliMpMotifPosition* motifPos = Slat()->FindMotifPosition(manuId); if ( motifPos ) return motifPos->HasPadByManuChannel(manuChannel); return kFALSE; } //_____________________________________________________________________________ Int_t AliMpSlatSegmentation::GetNofElectronicCards() const { /// Get the number of manus of this slat return Slat()->GetNofElectronicCards(); } //_____________________________________________________________________________ Double_t AliMpSlatSegmentation::GetPositionX() const { /// Return x position of slat origin return Slat()->GetPositionX(); } //_____________________________________________________________________________ Double_t AliMpSlatSegmentation::GetPositionY() const { /// Return y position of slat origin return Slat()->GetPositionY(); } //_____________________________________________________________________________ Bool_t AliMpSlatSegmentation::HasMotifPosition(Int_t manuId) const { /// Use default implementation return AliMpVSegmentation::HasMotifPosition(manuId); } //_____________________________________________________________________________ AliMpMotifPosition* AliMpSlatSegmentation::MotifPosition(Int_t manuId) const { /// Get back a given manu return Slat()->FindMotifPosition(manuId); }