MUON/mapping/AliMpRowSegmentLSpecial.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 // $Id$
  17 // $MpId: AliMpRowSegmentLSpecial.cxx,v 1.7 2006/05/24 13:58:46 ivana Exp $
  18 // Category: sector
  19 //
  20 // Class AliMpRowSegmentLSpecial
  21 // -----------------------------
  22 // Class describing a special inner row segment composed of the
  23 // pad rows.
  24 // Included in AliRoot: 2003/05/02
  25 // Authors: David Guez, Ivana Hrivnacova; IPN Orsay
  26
  27 #include <Riostream.h>
  28 #include <TMath.h>
  29
  30 #include "AliMpRowSegmentLSpecial.h"
  31 #include "AliMpRow.h"
  32 #include "AliMpPadRow.h"
  33 #include "AliMpVPadRowSegment.h"
  34 #include "AliMpMotif.h"
  35 #include "AliMpMotifType.h"
  36 #include "AliMpMotifMap.h"
  37 #include "AliMpMotifPosition.h"
  38 #include "AliMpConstants.h"
  39
  40 #include "AliLog.h"
  41
  42 /// \cond CLASSIMP
  43 ClassImp(AliMpRowSegmentLSpecial)
  44 /// \endcond
  45
  46 //______________________________________________________________________________
  47 AliMpRowSegmentLSpecial::AliMpRowSegmentLSpecial(AliMpRow* row, Double_t offsetX)
  48   : AliMpVRowSegmentSpecial(row, offsetX)
  49 {
  50 /// Standard constructor
  51 }
  52
  53 //______________________________________________________________________________
  54 AliMpRowSegmentLSpecial::AliMpRowSegmentLSpecial()
  55   : AliMpVRowSegmentSpecial()
  56 {
  57 /// Default constructor
  58 }
  59
  60 //______________________________________________________________________________
  61 AliMpRowSegmentLSpecial::~AliMpRowSegmentLSpecial()
  62 {
  63 /// Destructor
  64 }
  65
  66 //
  67 // private methods
  68 //
  69
  70 //______________________________________________________________________________
  71 AliMpVPadRowSegment*
  72 AliMpRowSegmentLSpecial::FindMostRightPadRowSegment(Int_t motifPositionId) const
  73 {
  74 /// Find the most right pad row segment with this motifPositionId.
  75
  76   AliMpVPadRowSegment* found = 0;
  77
  78   for (Int_t i=0; i<GetNofPadRows(); i++) {
  79     AliMpPadRow* padRow = GetPadRow(i);
  80
  81     for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
  82       AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
  83
  84       if ( padRowSegment->GetMotifPositionId() == motifPositionId &&
  85            (!found || padRowSegment->RightBorderX() > found->RightBorderX()))
  86
  87         found = padRowSegment;
  88     }
  89   }
  90
  91   return found;
  92 }
  93
  94 //
  95 // protected methods
  96 //
  97
  98 //______________________________________________________________________________
  99 TVector2 AliMpRowSegmentLSpecial::MotifCenterSlow(Int_t motifPositionId) const
 100 {
 101 /// Return the coordinates of the motif specified with
 102 /// the given position identifier.                                           \n
 103 /// !! Applicable only for motifs that have their most down pad in
 104 /// this row segment.
 105
 106   // Find the first (left, down) pad row segment with this motifPositionId.
 107   AliMpVPadRowSegment* downPadRowSegment
 108     = FindPadRowSegment(motifPositionId);
 109   AliMpVPadRowSegment* rightPadRowSegment
 110     = FindMostRightPadRowSegment(motifPositionId);
 111
 112   // Check if the motifPositionId is present
 113   if (!downPadRowSegment || !rightPadRowSegment) {
 114     AliErrorStream() << "Outside row segment region" << endl;
 115     return 0;
 116   }
 117
 118   // Check if both pad row segments have the same motif
 119   if (downPadRowSegment->GetMotif() != rightPadRowSegment->GetMotif()) {
 120     AliFatal("Outside row segment region");
 121     return 0;
 122   }
 123
 124   // Get position of found row segment
 125   Double_t x = rightPadRowSegment->RightBorderX();
 126   Double_t y = GetRow()->LowBorderY()  ;
 127
 128   for (Int_t i=0; i<downPadRowSegment->GetPadRow()->GetID(); i++)
 129     y += GetPadRow(i)->HalfSizeY()*2.;
 130
 131   // Add motifs dimensions
 132   x -= downPadRowSegment->GetMotif()->Dimensions().X();
 133   y += downPadRowSegment->GetMotif()->Dimensions().Y();
 134
 135   return TVector2(x, y);
 136 }
 137
 138 //
 139 // public methods
 140 //
 141
 142 //______________________________________________________________________________
 143 void AliMpRowSegmentLSpecial::UpdatePadsOffset()
 144 {
 145 /// Set low indices limit to the pad offset calculated
 146 /// from the neighbour normal segment.
 147
 148   // Get the neighbour row segment
 149   // (the first normal segment)
 150   AliMpVRowSegment* neighbour = GetRow()->GetRowSegment(1);
 151
 152   // Get the the pads offset of the neighbour row segment
 153   // (the first normal segment)
 154   AliMpIntPair offset = neighbour->GetLowIndicesLimit();
 155
 156   // Find max nof pads in a row
 157   Int_t maxNofPads = MaxNofPadsInRow();
 158
 159   // Set limits
 160   SetLowIndicesLimit(offset - AliMpIntPair(maxNofPads, 0));
 161
 162   // Reset limits in the neighbour row segment
 163   // (pad offset is now included in the special segment)
 164   neighbour->SetLowIndicesLimit(
 165     AliMpIntPair(0, neighbour->GetLowIndicesLimit().GetSecond()));
 166 }
 167
 168 //______________________________________________________________________________
 169 Double_t  AliMpRowSegmentLSpecial::LeftBorderX() const
 170 {
 171 /// Return the x coordinate of the left row segment border
 172 /// in the global coordinate system.
 173
 174   Double_t leftBorder = DBL_MAX;
 175   for (Int_t i=0; i<GetNofPadRows(); i++) {
 176     AliMpPadRow* padRow = GetPadRow(i);
 177     Double_t border
 178       = padRow->GetPadRowSegment(padRow->GetNofPadRowSegments()-1)->LeftBorderX();
 179
 180     if (border < leftBorder) leftBorder =  border;
 181   }
 182
 183   return leftBorder;
 184 }
 185
 186 //______________________________________________________________________________
 187 Double_t  AliMpRowSegmentLSpecial::RightBorderX() const
 188 {
 189 /// Returns the x coordinate of the right row segment border
 190 /// in the global coordinate system.
 191
 192   Double_t sameBorder = GetOffsetX();
 193
 194   // Consistence check
 195   Double_t rightBorder = -DBL_MAX;
 196   for (Int_t i=0; i<GetNofPadRows(); i++) {
 197     AliMpPadRow* padRow = GetPadRow(i);
 198     Double_t border = padRow->GetPadRowSegment(0)->RightBorderX();
 199     if (border > rightBorder) rightBorder =  border;
 200   }
 201
 202   if (TMath::Abs(GetOffsetX() - rightBorder) > 1.e-04)  {
 203     AliErrorStream() << "WrongBorder" << endl;
 204     return sameBorder;
 205   }
 206
 207   return rightBorder;
 208 }
 209
 210 //______________________________________________________________________________
 211 TVector2 AliMpRowSegmentLSpecial::Position() const
 212 {
 213 /// Return the position of the row segment centre.
 214 /// The centre is defined as the centre of the rectangular
 215 /// row segment envelope.
 216
 217   Double_t x = GetOffsetX() - Dimensions().X();
 218   Double_t y = GetRow()->Position().Y();
 219
 220   return TVector2(x, y);
 221 }
 222
 223 #include <Riostream.h>
 224 //______________________________________________________________________________
 225 Int_t AliMpRowSegmentLSpecial::SetIndicesToMotifPosition(Int_t i,
 226                                          const AliMpIntPair& indices)
 227 {
 228 /// Set global indices to i-th motif position and returns next index in x.
 229
 230   // Get motif position
 231   AliMpMotifPosition* motifPosition
 232     = GetRow()->GetMotifMap()->FindMotifPosition(GetMotifPositionId(i));
 233
 234   // Low limit
 235   AliMpIntPair low
 236     = AliMpIntPair(GetLowIndicesLimit().GetFirst() + AliMpConstants::StartPadIndex(),
 237                indices.GetSecond())
 238       + FindRelativeLowIndicesOf(GetMotifPositionId(i));
 239
 240   if (! motifPosition->GetHighIndicesLimit().IsValid()) {
 241      motifPosition->SetLowIndicesLimit(low);
 242   }
 243   else {
 244     if (motifPosition->GetLowIndicesLimit().GetFirst() > low.GetFirst())
 245       motifPosition->SetLowIndicesLimit(
 246                         AliMpIntPair(low.GetFirst(),
 247                                  motifPosition->GetLowIndicesLimit().GetSecond()));
 248
 249     if (motifPosition->GetLowIndicesLimit().GetSecond() > low.GetSecond())
 250        motifPosition->SetLowIndicesLimit(
 251                          AliMpIntPair(motifPosition->GetLowIndicesLimit().GetFirst(),
 252                                   low.GetSecond()));
 253   }
 254
 255   // High limit
 256   AliMpMotifType* motifType = motifPosition->GetMotif()->GetMotifType();
 257   AliMpIntPair high
 258     = motifPosition->GetLowIndicesLimit()
 259       + AliMpIntPair(motifType->GetNofPadsX()-1, motifType->GetNofPadsY()-1);
 260
 261   motifPosition->SetHighIndicesLimit(high);
 262
 263   // Increment index only if last motif position is processed
 264   if (i != GetNofMotifs()-1)
 265     return indices.GetFirst();
 266     //return 0;
 267   else
 268     return indices.GetFirst() + MaxNofPadsInRow();
 269     //return MaxNofPadsInRow();
 270 }
 271 //______________________________________________________________________________
 272 void AliMpRowSegmentLSpecial::SetGlobalIndices(AliMpRow* rowBefore)
 273 {
 274 /// Set indices limits
 275 /// The limits are defined as the limits of the smallest rectangle which
 276 /// includes all pads of this special row segment.
 277
 278   // Low ix
 279   Int_t ixl = GetLowIndicesLimit().GetFirst() + AliMpConstants::StartPadIndex();
 280       // the pads offset was already defined by Reader
 281
 282   // High ix
 283   Int_t ixh = ixl + MaxNofPadsInRow() - 1;
 284
 285   // Low iy
 286   Int_t iyl = AliMpConstants::StartPadIndex();
 287   if (rowBefore) {
 288     //if (constPadSizeDirection == kY) {
 289       iyl = rowBefore->GetHighIndicesLimit().GetSecond()+1;
 290     //}
 291     /*
 292     else {
 293       AliMpVRowSegment* seg = rowBefore->FindRowSegment(ixl);
 294       AliMpMotifPosition* motPos =  rowBefore->FindMotifPosition(seg, ixl);
 295       if (!motPos)
 296         Fatal("SetGlobalIndices", "Motif position in rowBefore not found.");
 297       iyl = motPos->GetHighIndicesLimit().GetSecond()+1;
 298     }
 299     */
 300   }
 301
 302   // High iy
 303   Int_t iyh = iyl + GetNofPadRows() - 1;
 304
 305   SetLowIndicesLimit(AliMpIntPair(ixl, iyl));
 306   SetHighIndicesLimit(AliMpIntPair(ixh, iyh));
 307 }
 308
 309
 310
 311