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