Separating writing and reading of raw data (Christian)
[u/mrichter/AliRoot.git] / MUON / AliMUONRawWriter.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 ////////////////////////////////////
17 //
18 // MUON Raw Data generator and reader in ALICE-MUON
19 // This class version 3 (further details could be found in Alice-note)
20 //
21 // Implemented non-constant buspatch numbers for tracking
22 // with correct DDL id (first guess)
23 // (Ch. Finck, dec 2005)
24 //
25 // Digits2Raw:
26 // Generates raw data for MUON tracker and finally for trigger
27 // Using real mapping (inverse) for tracker
28 // For trigger there is no mapping (mapping could be found in AliMUONTriggerCircuit)
29 // Ch. Finck july 04
30 //
31 // Raw2Digits:
32 // Using real mapping  for tracker
33 // Indranil Das (Adapted for runloader: Ch. Finck) july 05
34 // 
35 ////////////////////////////////////
36
37 #include <fstream>
38 #include <string>
39
40 #include <TClonesArray.h>
41
42 #include "AliLoader.h"
43 #include "AliBitPacking.h" 
44 #include "AliRawReader.h"
45 #include "AliLog.h"
46 #include "AliRun.h"
47
48 #include "AliMUON.h"
49 #include "AliMUONRawWriter.h"
50 #include "AliMUONDigit.h"
51
52 #include "AliMUONConstants.h"
53 #include "AliMUONData.h"
54
55 #include "AliMUONSubEventTrigger.h"
56 #include "AliMUONDDLTracker.h"
57 #include "AliMUONDDLTrigger.h"
58
59 #include "AliMUONLocalTrigger.h"
60 #include "AliMUONGlobalTrigger.h"
61
62 #include "AliMUONGeometrySegmentation.h"
63 #include "AliMUONGeometryModule.h"
64 #include "AliMUONGeometryStore.h"
65 #include "AliMpSegFactory.h"
66 #include "AliMpPlaneType.h"
67 #include "AliMpVSegmentation.h"
68 #include "AliMpHelper.h"
69 #include "AliMpPad.h"
70
71
72 ClassImp(AliMUONRawWriter) // Class implementation in ROOT context
73 //__________________________________________________________________________
74 AliMUONRawWriter::AliMUONRawWriter(AliLoader* loader,  AliMUONData* data)
75   : TObject()
76 {
77   // Standard Constructor
78  
79   // initialize loader's
80   fLoader = loader;
81
82   // initialize segmentation factory
83   fSegFactory = new AliMpSegFactory();
84
85   // initialize container
86 //   fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
87   fMUONData  = data;
88
89   // initialize array
90   fSubEventArray = new TClonesArray("AliMUONSubEventTracker",1000);
91
92
93   // ddl pointer
94   fDDLTracker = new AliMUONDDLTracker();
95   fDDLTrigger = new AliMUONDDLTrigger();
96
97   fBusPatchManager = new AliMpBusPatch();
98   fBusPatchManager->ReadBusPatchFile();
99
100 }
101
102 //__________________________________________________________________________
103 AliMUONRawWriter::AliMUONRawWriter()
104   : TObject(),
105     fMUONData(0),
106     fLoader(0),    
107     fSegFactory(0),
108     fDDLTracker(0),
109     fDDLTrigger(0)
110 {
111   // Default Constructor
112   fFile[0] = fFile[1] = 0x0;
113   
114 }
115
116 //_______________________________________________________________________
117 AliMUONRawWriter::AliMUONRawWriter (const AliMUONRawWriter& rhs)
118   : TObject(rhs)
119 {
120 // Protected copy constructor
121
122   AliFatal("Not implemented.");
123 }
124
125 //_______________________________________________________________________
126 AliMUONRawWriter & 
127 AliMUONRawWriter::operator=(const AliMUONRawWriter& rhs)
128 {
129 // Protected assignement operator
130
131   if (this == &rhs) return *this;
132
133   AliFatal("Not implemented.");
134     
135   return *this;  
136 }
137
138 //__________________________________________________________________________
139 AliMUONRawWriter::~AliMUONRawWriter(void)
140 {
141   if (fSegFactory) 
142     fSegFactory->DeleteSegmentations();
143   delete fSegFactory;  
144
145   if (fSubEventArray)
146     fSubEventArray->Delete(); //using delete cos allocating memory in copy ctor.
147
148   if (fDDLTracker)
149     delete fDDLTracker;
150   if (fDDLTrigger)
151     delete fDDLTrigger;
152
153   fBusPatchManager->Delete();
154
155   return;
156 }
157 //____________________________________________________________________
158 Int_t AliMUONRawWriter::Digits2Raw()
159 {
160  // convert digits of the current event to raw data
161
162   Int_t idDDL;
163   Char_t name[20];
164
165   fLoader->LoadDigits("READ");
166
167   fMUONData->SetTreeAddress("D,GLT");
168
169
170   // tracking chambers
171
172   for (Int_t ich = 0; ich < AliMUONConstants::NTrackingCh(); ich++) {
173  
174     // open files
175     idDDL = ich * 2  + 0x900; // official number for MUON
176     sprintf(name, "MUON_%d.ddl",idDDL);
177     fFile[0] = fopen(name,"w");
178
179     idDDL = (ich * 2) + 1 + 0x900;
180     sprintf(name, "MUON_%d.ddl",idDDL);
181     fFile[1] = fopen(name,"w");
182
183     WriteTrackerDDL(ich);
184   
185     // reset and close
186     fclose(fFile[0]);
187     fclose(fFile[1]);
188     fMUONData->ResetDigits();
189   }
190  
191   // trigger chambers
192  
193   // open files
194   idDDL = 0xA00;// official number for MUTR
195   sprintf(name, "MUTR_%d.ddl",idDDL);
196   fFile[0] = fopen(name,"w");
197
198   idDDL = 0xA00 + 1;
199   sprintf(name, "MUTR_%d.ddl",idDDL);
200   fFile[1] = fopen(name,"w");
201
202   WriteTriggerDDL();
203   
204   // reset and close
205   fclose(fFile[0]);
206   fclose(fFile[1]);
207   fMUONData->ResetTrigger();
208   
209   fLoader->UnloadDigits();
210
211   return kTRUE;
212 }
213 //____________________________________________________________________
214 Int_t AliMUONRawWriter::WriteTrackerDDL(Int_t iCh)
215 {
216   // writing DDL for tracker
217   // used inverse mapping
218
219   // resets
220   TClonesArray* muonDigits = 0;
221   fSubEventArray->Clear();
222
223   //
224   TArrayI nbInBus;
225
226   nbInBus.Set(5000);
227
228   nbInBus.Reset();
229
230   // DDL header
231   AliRawDataHeader header = fDDLTracker->GetHeader();
232   Int_t headerSize = fDDLTracker->GetHeaderSize();
233
234   // DDL event one per half chamber
235   AliMUONSubEventTracker* subEvent;
236
237   // data format
238   Char_t parity = 0x4;
239   UShort_t manuId = 0;
240   UChar_t channelId = 0;
241   UShort_t charge = 0;
242   Int_t busPatchId = 0;
243
244   UInt_t word;
245   Int_t nEntries = 0;
246   Int_t* buffer = 0;
247   Int_t index;
248   Int_t indexDsp;
249   Int_t indexBlk;
250   Int_t padX;
251   Int_t padY;
252   Int_t cathode = 0;
253   Int_t detElemId;
254   Int_t nDigits;
255
256   const AliMUONDigit* digit;
257
258   AliDebug(3, Form("WriteDDL chamber %d\n", iCh+1));
259
260   // getting digits
261   fMUONData->ResetDigits();
262   fMUONData->GetDigits();
263   muonDigits = fMUONData->Digits(iCh);
264
265   nDigits = muonDigits->GetEntriesFast();
266   AliDebug(3,Form("ndigits = %d\n",nDigits));
267  
268   // loop over digit
269   for (Int_t idig = 0; idig < nDigits; idig++) {
270
271     digit = (AliMUONDigit*) muonDigits->UncheckedAt(idig);
272
273     padX = digit->PadX();
274     padY = digit->PadY();
275     charge = digit->Signal();
276     charge &= 0xFFF;
277     cathode = digit->Cathode();
278     detElemId = digit->DetElemId();
279
280     // inverse mapping
281     Int_t error = GetInvMapping(digit, busPatchId, manuId, channelId);
282     if (error) continue;
283
284     AliDebug(3,Form("input  IdDE %d busPatchId %d PadX %d PadY %d iCath %d \n", 
285                     detElemId, busPatchId, padX, padY, cathode));
286
287     AliDebug(3,Form("busPatchId %d, manuId %d channelId %d\n", busPatchId, manuId, channelId ));
288
289     //packing word
290     AliBitPacking::PackWord((UInt_t)parity,word,29,31);
291     AliBitPacking::PackWord((UInt_t)manuId,word,18,28);
292     AliBitPacking::PackWord((UInt_t)channelId,word,12,17);
293     AliBitPacking::PackWord((UInt_t)charge,word,0,11);
294
295     // set sub Event
296     subEvent = new AliMUONSubEventTracker();
297     subEvent->AddData(word);
298     subEvent->SetBusPatchId(busPatchId);
299        
300     // storing the number of identical buspatches
301     nbInBus[busPatchId]++;
302     AddData(subEvent);
303    
304     delete subEvent;
305   }
306
307   // sorting by buspatch
308   fSubEventArray->Sort();
309
310   // gather datas from same bus patch
311   nEntries = fSubEventArray->GetEntriesFast();
312
313   for (Int_t i = 0; i < nEntries; i++) {
314     AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray->At(i);
315     busPatchId = temp->GetBusPatchId();
316
317     // add bus patch header, length and total length managed by subevent class
318     temp->SetTriggerWord(0xdeadbeef);
319     for (Int_t j = 0; j < nbInBus[busPatchId]-1; j++) {
320       AliMUONSubEventTracker* temp1 =  (AliMUONSubEventTracker*)fSubEventArray->At(++i);
321       temp->AddData(temp1->GetData(0));
322       fSubEventArray->RemoveAt(i) ;
323     }
324   }
325   fSubEventArray->Compress();
326
327   if (AliLog::GetGlobalDebugLevel() == 3) {
328     nEntries = fSubEventArray->GetEntriesFast();
329     for (Int_t i = 0; i < nEntries; i++) {
330       AliMUONSubEventTracker* temp =  (AliMUONSubEventTracker*)fSubEventArray->At(i);
331       printf("busPatchid back %d\n",temp->GetBusPatchId());
332       for (Int_t j = 0; j < temp->GetLength(); j++) {
333         printf("manuId back %d, ",temp->GetManuId(j));
334         printf("channelId back %d, ",temp->GetChannelId(j));
335         printf("charge back %d\n",temp->GetCharge(j));
336       }
337     }
338     printf("\n");
339   }
340   
341   // getting info for the number of buspatches
342   Int_t iBusPatch;
343   Int_t length;
344   Int_t iBusPerDSP[5];//number of bus patches per DSP
345   Int_t iDspMax; //number max of DSP per block
346  
347   Int_t iFile = 0;
348   fBusPatchManager->GetDspInfo(iCh, iDspMax, iBusPerDSP);
349
350   TArrayI* vec = fBusPatchManager->GetBusfromDE((iCh+1)*100);
351
352   Int_t iBus0AtCh = vec->At(0); //get first bus patch id for a given ich
353         
354   AliDebug(3,Form("iBus0AtCh %d", iBus0AtCh));
355
356   iBusPatch = iBus0AtCh - 1; // starting point for each chamber
357
358   // nEntries = fSubEventArray->GetEntriesFast();
359   AliMUONSubEventTracker* temp = 0x0;
360
361   // open DDL file, on per 1/2 chamber
362   for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
363     
364
365     // filling buffer
366     buffer = new Int_t [(2048+24)*50]; // 24 words in average for one buspatch and 2048 manu info at most
367
368     indexBlk = 0;
369     indexDsp = 0;
370     index = 0;
371
372     // two blocks A and B per DDL
373     for (Int_t iBlock = 0; iBlock < 2; iBlock++) {
374
375       // block header
376       length = fDDLTracker->GetBlkHeaderLength();
377       memcpy(&buffer[index],fDDLTracker->GetBlkHeader(),length*4);
378       indexBlk = index;
379       index += length; 
380
381       // 5 DSP's max per block
382       for (Int_t iDsp = 0; iDsp < iDspMax; iDsp++) {
383
384         // DSP header
385         length = fDDLTracker->GetDspHeaderLength();
386         memcpy(&buffer[index],fDDLTracker->GetDspHeader(),length*4);
387         indexDsp = index;
388         index += length; 
389
390         // 5 buspatches max per DSP
391         for (Int_t i = 0; i < iBusPerDSP[iDsp]; i++) {
392
393           iBusPatch ++;
394           if ((fBusPatchManager->GetDDLfromBus(iBusPatch) % 2) == 1) // comparing to DDL file
395             iFile = 0;
396           else
397             iFile = 1;
398
399           AliDebug(3,Form("iCh %d iDDL %d iBlock %d iDsp %d busPatchId %d", iCh, iDDL, iBlock, iDsp, iBusPatch));
400
401           nEntries = fSubEventArray->GetEntriesFast();
402
403           for (Int_t iEntries = 0; iEntries < nEntries; iEntries++) { // method "bourrique"...
404             temp = (AliMUONSubEventTracker*)fSubEventArray->At(iEntries);
405             busPatchId = temp->GetBusPatchId();
406             if (busPatchId == iBusPatch) break;
407             busPatchId = -1;
408             AliDebug(3,Form("busPatchId %d", temp->GetBusPatchId()));
409           } 
410          
411           // check if buspatchid has digit
412           if (busPatchId != -1) {
413             // add bus patch structure
414             length = temp->GetHeaderLength();
415             memcpy(&buffer[index],temp->GetAddress(),length*4);
416             index += length;
417             for (Int_t j = 0; j < temp->GetLength(); j++) {
418               buffer[index++] =  temp->GetData(j);
419               AliDebug(3,Form("busPatchId %d, manuId %d channelId %d\n", temp->GetBusPatchId(), 
420                               temp->GetManuId(j), temp->GetChannelId(j) ));
421             }
422             //        fSubEventArray->RemoveAt(iEntries);
423             //        fSubEventArray->Compress();
424           } else {
425             // writting anyhow buspatch structure (empty ones)
426             buffer[index++] = 4; // total length
427             buffer[index++] = 0; // raw data length
428             buffer[index++] = iBusPatch; // bus patch
429             buffer[index++] = 0xdeadbeef; // trigger word
430           }
431         } // bus patch
432         buffer[indexDsp] = index - indexDsp; // dsp length
433         buffer[indexDsp+1] = index - indexDsp - fDDLTracker->GetDspHeaderLength();
434         if ((index - indexDsp) % 2 == 0)
435           buffer[indexDsp+7] = 0;
436         else
437           buffer[indexDsp+7] = 1;
438       } // dsp
439       buffer[indexBlk] = index - indexBlk; // block length
440       buffer[indexBlk+1] = index - indexBlk - fDDLTracker->GetBlkHeaderLength();
441     }
442     
443     //writting onto disk
444     // write DDL 1 & 2
445     header.fSize = (index + headerSize) * 4;// total length in bytes
446     fwrite((char*)(&header),headerSize*4,1,fFile[iFile]);
447     fwrite(buffer,sizeof(int),index,fFile[iFile]);
448    
449     delete[] buffer;
450   }
451
452   return kTRUE;
453 }
454 //____________________________________________________________________
455 Int_t AliMUONRawWriter::WriteTriggerDDL()
456 {
457
458  // DDL event one per half chamber
459   AliMUONSubEventTrigger* subEvent = 0x0;
460
461
462   // stored local id number 
463   TArrayI isFired(256);
464   isFired.Reset();
465
466
467  // DDL header
468   AliRawDataHeader header = fDDLTrigger->GetHeader();
469   Int_t headerSize = fDDLTrigger->GetHeaderSize();
470   Int_t length;
471   TClonesArray* localTrigger;
472   TClonesArray* globalTrigger;
473   AliMUONGlobalTrigger* gloTrg;
474   AliMUONLocalTrigger* locTrg = 0x0;
475
476   // getting information from trigger
477   fMUONData->GetTriggerD();
478
479   // global trigger for trigger pattern
480   globalTrigger = fMUONData->GlobalTrigger(); 
481   gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
482   Int_t gloTrigPat = GetGlobalTriggerPattern(gloTrg);
483
484   // local trigger 
485   localTrigger = fMUONData->LocalTrigger();    
486
487   UInt_t word;
488   Int_t* buffer = 0;
489   Int_t index;
490   Int_t iEntries = 0;
491   Int_t iLocCard, locCard;
492   Char_t locDec, trigY, posY, posX,regOut;
493   Int_t devX;
494   Int_t version = 1; // software version
495   Int_t eventType = 1; // trigger type: 1 for physics ?
496   Int_t serialNb = 0xF; // serial nb of card: all bits on for the moment
497   Int_t globalFlag = 1; // set to 2 if global info present in DDL else set to 1
498
499   Int_t nEntries = (Int_t) (localTrigger->GetEntries());// 234 local cards
500   // stored the local card id that's fired
501   for (Int_t i = 0; i <  nEntries; i++) {
502     locTrg = (AliMUONLocalTrigger*)localTrigger->At(i);
503     isFired[locTrg->LoCircuit()] = 1; // storing local boards with informations
504   }
505
506   if (!nEntries)
507     AliError("No Trigger information available");
508
509   buffer = new Int_t [672]; // [16(local)*5 words + 3 words]*8(reg) + 8 words = 672
510
511   // open DDL file, on per 1/2 chamber
512   for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
513     
514     index = 0; 
515
516     // DDL enhanced header
517     word = 0;
518     AliBitPacking::PackWord((UInt_t)iDDL+1,word,28,31); //see AliMUONDDLTrigger.h for details
519     AliBitPacking::PackWord((UInt_t)serialNb,word,24,27);
520     AliBitPacking::PackWord((UInt_t)version,word,16,23);
521     AliBitPacking::PackWord((UInt_t)eventType,word,12,15);
522
523     if (iDDL == 0) // suppose global info in DDL one
524       globalFlag = 2;
525     else 
526       globalFlag = 1;
527     AliBitPacking::PackWord((UInt_t)globalFlag,word,8,11);
528     fDDLTrigger->SetDDLWord(word);
529
530     if (iDDL == 0)
531       fDDLTrigger->SetGlobalOutput(gloTrigPat);// no global input for the moment....
532     else 
533       fDDLTrigger->SetGlobalOutput(0);
534     length = fDDLTrigger->GetHeaderLength(); 
535     memcpy(&buffer[index],fDDLTrigger->GetEnhancedHeader(),length*4);
536     index += length; 
537
538     // 8 regional cards per DDL
539     for (Int_t iReg = 0; iReg < 8; iReg++) {
540
541       subEvent = new AliMUONSubEventTrigger();
542
543       // Regional card header
544       word = 0;
545       regOut  = 0;
546       AliBitPacking::PackWord((UInt_t)serialNb,word,24,28); //see  AliMUONSubEventTrigger.h for details
547       AliBitPacking::PackWord((UInt_t)version,word,16,23);
548       AliBitPacking::PackWord((UInt_t)iReg,word,12,15);
549       AliBitPacking::PackWord((UInt_t)regOut,word,0,7); // whenever regional output will be implemented
550
551       subEvent->SetRegWord(word);
552       memcpy(&buffer[index++],subEvent->GetAddress(),4);
553
554       buffer[index++] = 0;// 2 words of regional input
555       buffer[index++] = 0;
556
557       // 16 local card per regional board
558       for (Int_t iLoc = 0; iLoc < 16; iLoc++) {
559
560         iLocCard = iLoc + iReg*16 + iDDL*128;
561
562         if (isFired[iLocCard]) {
563           locTrg = (AliMUONLocalTrigger*)localTrigger->At(iEntries);
564           locCard = locTrg->LoCircuit();
565           locDec  = locTrg->GetLoDecision();
566           trigY = 0;
567           posY = locTrg->LoStripY();
568           posX = locTrg->LoStripX();
569           devX = locTrg->LoDev();
570           AliDebug(4,Form("loctrg %d, posX %d, posY %d, devX %d\n", 
571                           locTrg->LoCircuit(),locTrg->LoStripX(),locTrg->LoStripY(),locTrg->LoDev()));
572         } else { //no trigger (see PRR chpt 3.4)
573           locCard = -1;
574           locDec = 0;
575           trigY = 1;
576           posY = 15;
577           posX = 0;
578           devX = 0x8;
579         }
580
581         //packing word
582         word = 0;
583         AliBitPacking::PackWord((UInt_t)(iLocCard % 16),word,19,22); //card id number in crate
584         AliBitPacking::PackWord((UInt_t)locDec,word,15,18);
585         AliBitPacking::PackWord((UInt_t)trigY,word,14,14);
586         AliBitPacking::PackWord((UInt_t)posY,word,10,13);
587         AliBitPacking::PackWord((UInt_t)devX,word,5,9);
588         AliBitPacking::PackWord((UInt_t)posX,word,0,4);
589
590         if (locCard == iLocCard) {
591           // add local cards structure
592           buffer[index++] = (locTrg->GetX1Pattern() | (locTrg->GetX2Pattern() << 16));
593           buffer[index++] = (locTrg->GetX3Pattern() | (locTrg->GetX4Pattern() << 16));
594           buffer[index++] = (locTrg->GetY1Pattern() | (locTrg->GetY2Pattern() << 16));
595           buffer[index++] = (locTrg->GetY3Pattern() | (locTrg->GetY4Pattern() << 16));
596           buffer[index++] = (Int_t)word; // data word
597           if (iEntries < nEntries-1)
598             iEntries++;
599         } else {
600           buffer[index++] = 0; // 4 words for x1, x2, y1, y2
601           buffer[index++] = 0; 
602           buffer[index++] = 0; 
603           buffer[index++] = 0; 
604           buffer[index++] = (Int_t)word; // data word
605
606         }
607       } // local card 
608
609       delete subEvent;  
610
611     } // Regional card
612     
613     buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word
614     buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word for 64 bits transfer purpose
615
616     // writting onto disk
617     // write DDL 1
618     header.fSize = (index + headerSize) * 4;// total length in bytes
619     fwrite((char*)(&header),headerSize*4,1,fFile[iDDL]);
620     fwrite(buffer,sizeof(int),index,fFile[iDDL]);
621   
622   }
623   delete[] buffer;
624
625   return kTRUE;
626 }
627
628 //____________________________________________________________________
629 Int_t AliMUONRawWriter::GetInvMapping(const AliMUONDigit* digit,
630                                      Int_t &busPatchId, UShort_t &manuId, UChar_t &channelId)
631 {
632
633   // Inverse mapping for tracker
634
635   // information from digits
636   Int_t iCath = digit->Cathode();
637   Int_t idDE  = digit->DetElemId();
638   Int_t padX  = digit->PadX();
639   Int_t padY  = digit->PadY();
640
641   if (idDE >= 500) { // Since in AliMpSlat pads begin at (0,0) 
642     padX--;         // while in AliMUONSt345Seg. they begin at (1,1)
643     padY--;
644   }
645
646   // segmentation
647   AliMpPlaneType plane;
648   AliMpPlaneType plane1 = kBendingPlane;
649   AliMpPlaneType plane2 = kNonBendingPlane;
650
651   if (idDE < 500) { // should use GetDirection somehow (ChF)
652     if ( ((idDE % 100) % 2) != 0 ) {
653       plane1 = kNonBendingPlane;
654       plane2 = kBendingPlane;
655     }
656   }
657   // station 345 bending == cath0 for the moment
658    plane = (iCath == 0) ? plane1 : plane2;
659
660   //AliMpVSegmentation* seg = AliMUONSegmentationManager::Segmentation(idDE, plane);
661   AliMpVSegmentation* seg = fSegFactory->CreateMpSegmentation(idDE, iCath);
662   AliMpPad pad = seg->PadByIndices(AliMpIntPair(padX,padY),kTRUE);
663
664   if(!pad.IsValid()) {
665      AliWarning(Form("No elec. for idDE: %d, padx: %d pady %d, charge: %d\n",
666                   idDE, digit->PadX(), digit->PadY(), digit->Signal()));
667     return kTRUE;
668   }
669
670   // Getting Manu id
671   manuId = pad.GetLocation().GetFirst();
672   manuId &= 0x7FF; // 11 bits 
673
674   // Getting channel id
675   channelId =  pad.GetLocation().GetSecond();
676   channelId &= 0x3F; // 6 bits
677
678   // Getting buspatch id
679   TArrayI* vec = fBusPatchManager->GetBusfromDE(idDE);
680   Int_t pos;
681
682   if (idDE < 500) { // station 1 & 2
683     // set 32 manus for one bus patch ? (ChF)
684     pos = manuId/32;
685   } else {
686     // offset of 100 in manuId for following bus patch
687     pos = manuId/100;
688   }
689
690  //  if (pos >(int_t) vec.size())
691 //     AliWarning("pos greater than size\n");
692   busPatchId = vec->At(pos);
693
694   if (plane ==  kNonBendingPlane) // for Non-Bending manuid+= 1000;
695     manuId += 1000; // tmp solution til one finds something better  (ChF)
696   
697   AliDebug(3,Form("idDE: %d, busPatchId %d, manuId: %d, channelId:%d\n",
698                   idDE, busPatchId, manuId, channelId));
699
700   AliDebug(3,Form("idDE: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady: %d, charge: %d\n",
701                   idDE, busPatchId, manuId, channelId, digit->PadX(), digit->PadY(), digit->Signal()));
702
703   return kFALSE; // no error
704 }
705
706 //____________________________________________________________________
707 Int_t AliMUONRawWriter::GetGlobalTriggerPattern(const AliMUONGlobalTrigger* gloTrg) const
708 {
709   // global trigger pattern calculation
710
711   Int_t gloTrigPat = 0;
712
713   if (gloTrg->SinglePlusLpt())  gloTrigPat|= 0x1;
714   if (gloTrg->SinglePlusHpt())  gloTrigPat|= 0x2;
715   if (gloTrg->SinglePlusApt())  gloTrigPat|= 0x4;
716  
717   if (gloTrg->SingleMinusLpt()) gloTrigPat|= 0x8;
718   if (gloTrg->SingleMinusHpt()) gloTrigPat|= 0x10;
719   if (gloTrg->SingleMinusApt()) gloTrigPat|= 0x20;
720  
721   if (gloTrg->SingleUndefLpt()) gloTrigPat|= 0x40;
722   if (gloTrg->SingleUndefHpt()) gloTrigPat|= 0x80;
723   if (gloTrg->SingleUndefApt()) gloTrigPat|= 0x100;
724  
725   if (gloTrg->PairUnlikeLpt())  gloTrigPat|= 0x200;
726   if (gloTrg->PairUnlikeHpt())  gloTrigPat|= 0x400;
727   if (gloTrg->PairUnlikeApt())  gloTrigPat|= 0x800;
728
729   if (gloTrg->PairLikeLpt())    gloTrigPat|= 0x1000;
730   if (gloTrg->PairLikeHpt())    gloTrigPat|= 0x2000;
731   if (gloTrg->PairLikeApt())    gloTrigPat|= 0x4000;
732
733   return gloTrigPat;
734 }