MUON/mapping/AliMpMotifMap.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: AliMpMotifMap.cxx,v 1.16 2006/05/24 13:58:41 ivana Exp $
  18 // Category: motif
  19
  20 //-----------------------------------------------------------------------------
  21 // Class AliMpMotifMap
  22 // -------------------
  23 // Class describing the motif map container, where motifs are
  24 // mapped to their string IDs.
  25 // Included in AliRoot: 2003/05/02
  26 // Authors: David Guez, Ivana Hrivnacova; IPN Orsay
  27 //-----------------------------------------------------------------------------
  28
  29 #include "AliMpMotifMap.h"
  30
  31 #include "AliCodeTimer.h"
  32 #include "AliMpExMapIterator.h"
  33 #include "AliMpVMotif.h"
  34 #include "AliMpMotif.h"
  35 #include "AliMpMotifSpecial.h"
  36 #include "AliMpMotifType.h"
  37 #include "AliMpMotifPosition.h"
  38
  39 #include "AliLog.h"
  40
  41 #include <Riostream.h>
  42 #include <TVector2.h>
  43 #include <TArrayI.h>
  44
  45 /// \cond CLASSIMP
  46 ClassImp(AliMpMotifMap)
  47 /// \endcond
  48
  49 //_____________________________________________________________________________
  50 AliMpMotifMap::AliMpMotifMap()
  51   : TObject(),
  52     fMotifs(),
  53     fMotifTypes(),
  54     fMotifPositions(),
  55     fMotifPositions2()
  56 {
  57 /// Standard constructor
  58
  59 #ifdef WITH_ROOT
  60   fMotifPositions2.SetOwner(false);
  61 #endif
  62 }
  63
  64 //_____________________________________________________________________________
  65 AliMpMotifMap::AliMpMotifMap(TRootIOCtor* ioCtor)
  66   : TObject(),
  67 #ifdef WITH_STL
  68     fMotifs(),
  69     fMotifTypes(),
  70     fMotifPositions(),
  71     fMotifPositions2()
  72 #endif
  73 #ifdef WITH_ROOT
  74     fMotifs(ioCtor),
  75     fMotifTypes(ioCtor),
  76     fMotifPositions(ioCtor),
  77     fMotifPositions2(ioCtor)
  78 #endif
  79 {
  80 /// Root IO constructor
  81
  82 #ifdef WITH_ROOT
  83    fMotifPositions2.SetOwner(false);
  84 #endif
  85 }
  86
  87 //_____________________________________________________________________________
  88 AliMpMotifMap::~AliMpMotifMap()
  89 {
  90 /// Destructor
  91
  92   // Delete all registered motifs, motif types, motif positions
  93
  94 #ifdef WITH_STL
  95   for (MotifMapIterator im=fMotifs.begin(); im != fMotifs.end(); im++) {
  96     delete im->second;
  97   }
  98
  99   for (MotifTypeMapIterator it=fMotifTypes.begin();
 100        it != fMotifTypes.end(); it++) {
 101     delete it->second;
 102   }
 103
 104   for (MotifPositionMapIterator ip=fMotifPositions.begin();
 105        ip != fMotifPositions.end(); ip++) {
 106     delete ip->second;
 107   }
 108 #endif
 109
 110 }
 111
 112 //
 113 // private methods
 114 //
 115
 116 //_____________________________________________________________________________
 117 void  AliMpMotifMap::PrintMotif(const AliMpVMotif* motif) const
 118 {
 119 /// Print the motif.
 120
 121   cout << motif->GetID().Data() << "  "
 122        << motif->GetMotifType()->GetID() << "    "
 123        << motif->Dimensions().X() << " "
 124        << motif->Dimensions().Y();
 125 }
 126
 127 //_____________________________________________________________________________
 128 void  AliMpMotifMap::PrintMotifType(const AliMpMotifType* motifType) const
 129 {
 130 /// Print the motif type.
 131
 132   cout << motifType->GetID().Data() << "  "
 133        << motifType->GetNofPadsX() << "  "
 134        << motifType->GetNofPadsY() << "  ";
 135 }
 136
 137 //_____________________________________________________________________________
 138 void  AliMpMotifMap::PrintMotifPosition(
 139                           const AliMpMotifPosition* motifPosition) const
 140 {
 141 /// Print the motif position.
 142
 143   cout << " ID " << motifPosition->GetID() << "  "
 144        << " Motif ID " << motifPosition->GetMotif()->GetID() << "  "
 145        << " Pos (X,Y) = (" << motifPosition->Position().X() << ","
 146        << motifPosition->Position().Y() << ")";
 147 }
 148
 149 //_____________________________________________________________________________
 150 void  AliMpMotifMap::PrintMotifPosition2(
 151                           const AliMpMotifPosition* motifPosition) const
 152 {
 153 /// Print the motif position.
 154
 155   cout << setw(3) << motifPosition->GetLowIndicesLimit().GetFirst() << "  "
 156        << setw(3) << motifPosition->GetLowIndicesLimit().GetSecond() << "  "
 157        << setw(3) << motifPosition->GetHighIndicesLimit().GetFirst()  << " "
 158        << setw(3) << motifPosition->GetHighIndicesLimit().GetSecond()  << " "
 159        << motifPosition->GetID() << "  ";
 160 }
 161
 162 //_____________________________________________________________________________
 163 void  AliMpMotifMap::PrintMotifs() const
 164 {
 165 /// Print all the motifs and their motif types
 166 /// for all motifs in the motifs map.
 167
 168 #ifdef WITH_STL
 169   if (fMotifs.size()) {
 170     cout << "Dump of Motif Map - " << fMotifs.size() << " entries:" << endl;
 171     Int_t counter = 0;
 172     for (MotifMapIterator i=fMotifs.begin(); i != fMotifs.end(); i++) {
 173       const TString& id  = (*i).first;
 174       cout << "Map element "
 175            << setw(3) << counter++ << "   "
 176            << id.Data() << "   " ;
 177       PrintMotif((*i).second);
 178       cout << endl;
 179     }
 180     cout << endl;
 181   }
 182 #endif
 183
 184 #ifdef WITH_ROOT
 185   if (fMotifs.GetSize()) {
 186     cout << "Dump of Motif Map - " << fMotifs.GetSize() << " entries:" << endl;
 187     Int_t counter = 0;
 188     AliMpExMapIterator* it = fMotifs.CreateIterator();
 189     Int_t key;
 190     AliMpVMotif* motif;
 191
 192     while ( ( motif = static_cast<AliMpVMotif*>(it->Next(key)) ) )
 193     {
 194          TString id  = fMotifs.AliMpExMap::GetString(key);
 195       cout << "Map element "
 196            << setw(3) << counter++ << "   "
 197            << id.Data() << "   " ;
 198       PrintMotif(motif);
 199       cout << endl;
 200     }
 201     cout << endl;
 202     delete it;
 203   }
 204 #endif
 205 }
 206
 207 //_____________________________________________________________________________
 208 void  AliMpMotifMap::PrintMotifTypes() const
 209 {
 210 /// Print all the the motifs types and their motif dimensions
 211 /// for all motif types in the motif types map.
 212
 213 #ifdef WITH_STL
 214   if (fMotifTypes.size()) {
 215     cout << "Dump of Motif Type Map - " << fMotifTypes.size() << " entries:" << endl;
 216     Int_t counter = 0;
 217     for (MotifTypeMapIterator i=fMotifTypes.begin(); i != fMotifTypes.end(); i++) {
 218       const TString& id  = (*i).first;
 219       cout << "Map element "
 220            << setw(3) << counter++ << "   "
 221            << id.Data() << "   ";
 222       PrintMotifType((*i).second);
 223       cout << endl;
 224     }
 225     cout << endl;
 226   }
 227 #endif
 228
 229 #ifdef WITH_ROOT
 230   if (fMotifTypes.GetSize()) {
 231     cout << "Dump of Motif Type Map - " << fMotifTypes.GetSize() << " entries:" << endl;
 232     Int_t counter = 0;
 233     AliMpExMapIterator* it = fMotifTypes.CreateIterator();
 234     Int_t key;
 235     AliMpMotifType* motifType;
 236
 237     while ( ( motifType = static_cast<AliMpMotifType*>(it->Next(key)) ) )
 238     {
 239       TString id  = AliMpExMap::GetString(key);
 240       cout << "Map element "
 241            << setw(3) << counter++ << "   "
 242            << id.Data() << "   " ;
 243       PrintMotifType(motifType);
 244       cout << endl;
 245     }
 246     cout << endl;
 247     delete it;
 248   }
 249 #endif
 250 }
 251
 252 //_____________________________________________________________________________
 253 void
 254 AliMpMotifMap::GetAllMotifPositionsIDs(TArrayI& ecn) const
 255 {
 256 /// Fill the given array with all motif positions IDs (electronic card numbers)
 257 /// defined in the map
 258
 259 #ifdef WITH_STL
 260   ecn.Set(fMotifPositions.size());
 261   Int_t i(0);
 262   MotifPositionMapIterator it;
 263   for (it=fMotifPositions.begin(); it != fMotifPositions.end(); it++) {
 264     AliMpMotifPosition* motifPosition = (*it).second;
 265     ecn[i++] = motifPosition->GetID();
 266   }
 267 #endif
 268
 269 #ifdef WITH_ROOT
 270   ecn.Set(fMotifPositions.GetSize());
 271   TIter next(fMotifPositions.CreateIterator());
 272   AliMpMotifPosition* motifPosition;
 273   Int_t i(0);
 274   while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
 275   {
 276     ecn[i] = motifPosition->GetID();
 277     ++i;
 278   }
 279 #endif
 280 }
 281
 282 //_____________________________________________________________________________
 283 UInt_t  AliMpMotifMap::GetNofMotifPositions() const
 284 {
 285 /// Return the number of all motif positions IDs (electronic card numbers)
 286
 287 #ifdef WITH_STL
 288   return fMotifPositions.size();
 289 #endif
 290
 291 #ifdef WITH_ROOT
 292   return fMotifPositions.GetSize();
 293 #endif
 294 }
 295
 296 //_____________________________________________________________________________
 297 AliMpMotifPosition* AliMpMotifMap::GetMotifPosition(UInt_t index) const
 298 {
 299 /// Return the motif position which is in the map on the index-th position
 300
 301   AliCodeTimerAuto("");
 302
 303   if ( index >= GetNofMotifPositions() ) {
 304     AliErrorStream() << "Index " << index << " outside limits." << endl;
 305     return 0;
 306   }
 307
 308 #ifdef WITH_STL
 309   MotifPositionMapIterator it = fMotifPositions.begin();
 310   std::advance(it, index);
 311   return it->second;
 312 #endif
 313
 314 #ifdef WITH_ROOT
 315   TIter next(fMotifPositions.CreateIterator());
 316   while (index-- > 0) next();
 317   return static_cast<AliMpMotifPosition*>(next());
 318 #endif
 319 }
 320
 321 //_____________________________________________________________________________
 322 Int_t AliMpMotifMap::CalculateNofPads() const
 323 {
 324 /// Calculate total number of pads in the map
 325
 326   Int_t nofPads = 0;
 327
 328 #ifdef WITH_STL
 329   MotifPositionMapIterator it;
 330   for (it=fMotifPositions.begin(); it != fMotifPositions.end(); it++) {
 331     AliMpMotifPosition* motifPosition = (*it).second;
 332     nofPads += motifPosition->GetMotif()->GetMotifType()->GetNofPads();
 333   }
 334 #endif
 335
 336 #ifdef WITH_ROOT
 337   TIter next(fMotifPositions.CreateIterator());
 338   AliMpMotifPosition* motifPosition;
 339   while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
 340   {
 341     nofPads += motifPosition->GetMotif()->GetMotifType()->GetNofPads();
 342   }
 343 #endif
 344
 345   return nofPads;
 346 }
 347
 348 //_____________________________________________________________________________
 349 void  AliMpMotifMap::PrintMotifPositions() const
 350 {
 351 /// Print all motif positions.
 352
 353 #ifdef WITH_STL
 354   if (fMotifPositions.size()) {
 355     cout << "Dump of Motif Position Map - " << fMotifPositions.size() << " entries:" << endl;
 356     Int_t counter = 0;
 357     for (MotifPositionMapIterator i=fMotifPositions.begin();
 358                                   i != fMotifPositions.end(); i++) {
 359
 360       cout << "Map element "
 361            << setw(3) << counter++ << "   ";
 362       PrintMotifPosition((*i).second);
 363       cout << endl;
 364     }
 365     cout << endl;
 366   }
 367 #endif
 368
 369 #ifdef WITH_ROOT
 370   if (fMotifPositions.GetSize()) {
 371     cout << "Dump of Motif Position Map - " << fMotifPositions.GetSize() << " entries:" << endl;
 372     Int_t counter = 0;
 373     TIter next(fMotifPositions.CreateIterator());
 374     AliMpMotifPosition* motifPosition;
 375
 376     while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
 377     {
 378       cout << "Map element "
 379            << setw(3) << counter++ << "   ";
 380       PrintMotifPosition(motifPosition);
 381       cout << endl;
 382     }
 383     cout << endl;
 384   }
 385 #endif
 386 }
 387
 388 //_____________________________________________________________________________
 389 void  AliMpMotifMap::PrintMotifPositions2() const
 390 {
 391 /// Print all motif positions from the second map
 392 /// (by global indices)
 393
 394 #ifdef WITH_STL
 395   if (fMotifPositions2.size()) {
 396     cout << "Dump of Motif Position Map 2 - " << fMotifPositions2.size() << " entries:" << endl;
 397     Int_t counter = 0;
 398     for (MotifPositionMap2Iterator i=fMotifPositions2.begin();
 399                                    i != fMotifPositions2.end(); i++) {
 400
 401       cout << "Map element "
 402            << setw(3) << counter++ << "   ";
 403       PrintMotifPosition2((*i).second);
 404       cout << endl;
 405     }
 406     cout << endl;
 407   }
 408 #endif
 409
 410 #ifdef WITH_ROOT
 411
 412   if (fMotifPositions2.GetSize())
 413   {
 414     cout << "Dump of Motif Position Map 2 - " << fMotifPositions2.GetSize() << " entries:" << endl;
 415     TIter next(fMotifPositions2.CreateIterator());
 416     AliMpMotifPosition* motifPosition(0x0);
 417     Int_t counter = 0;
 418
 419     while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
 420     {
 421       cout << "Map element " << setw(3) << counter++ << "   ";
 422       PrintMotifPosition2(motifPosition);
 423       cout << endl;
 424     }
 425     cout << endl;
 426   }
 427 #endif
 428 }
 429
 430 //
 431 // public methods
 432 //
 433
 434 //_____________________________________________________________________________
 435 Bool_t AliMpMotifMap::AddMotif(AliMpVMotif* motif, Bool_t warn)
 436 {
 437 /// Add the specified motif
 438 /// if the motif with this ID is not yet present.
 439
 440   AliMpVMotif* found = FindMotif(motif->GetID());
 441   if (found) {
 442     if (warn && found == motif)
 443       AliWarningStream() << "The motif is already in map." << endl;
 444
 445     if (warn && found != motif) {
 446       AliWarningStream()
 447         << "Another motif with the same ID is already in map." << endl;
 448     }
 449     return false;
 450   }
 451
 452 #ifdef WITH_STL
 453   fMotifs[motif->GetID()] = motif;
 454 #endif
 455
 456 #ifdef WITH_ROOT
 457   fMotifs.Add(motif->GetID(), motif);
 458 #endif
 459
 460   return true;
 461 }
 462
 463 //_____________________________________________________________________________
 464 Bool_t AliMpMotifMap::AddMotifType(AliMpMotifType* motifType, Bool_t warn)
 465 {
 466 /// Add the specified motif type
 467 /// if the motif with this ID is not yet present.
 468
 469   AliMpMotifType* found = FindMotifType(motifType->GetID());
 470   if (found) {
 471     if (warn && found == motifType)
 472       AliWarningStream() << "The motif type is already in map." << endl;
 473
 474     if (warn && found != motifType) {
 475       AliWarningStream()
 476         << "Another motif type with the same ID is already in map." << endl;
 477     }
 478     return false;
 479   }
 480
 481 #ifdef WITH_STL
 482   fMotifTypes[motifType->GetID()] = motifType;
 483 #endif
 484
 485 #ifdef WITH_ROOT
 486   fMotifTypes.Add(motifType->GetID(), motifType);
 487 #endif
 488
 489   return true;
 490 }
 491
 492 //_____________________________________________________________________________
 493 Bool_t AliMpMotifMap::AddMotifPosition(AliMpMotifPosition* motifPosition, Bool_t warn)
 494 {
 495 /// Add the specified motif position
 496 /// if this position is not yet present.
 497
 498   AliMpMotifPosition* found = FindMotifPosition(motifPosition->GetID());
 499   if (found) {
 500     if (warn && found == motifPosition) {
 501       AliWarningStream()
 502            << "ID: " << motifPosition->GetID()
 503            << "  found: " << found
 504            << "  new:   " << motifPosition << endl
 505            << "This motif position is already in map." << endl;
 506     }
 507
 508     if (warn && found != motifPosition) {
 509       AliWarningStream()
 510            << "ID: " << motifPosition->GetID()
 511            << "  found: " << found
 512            << "  new:   " << motifPosition << endl
 513            << "Another motif position with the same ID is already in map."
 514            << endl;
 515     }
 516
 517     return false;
 518   }
 519
 520 #ifdef WITH_STL
 521   fMotifPositions[motifPosition->GetID()] = motifPosition;
 522 #endif
 523
 524 #ifdef WITH_ROOT
 525   fMotifPositions.Add(motifPosition->GetID() << 16, motifPosition);
 526 #endif
 527
 528   return true;
 529 }
 530
 531 //_____________________________________________________________________________
 532 void AliMpMotifMap::FillMotifPositionMap2()
 533 {
 534 /// Fill the second map (by global indices) of motif positions.
 535
 536 #ifdef WITH_STL
 537   if (fMotifPositions2.size() > 0 ) {
 538     AliWarningStream() << "Map has been already filled." << endl;
 539     return;
 540   }
 541
 542   for (MotifPositionMapIterator ip=fMotifPositions.begin();
 543        ip != fMotifPositions.end(); ip++) {
 544
 545     fMotifPositions2[(*ip).second->GetLowIndicesLimit()] = (*ip).second;
 546   }
 547 #endif
 548
 549 #ifdef WITH_ROOT
 550   if (fMotifPositions2.GetSize() > 0 ) {
 551     AliWarningStream() <<"Map has been already filled." << endl;
 552     return;
 553   }
 554
 555   TIter next(fMotifPositions.CreateIterator());
 556   AliMpMotifPosition* motifPosition(0x0);
 557   while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
 558   {
 559     fMotifPositions2.Add(motifPosition->GetLowIndicesLimit(), motifPosition);
 560   }
 561 #endif
 562
 563 }
 564
 565 //_____________________________________________________________________________
 566 void  AliMpMotifMap::Print(const char* opt) const
 567 {
 568 /// Print the motifs and motif types maps.
 569
 570   TString sopt(opt);
 571
 572   sopt.ToUpper();
 573
 574   if ( sopt.Contains("MOTIFS") || sopt == "ALL" ) PrintMotifs();
 575   if ( sopt.Contains("MOTIFTYPES") || sopt == "ALL" ) PrintMotifTypes();
 576   if ( sopt.Contains("MOTIFPOSITIONS") || sopt == "ALL" ) PrintMotifPositions();
 577   if ( sopt.Contains("MOTIFPOSITIONS2") || sopt == "ALL" ) PrintMotifPositions2();
 578 }
 579
 580 //_____________________________________________________________________________
 581 void  AliMpMotifMap::PrintGlobalIndices(const char* fileName) const
 582 {
 583 /// Print all motif positions and their global indices.
 584
 585   ofstream out(fileName, ios::out);
 586
 587 #ifdef WITH_STL
 588   if (fMotifPositions.size()) {
 589     for (MotifPositionMapIterator i=fMotifPositions.begin();
 590                                    i != fMotifPositions.end(); i++) {
 591
 592       AliMpMotifPosition* motifPosition = (*i).second;
 593       out << setw(5) << motifPosition->GetID() << "     "
 594           << setw(3) << motifPosition->GetLowIndicesLimit().GetFirst()  << " "
 595           << setw(3) << motifPosition->GetLowIndicesLimit().GetSecond()
 596          << endl;
 597     }
 598     out << endl;
 599   }
 600 #endif
 601
 602 #ifdef WITH_ROOT
 603   if (fMotifPositions.GetSize()) {
 604     TIter next(fMotifPositions.CreateIterator());
 605     AliMpMotifPosition* motifPosition;
 606     while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
 607     {
 608       out << setw(5) << motifPosition->GetID() << "     "
 609           << setw(3) << motifPosition->GetLowIndicesLimit().GetFirst()  << " "
 610           << setw(3) << motifPosition->GetLowIndicesLimit().GetSecond()
 611          << endl;
 612     }
 613     out << endl;
 614   }
 615 #endif
 616 }
 617
 618 //_____________________________________________________________________________
 619 void  AliMpMotifMap::UpdateGlobalIndices(const char* fileName)
 620 {
 621 /// Update the motif positions global indices from the file.
 622
 623   ifstream in(fileName, ios::in);
 624
 625   Int_t motifPositionId, offx, offy;
 626
 627   do {
 628     in >> motifPositionId >> offx >> offy;
 629
 630     if (in.eof()) {
 631       FillMotifPositionMap2();
 632       return;
 633     }
 634
 635     AliMpMotifPosition* motifPosition = FindMotifPosition(motifPositionId);
 636
 637     if (motifPosition) {
 638        AliDebugStream(1)
 639             << "Processing "
 640             << motifPosition->GetID() << " " << offx << " " << offy << endl;
 641
 642        motifPosition->SetLowIndicesLimit(AliMpIntPair(offx, offy));
 643
 644        Int_t offx2
 645          = offx + motifPosition->GetMotif()->GetMotifType()->GetNofPadsX() - 1;
 646
 647        Int_t offy2
 648          = offy + motifPosition->GetMotif()->GetMotifType()->GetNofPadsY() - 1;
 649
 650        motifPosition->SetHighIndicesLimit(AliMpIntPair(offx2, offy2));
 651     }
 652     else {
 653        AliWarningStream()
 654          << "Motif position " << motifPositionId << " not found" << endl;
 655     }
 656   }
 657   while (!in.eof());
 658 }
 659
 660
 661 //_____________________________________________________________________________
 662 AliMpVMotif* AliMpMotifMap::FindMotif(const TString& motifID) const
 663 {
 664 /// Find the motif with the specified ID.
 665
 666   //AliCodeTimerAuto("");
 667
 668 #ifdef WITH_STL
 669   MotifMapIterator i = fMotifs.find(motifID);
 670   if (i != fMotifs.end())
 671     return (*i).second;
 672   else
 673     return 0;
 674 #endif
 675
 676 #ifdef WITH_ROOT
 677   return (AliMpVMotif*)fMotifs.GetValue(motifID);
 678 #endif
 679 }
 680
 681 //_____________________________________________________________________________
 682 AliMpVMotif* AliMpMotifMap::FindMotif(const TString& motifID,
 683                                       const TString& motifTypeID,
 684                                       const TVector2& padDimensions ) const
 685 {
 686 /// Find the motif with the specified ID and returns it
 687 /// only if its motif type and motif dimensions agree
 688 /// with the given motifTypeID and motifDimensions.
 689 /// Disagreement causes fatal error.
 690
 691   //AliCodeTimerAuto("");
 692
 693   AliMpVMotif* motif = FindMotif(motifID);
 694
 695   if (motif && motif->GetMotifType()->GetID() != motifTypeID) {
 696       AliFatal("Motif has been already defined with a different type.");
 697       return 0;
 698   }
 699
 700   // check pad dimension in case of a normal motif
 701   if (motif &&
 702       dynamic_cast<AliMpMotif*>(motif) &&
 703       ( motif->GetPadDimensions(0).X() != padDimensions.X() ||
 704         motif->GetPadDimensions(0).Y() != padDimensions.Y())) {
 705
 706       AliFatal("Motif type has been already defined with different dimensions.");
 707       return 0;
 708
 709   }
 710
 711   // check case of a special motif
 712   if (motif &&
 713       (padDimensions.X() == 0. && padDimensions.Y() == 0.) &&
 714       !dynamic_cast<AliMpMotifSpecial*>(motif)) {
 715
 716       AliFatal("Motif type has been already defined with different dimensions.");
 717       return 0;
 718
 719   }
 720
 721   return motif;
 722 }
 723
 724 //_____________________________________________________________________________
 725 AliMpMotifType* AliMpMotifMap::FindMotifType(const TString& motifTypeID) const
 726 {
 727 /// Find the motif type with the specified motif type ID.
 728
 729   //AliCodeTimerAuto("");
 730
 731 #ifdef WITH_STL
 732   MotifTypeMapIterator i = fMotifTypes.find(motifTypeID);
 733   if (i != fMotifTypes.end())
 734     return (*i).second;
 735   else
 736     return 0;
 737 #endif
 738
 739 #ifdef WITH_ROOT
 740   return (AliMpMotifType*)fMotifTypes.GetValue(motifTypeID);
 741 #endif
 742 }
 743
 744 //_____________________________________________________________________________
 745 AliMpMotifPosition*
 746 AliMpMotifMap::FindMotifPosition(Int_t motifPositionID) const
 747 {
 748 /// Find the motif position with the specified motif position ID.
 749
 750   //AliCodeTimerAuto("");
 751
 752 #ifdef WITH_STL
 753   MotifPositionMapIterator i = fMotifPositions.find(motifPositionID);
 754   if (i != fMotifPositions.end())
 755     return (*i).second;
 756   else
 757     return 0;
 758 #endif
 759
 760 #ifdef WITH_ROOT
 761   return (AliMpMotifPosition*)fMotifPositions.GetValue(motifPositionID << 16);
 762 #endif
 763 }
 764
 765 /*
 766 //_____________________________________________________________________________
 767 AliMpMotifPosition*
 768 AliMpMotifMap::FindMotifPosition(const AliMpIntPair& indices) const
 769 {
 770 /// Find the last motif position which has the global indices (low limit)
 771 /// less then the indices specified.
 772
 773 #ifdef WITH_STL
 774   MotifPositionMap2Iterator found
 775     = fMotifPositions2.lower_bound(indices);
 776
 777   if (found == fMotifPositions2.end()) found--;
 778
 779   MotifPositionMap2Iterator i=found;
 780   do {
 781     AliMpIntPair low = (*i).second->GetLowIndicesLimit();
 782     AliMpIntPair up = (*i).second->GetHighIndicesLimit();
 783
 784     if ( indices.GetFirst()  >= low.GetFirst() &&
 785          indices.GetSecond() >= low.GetSecond() &&
 786          indices.GetFirst()  <= up.GetFirst() &&
 787          indices.GetSecond() <= up.GetSecond())
 788
 789          return (*i).second;
 790   }
 791   while ( i-- != fMotifPositions2.begin());
 792
 793   return 0;
 794 #endif
 795
 796 #ifdef WITH_ROOT
 797   // HOW TO DO THIS WITH ROOT ????
 798   // Fortunately it seems not to be used anywhere
 799   Fatal("FindMotifPosition", "Difficult in Root to do this.");
 800   return 0;
 801 #endif
 802 }
 803 */