MUON/mapping/AliMpVRowSegmentSpecial.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: AliMpVRowSegmentSpecial.cxx,v 1.9 2006/05/24 13:58:46 ivana Exp $
  18 // Category: sector
  19
  20 //-----------------------------------------------------------------------------
  21 // Class AliMpVRowSegmentSpecial
  22 // ----------------------------
  23 // Class describing a special 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 "AliMpVRowSegmentSpecial.h"
  30 #include "AliMpRow.h"
  31 #include "AliMpPadRow.h"
  32 #include "AliMpVPadRowSegment.h"
  33 #include "AliMpMotif.h"
  34 #include "AliMpMotifType.h"
  35 #include "AliMpMotifMap.h"
  36 #include "AliMpMotifPosition.h"
  37 #include "AliMpConstants.h"
  38
  39 #include <Riostream.h>
  40
  41 /// \cond CLASSIMP
  42 ClassImp(AliMpVRowSegmentSpecial)
  43 /// \endcond
  44
  45 #ifdef WITH_ROOT
  46 const Int_t  AliMpVRowSegmentSpecial::fgkMaxNofMotifPositionIds = 20;
  47 #endif
  48
  49 //______________________________________________________________________________
  50 AliMpVRowSegmentSpecial::AliMpVRowSegmentSpecial(AliMpRow* row, Double_t offsetX)
  51   : AliMpVRowSegment(),
  52     fRow(row),
  53     fOffsetX(offsetX),
  54     fPadRows(),
  55     fMotifs(),
  56     fMotifPositionIds()
  57 #ifdef WITH_ROOT
  58     ,fNofMotifPositionIds(0)
  59 #endif
  60 {
  61 /// Standard constructor
  62 }
  63
  64 //______________________________________________________________________________
  65 AliMpVRowSegmentSpecial::AliMpVRowSegmentSpecial()
  66   : AliMpVRowSegment(),
  67     fRow(0),
  68     fOffsetX(0.),
  69     fPadRows(),
  70     fMotifs(),
  71     fMotifPositionIds()
  72 #ifdef WITH_ROOT
  73     ,fNofMotifPositionIds(0)
  74 #endif
  75 {
  76 /// Default constructor
  77
  78 #ifdef WITH_ROOT
  79    fMotifPositionIds.Set(fgkMaxNofMotifPositionIds);
  80 #endif
  81 }
  82
  83 //______________________________________________________________________________
  84 AliMpVRowSegmentSpecial::~AliMpVRowSegmentSpecial()
  85 {
  86 /// Destructor
  87
  88   for (Int_t i=0; i<GetNofPadRows(); i++)
  89     delete fPadRows[i];
  90 }
  91
  92 //
  93 // protected methods
  94 //
  95
  96 //______________________________________________________________________________
  97 AliMpPadRow*  AliMpVRowSegmentSpecial::FindPadRow(Double_t y) const
  98 {
  99 /// Find the pad row in the given y coordinate.
 100
 101   Double_t lowBorder =  fRow->LowBorderY();
 102   Double_t highBorder = fRow->LowBorderY();
 103
 104   for (Int_t i=0; i<GetNofPadRows(); i++) {
 105
 106     AliMpPadRow* padRow = GetPadRow(i);
 107     highBorder += 2.*padRow->HalfSizeY();
 108
 109     if ( y >= lowBorder &&  y <= highBorder)
 110       return padRow;
 111
 112     lowBorder = highBorder;
 113   }
 114
 115   return 0;
 116 }
 117
 118 //______________________________________________________________________________
 119 AliMpVPadRowSegment*
 120 AliMpVRowSegmentSpecial::FindPadRowSegment(Int_t motifPositionId) const
 121 {
 122 /// Find the most down pad row segment with this motifPositionId.
 123
 124   for (Int_t i=0; i<GetNofPadRows(); i++) {
 125     AliMpPadRow* padRow = GetPadRow(i);
 126
 127     for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
 128       AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
 129
 130       if (padRowSegment->GetMotifPositionId() == motifPositionId)
 131         return padRowSegment;
 132     }
 133   }
 134   return 0;
 135 }
 136
 137 //______________________________________________________________________________
 138 AliMpIntPair
 139 AliMpVRowSegmentSpecial::FindRelativeLowIndicesOf(Int_t motifPositionId) const
 140 {
 141 /// Return the lowest pad indices where the motif of the given position ID
 142 /// exist in this segment.
 143
 144   AliMpIntPair ans(0,1000);
 145   AliMpIntPair ans0 = ans;
 146   Int_t maxNofPadsX=0;
 147
 148   for (Int_t i=0; i<GetNofPadRows(); i++) {
 149     AliMpPadRow* padRow = GetPadRow(i);
 150
 151     Int_t nofPadsX=0;
 152     for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
 153       AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
 154       nofPadsX += padRowSegment->GetNofPads();
 155       if (padRowSegment->GetMotifPositionId() == motifPositionId) {
 156          if (ans.GetFirst() < nofPadsX) ans.SetFirst(nofPadsX);
 157          if (ans.GetSecond()>i) ans.SetSecond(i);
 158                   // ans.First = max (nof pads of this pos ID)
 159                   // ans.Second = min of pad row number
 160       }
 161     }
 162     if (nofPadsX > maxNofPadsX) maxNofPadsX = nofPadsX;
 163   }
 164   if (ans == ans0) return AliMpIntPair::Invalid();
 165
 166   return AliMpIntPair(maxNofPadsX-ans.GetFirst(), ans.GetSecond());
 167 }
 168
 169 //______________________________________________________________________________
 170 Int_t  AliMpVRowSegmentSpecial::MaxNofPadsInRow() const
 171 {
 172 /// Return the maximum number of pads in this row segment along the X direction
 173
 174   Int_t maxNofPads = 0;
 175
 176   for (Int_t i=0; i<GetNofPadRows(); i++){
 177     Int_t nofPads = GetPadRow(i)->GetNofPads();
 178
 179     // Find maximum
 180     if (nofPads > maxNofPads) maxNofPads = nofPads;
 181   }
 182
 183   return maxNofPads;
 184 }
 185
 186 //______________________________________________________________________________
 187 Bool_t AliMpVRowSegmentSpecial::HasMotif(const AliMpVMotif* motif) const
 188 {
 189 /// Return true if the specified motif is already in fMotifs vector,
 190 /// returns false otherwise.
 191
 192 #ifdef WITH_STL
 193   for (UInt_t i=0; i<fMotifs.size(); i++)
 194     if (fMotifs[i] == motif) return true;
 195 #endif
 196
 197 #ifdef WITH_ROOT
 198   for (Int_t i=0; i<fMotifs.GetEntriesFast(); i++)
 199     if (fMotifs[i] == (const TObject*)motif) return true;
 200 #endif
 201
 202   return false;
 203 }
 204
 205 //______________________________________________________________________________
 206 Int_t AliMpVRowSegmentSpecial::GetNofPadRows() const
 207 {
 208 /// Return number of pad rows.
 209
 210 #ifdef WITH_STL
 211   return fPadRows.size();
 212 #endif
 213
 214 #ifdef WITH_ROOT
 215   return fPadRows.GetEntriesFast();
 216 #endif
 217 }
 218
 219 //______________________________________________________________________________
 220 AliMpPadRow* AliMpVRowSegmentSpecial::GetPadRow(Int_t i) const
 221 {
 222 /// Return number of pad rows.
 223
 224 #ifdef WITH_STL
 225   return fPadRows[i];
 226 #endif
 227
 228 #ifdef WITH_ROOT
 229   return (AliMpPadRow*)fPadRows[i];
 230 #endif
 231 }
 232
 233 //
 234 // public methods
 235 //
 236
 237 //______________________________________________________________________________
 238 void  AliMpVRowSegmentSpecial::AddPadRow(AliMpPadRow* padRow)
 239 {
 240 /// Add a pad row.
 241
 242   padRow->SetOffsetX(fOffsetX);
 243   padRow->SetID(GetNofPadRows());
 244
 245 #ifdef WITH_STL
 246   fPadRows.push_back(padRow);
 247 #endif
 248
 249 #ifdef WITH_ROOT
 250   fPadRows.Add(padRow);
 251 #endif
 252 }
 253
 254 //______________________________________________________________________________
 255 void AliMpVRowSegmentSpecial::UpdateMotifVector()
 256 {
 257 /// Add motifs associated with the pad row segments in the specified
 258 /// pad row in the fMotifs vector.
 259
 260   for (Int_t i=0; i<GetNofPadRows(); i++) {
 261     AliMpPadRow* padRow = GetPadRow(i);
 262
 263     for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) {
 264       AliMpVMotif* motif = padRow->GetPadRowSegment(j)->GetMotif();
 265
 266       if (!HasMotif(motif)) {
 267 #ifdef WITH_STL
 268         fMotifs.push_back(motif);
 269         fMotifPositionIds.push_back(
 270           padRow->GetPadRowSegment(j)->GetMotifPositionId());
 271 #endif
 272 #ifdef WITH_ROOT
 273         fMotifs.Add(motif);
 274
 275         // resize array if needed
 276         if (fNofMotifPositionIds<fgkMaxNofMotifPositionIds)
 277           fMotifPositionIds.Set(fMotifPositionIds.GetSize()+
 278                                 fgkMaxNofMotifPositionIds);
 279         fMotifPositionIds.AddAt(
 280           padRow->GetPadRowSegment(j)->GetMotifPositionId(),
 281           fNofMotifPositionIds++);
 282 #endif
 283       }
 284     }
 285   }
 286 }
 287
 288 //______________________________________________________________________________
 289 Double_t  AliMpVRowSegmentSpecial::HalfSizeY() const
 290 {
 291 /// Return the size in y of this row segment.
 292
 293   Double_t halfSizeY = 0.;
 294   for (Int_t i=0; i<GetNofPadRows(); i++) {
 295     halfSizeY += GetPadRow(i)->HalfSizeY();
 296   }
 297
 298   return halfSizeY;
 299 }
 300
 301 //______________________________________________________________________________
 302 AliMpVMotif*  AliMpVRowSegmentSpecial::FindMotif(const TVector2& position) const
 303 {
 304 /// Return the motif of this row;
 305
 306   AliMpPadRow* padRow
 307     = FindPadRow(position.Y());
 308
 309   if (!padRow) return 0;
 310
 311   AliMpVPadRowSegment* padRowSegment
 312     = padRow->FindPadRowSegment(position.X());
 313
 314   if (!padRowSegment) return 0;
 315
 316   return padRowSegment->GetMotif();
 317 }
 318
 319 //______________________________________________________________________________
 320 Int_t AliMpVRowSegmentSpecial::FindMotifPositionId(const TVector2& position) const
 321 {
 322 /// Return the motif position identified for the given
 323 /// geometric position.
 324
 325   AliMpPadRow* padRow
 326     = FindPadRow(position.Y());
 327
 328   if (!padRow) return 0;
 329
 330   AliMpVPadRowSegment* padRowSegment
 331     = padRow->FindPadRowSegment(position.X());
 332
 333   if (!padRowSegment) return 0;
 334
 335   return padRowSegment->GetMotifPositionId();
 336 }
 337
 338 //______________________________________________________________________________
 339 Bool_t AliMpVRowSegmentSpecial::HasMotifPosition(Int_t motifPositionId) const
 340 {
 341 /// Return true if the motif specified with the given position identifier
 342 /// is in this segment.
 343
 344   if (FindPadRowSegment(motifPositionId))
 345     return true;
 346   else
 347     return false;
 348 }
 349
 350 //______________________________________________________________________________
 351 TVector2 AliMpVRowSegmentSpecial::MotifCenter(Int_t motifPositionId) const
 352 {
 353 /// Return the coordinates of the motif specified with
 354 /// the given position identifier.
 355
 356   // Try to get the motif position from the motif map first
 357   AliMpMotifPosition* motifPosition
 358     = GetRow()->GetMotifMap()->FindMotifPosition(motifPositionId);
 359   if (motifPosition) return motifPosition->Position();
 360
 361   // Use slow method otherwise
 362   return MotifCenterSlow(motifPositionId);
 363 }
 364
 365 //______________________________________________________________________________
 366 TVector2 AliMpVRowSegmentSpecial::Dimensions() const
 367 {
 368 /// Return the halflengths in x, y of the row segment rectangular envelope.
 369
 370   Double_t x = 0.;
 371   Double_t y = 0.;
 372   for (Int_t i=0; i<GetNofPadRows(); i++) {
 373     AliMpPadRow* padRow = GetPadRow(i);
 374
 375     // Add all pad rows y halfsizes
 376     y += padRow->HalfSizeY();
 377
 378     // Find the biggest pad rows x halfsize
 379     Double_t xx
 380       = (padRow->GetPadRowSegment(0)->RightBorderX() -
 381          padRow->GetPadRowSegment(padRow->GetNofPadRowSegments()-1)->LeftBorderX())/2.;
 382     if (xx > x) x = xx;
 383   }
 384
 385   return TVector2(x, y);
 386 }
 387
 388 //______________________________________________________________________________
 389 AliMpRow*  AliMpVRowSegmentSpecial::GetRow() const
 390 {
 391 /// Return the row.which this row segment belongs to.
 392
 393   return fRow;
 394 }
 395
 396 //______________________________________________________________________________
 397 Int_t  AliMpVRowSegmentSpecial::GetNofMotifs() const
 398 {
 399 /// Return the number of different motifs present in this row segment.
 400
 401 #ifdef WITH_STL
 402   return fMotifs.size();
 403 #endif
 404 #ifdef WITH_ROOT
 405   return fMotifs.GetEntriesFast();
 406 #endif
 407 }
 408
 409 //______________________________________________________________________________
 410 AliMpVMotif* AliMpVRowSegmentSpecial::GetMotif(Int_t i) const
 411 {
 412 /// Return the i-th motif present in this row segment.
 413
 414 #ifdef WITH_STL
 415    return fMotifs[i];
 416 #endif
 417 #ifdef WITH_ROOT
 418    return (AliMpVMotif*)fMotifs[i];
 419 #endif
 420 }
 421
 422 //______________________________________________________________________________
 423 Int_t  AliMpVRowSegmentSpecial::GetMotifPositionId(Int_t i) const
 424 {
 425 /// Return the i-th motif position Id present in this row segment.
 426
 427    return fMotifPositionIds[i];
 428 }
 429