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