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