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