Redefinition of macro to avoid warnings
[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 /* $Id$ */
17
18 //-----------------------------------------------------------------------------
19 /// \class AliMUONRawWriter
20 /// MUON Raw Data generaton in ALICE-MUON
21 /// Raw data structure could be found in Alice-note.
22 ///
23 /// Implemented non-constant buspatch numbers for tracking
24 /// with correct DDL id (first guess)
25 /// (Ch. Finck, dec 2005)
26 ///
27 /// Digits2Raw:
28 /// Generates raw data for MUON tracker and finally for trigger
29 /// Using real mapping (inverse) for tracker
30 /// For trigger there is no mapping (mapping could be found in AliMUONTriggerCircuit)
31 /// Ch. Finck, July 04
32 /// Use memcpy instead of assignment elt by elt
33 /// Introducing variable DSP numbers, real manu numbers per buspatch for st12
34 /// Implemented scaler event for Trigger
35 /// Ch. Finck, Jan. 06
36 /// Using bus itr in DDL instead of simple incrementation
37 /// treat correctly the DDL & buspatch for station 3.
38 /// Using informations from AliMUONTriggerCrateStore for 
39 /// empty slots and non-notified cards in trigger crates.
40 /// Ch. Finck, August 06.
41 /// Using AliMpDDLStore::GetBusPatchId.
42 ///
43 /// \author Ch. Finck, Feb. 07.
44 //-----------------------------------------------------------------------------
45
46
47 #include "AliMUONRawWriter.h"
48
49 #include "AliMUONBlockHeader.h"
50 #include "AliMUONBusStruct.h"
51 #include "AliMUONConstants.h"
52 #include "AliMUONDarcHeader.h"
53 #include "AliMUONVDigit.h"
54 #include "AliMUONVDigitStore.h"
55 #include "AliMUONDspHeader.h"
56 #include "AliMUONGlobalTrigger.h"
57 #include "AliMUONLocalStruct.h"
58 #include "AliMUONLocalTrigger.h"
59 #include "AliMUONLocalTriggerBoard.h"
60 #include "AliMUONRegionalTrigger.h"
61 #include "AliMUONRegHeader.h"
62
63 #include "AliMUONVTriggerStore.h"
64 #include "AliCodeTimer.h"
65
66 #include "AliMpDDLStore.h"
67 #include "AliMpDDL.h"
68 #include "AliMpRegionalTrigger.h"
69 #include "AliMpTriggerCrate.h"
70 #include "AliMpLocalBoard.h"
71 #include "AliMpDetElement.h"
72 #include "AliMpDEManager.h"
73 #include "AliMpExMap.h"
74 #include "AliMpConstants.h"
75 #include "AliMpPlaneType.h"
76 #include "AliMpSegmentation.h"
77 #include "AliMpStationType.h"
78 #include "AliMpVSegmentation.h"
79
80 #include "AliRawReader.h"
81 #include "AliRawDataHeaderSim.h"
82 #include "AliBitPacking.h" 
83 #include "AliDAQ.h"
84 #include "AliLog.h"
85
86 #include "TObjArray.h"
87 #include "TStopwatch.h"
88 #include <Riostream.h>
89
90 /// \cond CLASSIMP
91 ClassImp(AliMUONRawWriter) // Class implementation in ROOT context
92 /// \endcond
93
94 //__________________________________________________________________________
95 AliMUONRawWriter::AliMUONRawWriter()
96   : TObject(),
97     fBlockHeader(new AliMUONBlockHeader()),
98     fDspHeader(new AliMUONDspHeader()),
99     fDarcHeader(new AliMUONDarcHeader()),
100     fRegHeader(new AliMUONRegHeader()),
101     fLocalStruct(new AliMUONLocalStruct()),
102     fDDLStore(AliMpDDLStore::Instance()),
103     fScalerEvent(kFALSE),
104     fHeader(0x0),
105     fBufferSize((((43*AliMpConstants::ManuNofChannels() + 4)*5 + 10)*5 + 8)*2),
106     fBuffer(new Int_t [fBufferSize])
107 {
108   /// Standard Constructor
109
110   AliDebug(1,"Standard ctor");
111
112   // setting data key to default value (only for writting)
113   fBlockHeader->SetDataKey(fBlockHeader->GetDefaultDataKey());
114   fDspHeader->SetDataKey(fDspHeader->GetDefaultDataKey());
115
116 }
117
118 //__________________________________________________________________________
119 AliMUONRawWriter::~AliMUONRawWriter(void)
120 {
121   /// Destructor
122
123   AliDebug(1,"dtor");
124   
125   delete fBlockHeader;
126   delete fDspHeader;
127   delete fDarcHeader;
128   delete fRegHeader;
129   delete fLocalStruct;
130   delete[] fBuffer;
131 }
132
133 //____________________________________________________________________
134 void  AliMUONRawWriter::LocalWordPacking(UInt_t& word, UInt_t locId, UInt_t locDec, 
135                                          UInt_t trigY, UInt_t posY, UInt_t posX, 
136                                          UInt_t sdevX, UInt_t devX)
137 {
138 /// pack local trigger word
139
140     AliBitPacking::PackWord(locId,word,19,22); //card id number in crate
141     AliBitPacking::PackWord(locDec,word,15,18);
142     AliBitPacking::PackWord(trigY,word,14,14);
143     AliBitPacking::PackWord(posY,word,10,13);
144     AliBitPacking::PackWord(sdevX,word,9,9);
145     AliBitPacking::PackWord(devX,word,5,8);
146     AliBitPacking::PackWord(posX,word,0,4);
147
148 }
149
150 //____________________________________________________________________
151 Int_t AliMUONRawWriter::Digits2Raw(AliMUONVDigitStore* digitStore,
152                                    AliMUONVTriggerStore* triggerStore)
153 {
154   /// convert digits of the current event to raw data
155
156   AliCodeTimerAuto("",)
157   
158   Int_t idDDL;
159   Char_t name[255];
160
161   // tracking chambers
162   
163   if ( digitStore ) 
164   {
165     AliCodeTimerAuto("for Tracker",0)
166
167     AliMpExMap busPatchMap;
168
169     Int_t nDDLs = AliDAQ::NumberOfDdls("MUONTRK");
170     
171     Int_t nofBusPatches(0);
172     
173     for (Int_t iDDL = 0; iDDL < nDDLs; ++iDDL ) 
174     {
175       AliMpDDL* ddl = fDDLStore->GetDDL(iDDL);
176       nofBusPatches += ddl->GetNofBusPatches();
177     }
178     
179     busPatchMap.SetSize(nofBusPatches);
180     
181     Digits2BusPatchMap(*digitStore,busPatchMap);
182
183     for (Int_t iDDL = 0; iDDL < nDDLs; ++iDDL ) 
184     {
185       WriteTrackerDDL(busPatchMap,iDDL);
186     }
187     AliDebug(1,"Tracker written");
188   }
189  
190   if ( triggerStore )
191   {
192     AliCodeTimerAuto("for Trigger",1)
193
194     // trigger chambers
195     
196     AliFstream* file[2];
197     
198     // open files
199     idDDL = 0;// MUTR
200     strcpy(name,AliDAQ::DdlFileName("MUONTRG",idDDL));
201     file[0] = new AliFstream(name);
202     
203     idDDL = 1;// MUTR
204     strcpy(name,AliDAQ::DdlFileName("MUONTRG",idDDL));
205     file[1] = new AliFstream(name);
206       
207     WriteTriggerDDL(*triggerStore,file);
208       
209     // reset and close
210     delete file[0];
211     delete file[1];
212       
213     AliDebug(1,"Trigger written");
214   }
215   
216   return kTRUE;
217 }
218
219 //______________________________________________________________________________
220 void 
221 AliMUONRawWriter::Digits2BusPatchMap(const AliMUONVDigitStore& digitStore,
222                                      AliMpExMap& busPatchMap)
223 {
224   /// Create bus patch structures corresponding to digits in the store
225   
226   AliCodeTimerAuto("",)
227   
228   static const Int_t kMAXADC = (1<<12)-1; // We code the charge on a 12 bits ADC.
229     
230   // DDL event one per half chamber
231   
232   // raw data
233   Char_t parity = 0x4;
234   UShort_t manuId = 0;
235   UChar_t channelId = 0;
236   UShort_t charge = 0;
237   Int_t busPatchId = 0;
238   Int_t currentBusPatchId = -1;
239   UInt_t word;
240   
241   AliMUONBusStruct* busStruct(0x0);
242   
243   TIter next(digitStore.CreateTrackerIterator());
244   AliMUONVDigit* digit;
245   
246   while ( ( digit = static_cast<AliMUONVDigit*>(next()) ) )
247   {
248     charge = digit->ADC();
249     if ( charge > kMAXADC )
250     {
251       // This is most probably an error in the digitizer (which should insure
252       // the adc is below kMAXADC), so make it a (non-fatal) error indeed.
253       AliError(Form("adc value %d above 0x%x for DE %d . Setting to 0x%x. Digit is:",
254                     charge,kMAXADC,digit->DetElemId(),kMAXADC));
255       StdoutToAliError(digit->Print());
256       charge = kMAXADC;
257     }
258     
259     // inverse mapping
260     busPatchId = GetBusPatch(*digit);
261
262     if (busPatchId<0) continue;
263     
264     if ( digit->ManuId() > 0x7FF ||
265          digit->ManuChannel() > 0x3F )
266     {
267       StdoutToAliError(digit->Print(););
268       AliFatal("ManuId,ManuChannel are invalid for the digit above.");
269     }
270     
271     manuId = ( digit->ManuId() & 0x7FF ); // 11 bits
272     channelId = ( digit->ManuChannel() & 0x3F ); // 6 bits
273     
274     //packing word
275     word = 0;
276     AliBitPacking::PackWord((UInt_t)manuId,word,18,28);
277     AliBitPacking::PackWord((UInt_t)channelId,word,12,17);
278     AliBitPacking::PackWord((UInt_t)charge,word,0,11);
279     
280     // parity word
281     parity = word & 0x1;
282     for (Int_t i = 1; i <= 30; ++i) 
283     {
284       parity ^=  ((word >> i) & 0x1);
285     }
286     AliBitPacking::PackWord((UInt_t)parity,word,31,31);
287
288     if ( currentBusPatchId != busPatchId ) 
289     {
290       busStruct = 
291         static_cast<AliMUONBusStruct*>(busPatchMap.GetValue(busPatchId));
292       currentBusPatchId = busPatchId;
293     }
294     
295     if (!busStruct)
296     {
297       busStruct = new AliMUONBusStruct;
298       busStruct->SetDataKey(busStruct->GetDefaultDataKey());
299       busStruct->SetBusPatchId(busPatchId);
300       busStruct->SetLength(0);
301       busPatchMap.Add(busPatchId,busStruct);
302     }
303     
304     // set sub Event
305     busStruct->AddData(word);
306   }
307 }
308
309 //______________________________________________________________________________
310 void
311 AliMUONRawWriter::WriteTrackerDDL(AliMpExMap& busPatchMap, Int_t iDDL)
312 {
313   /// Write DDL file for one tracker DDL
314   
315   // buffer size (max'ed out)
316   // (((43 manus max per bus patch *64 channels + 4 bus patch words) * 5 bus patch 
317   //   + 10 dsp words)*5 dsps + 8 block words)*2 blocks 
318  
319   AliCodeTimerAuto("",)
320
321   if (fHeader == 0x0) {
322     AliError("Raw data header must be set");
323     return;
324   }
325   memset(fBuffer,0,fBufferSize*sizeof(Int_t));
326   
327   AliMpDDL* ddl = fDDLStore->GetDDL(iDDL);
328   Int_t iDspMax = ddl->GetMaxDsp();
329   Int_t iBusPerDSP[5]; //number of bus patches per DSP
330   ddl->GetBusPerDsp(iBusPerDSP);
331   Int_t busIter = 0;
332   
333   Int_t totalDDLLength = 0;
334   
335   Int_t index = 0;
336   
337   // two blocks A and B per DDL
338   for (Int_t iBlock = 0; iBlock < 2; ++iBlock) 
339   {
340     // block header
341     Int_t length = fBlockHeader->GetHeaderLength();
342     memcpy(&fBuffer[index],fBlockHeader->GetHeader(),length*4);
343     Int_t indexBlk = index;
344     index += length; 
345     
346     // 5 DSP's max per block
347     for (Int_t iDsp = 0; iDsp < iDspMax; ++iDsp) 
348     {
349       // DSP header
350       Int_t dspHeaderLength = fDspHeader->GetHeaderLength();
351       memcpy(&fBuffer[index],fDspHeader->GetHeader(),dspHeaderLength*4);
352       Int_t indexDsp = index;
353       index += dspHeaderLength; 
354       
355       // 5 buspatches max per DSP
356       for (Int_t i = 0; i < iBusPerDSP[iDsp]; ++i) 
357       {
358         Int_t iBusPatch = ddl->GetBusPatchId(busIter++);
359         
360         // iteration over bus patch in DDL
361         if (iBusPatch == -1) 
362         {
363           AliWarning(Form("Error in bus itr in DDL %d\n", iDDL));
364           continue;
365         }
366         
367         AliMUONBusStruct* busStructPtr = static_cast<AliMUONBusStruct*>(busPatchMap.GetValue(iBusPatch));
368         
369         // check if buspatchid has digit
370         if (busStructPtr) 
371         {
372           // add bus patch structure header
373           Int_t busHeaderLength = busStructPtr->GetHeaderLength();
374           memcpy(&fBuffer[index],busStructPtr->GetHeader(),busHeaderLength*4);
375           index += busHeaderLength;
376           
377           // add bus patch data
378           Int_t busLength = busStructPtr->GetLength();
379           memcpy(&fBuffer[index],busStructPtr->GetData(),busLength*4);
380           index += busLength;
381         } 
382         else 
383         {
384           // writting anyhow buspatch structure (empty ones)
385           fBuffer[index++] = busStructPtr->GetDefaultDataKey(); // fill it also for empty data size
386           fBuffer[index++] = busStructPtr->GetHeaderLength(); // header length
387           fBuffer[index++] = 0; // raw data length
388           fBuffer[index++] = iBusPatch; // bus patch
389         }
390       } // bus patch
391       
392       // check if totalLength even
393       // set padding word in case
394       // Add one word 0xBEEFFACE at the end of DSP structure
395       Int_t totalDspLength  = index - indexDsp;
396       if ((totalDspLength % 2) == 1) 
397       { 
398         fBuffer[indexDsp + fDspHeader->GetHeaderLength() - 2] = 1;
399         fBuffer[index++] = fDspHeader->GetDefaultPaddingWord();
400         totalDspLength++;
401       }
402       
403       Int_t dspLength     = totalDspLength - fDspHeader->GetHeaderLength();
404       
405       fBuffer[indexDsp+1] = totalDspLength; // dsp total length
406       fBuffer[indexDsp+2] = dspLength; // data length  
407       
408     } // dsp
409     
410     Int_t totalBlkLength  = index - indexBlk;
411     Int_t blkLength       = totalBlkLength - fBlockHeader->GetHeaderLength();
412     totalDDLLength       += totalBlkLength;
413     
414     fBuffer[indexBlk+1] = totalBlkLength; // total block length
415     fBuffer[indexBlk+2] = blkLength;
416         
417   } // block
418   
419     // add twice the end of CRT structure data key
420     // hope it's good placed (ChF)
421     fBuffer[index++] = fBlockHeader->GetDdlDataKey();
422     fBuffer[index++] = fBlockHeader->GetDdlDataKey();
423     totalDDLLength  += 2;
424   
425   // writting onto disk
426   // total length in bytes
427   // DDL header
428
429   Int_t headerSize = sizeof(AliRawDataHeader)/4;
430   
431   fHeader->fSize = (totalDDLLength + headerSize) * 4;
432   
433   AliFstream* file = new AliFstream(AliDAQ::DdlFileName("MUONTRK",iDDL));
434   
435   file->WriteBuffer((char*)fHeader,headerSize*4);
436   file->WriteBuffer((char*)fBuffer,sizeof(int)*index);
437   delete file;
438 }
439
440 //______________________________________________________________________________
441 Int_t AliMUONRawWriter::GetBusPatch(const AliMUONVDigit& digit) const
442 {
443   /// Determine the BusPatch this digit belongs to.
444
445     return fDDLStore->GetBusPatchId(digit.DetElemId(),digit.ManuId());
446 }
447
448 //______________________________________________________________________________
449 Int_t AliMUONRawWriter::WriteTriggerDDL(const AliMUONVTriggerStore& triggerStore, AliFstream* file[2])
450 {
451   /// Write trigger DDL
452   
453   AliCodeTimerAuto("",)
454
455   if (fHeader == 0x0) {
456     AliError("Raw data header must be set");
457     return 0;
458   }
459
460  // DDL event one per half chamber
461
462  // DDL header size
463   Int_t headerSize = sizeof(AliRawDataHeader)/4;
464
465   // global trigger for trigger pattern
466   AliMUONGlobalTrigger* gloTrg = triggerStore.Global();
467   if (!gloTrg) 
468   {
469     return 0;
470   }
471   
472   Int_t gloTrigResp = gloTrg->GetGlobalResponse();
473   UInt_t *gloTrigInput = gloTrg->GetGlobalInput();
474
475   UInt_t word;
476   Int_t* buffer = 0;
477   Int_t index;
478   Int_t locCard;
479   UChar_t locDec, trigY, posY, posX, regOut;
480   UInt_t regInpLpt;
481   UInt_t regInpHpt;
482
483   UInt_t devX;
484   UChar_t sdevX;
485   UInt_t version = 1; // software version
486   UInt_t eventPhys = 1; // trigger type: 1 for physics, 0 for software
487   UInt_t serialNb = 0xF; // serial nb of card: all bits on for the moment
488   Int_t globalFlag = 0; // set to 1 if global info present in DDL else set to 0
489
490   // size of headers
491   static const Int_t kDarcHeaderLength   = fDarcHeader->GetDarcHeaderLength();
492   static const Int_t kGlobalHeaderLength = fDarcHeader->GetGlobalHeaderLength();
493   static const Int_t kDarcScalerLength   = fDarcHeader->GetDarcScalerLength();
494   static const Int_t kGlobalScalerLength = fDarcHeader->GetGlobalScalerLength();
495   static const Int_t kRegHeaderLength    = fRegHeader->GetHeaderLength();
496   static const Int_t kRegScalerLength    = fRegHeader->GetScalerLength();
497   static const Int_t kLocHeaderLength    = fLocalStruct->GetLength();
498   static const Int_t kLocScalerLength    = fLocalStruct->GetScalerLength();
499
500   // [16(local)*6 words + 6 words]*8(reg) + 8 words = 824 
501   static const Int_t kBufferSize = (16 * (kLocHeaderLength+1) +  (kRegHeaderLength+1))* 8 
502       +  kDarcHeaderLength + kGlobalHeaderLength + 2;
503
504   // [16(local)*51 words + 16 words]*8(reg) + 8 + 10 + 8 words scaler event 6682 words
505   static const Int_t kScalerBufferSize = (16 * (kLocHeaderLength +  kLocScalerLength +1) +  
506                                          (kRegHeaderLength + kRegScalerLength +1))* 8 +
507                                          (kDarcHeaderLength + kDarcScalerLength + 
508                                           kGlobalHeaderLength + kGlobalScalerLength + 2);
509   if(fScalerEvent) {
510     eventPhys = 0; //set to generate scaler events
511     fHeader->fWord2 |= (0x1 << 14); // set L1SwC bit on
512   }
513   if(fScalerEvent)
514     buffer = new Int_t [kScalerBufferSize];
515   else
516     buffer = new Int_t [kBufferSize];
517
518   // reset crate
519
520   // open DDL file, on per 1/2 chamber
521   for ( Int_t iDDL = 0; iDDL < 2; ++iDDL ) 
522   {
523     index = 0; 
524
525     if (iDDL == 0) // suppose global info in DDL one
526       globalFlag = 1;
527     else 
528       globalFlag = 0;
529
530     word = 0;
531     // set darc status word
532     // see AliMUONDarcHeader.h for details
533     AliBitPacking::PackWord((UInt_t)eventPhys,word,30,30);
534     AliBitPacking::PackWord((UInt_t)serialNb,word,20,23);
535     AliBitPacking::PackWord((UInt_t)globalFlag,word,10,10);
536     AliBitPacking::PackWord((UInt_t)version,word,12,19);
537     fDarcHeader->SetWord(word);
538
539     memcpy(&buffer[index], fDarcHeader->GetHeader(), (kDarcHeaderLength)*4); 
540     index += kDarcHeaderLength;
541
542     // no global input for the moment....
543     if (iDDL == 0) {
544       fDarcHeader->SetGlobalOutput(gloTrigResp);
545       for (Int_t ii = 0; ii < 4; ii++) {
546         fDarcHeader->SetGlobalInput(gloTrigInput[ii],ii);
547       }
548     } else {
549       fDarcHeader->SetGlobalOutput(0);
550     }
551
552     if (fScalerEvent) {
553       // 6 DARC scaler words
554       memcpy(&buffer[index], fDarcHeader->GetDarcScalers(),kDarcScalerLength*4);
555       index += kDarcScalerLength;
556     }
557     // end of darc word
558     buffer[index++] = fDarcHeader->GetEndOfDarc();
559
560     // 4 words of global board input + Global board output
561     memcpy(&buffer[index], fDarcHeader->GetGlobalInput(), (kGlobalHeaderLength)*4); 
562     index += kGlobalHeaderLength; 
563
564     if (fScalerEvent) {
565       // 10 Global scaler words
566       memcpy(&buffer[index], fDarcHeader->GetGlobalScalers(), kGlobalScalerLength*4);
567       index += kGlobalScalerLength;
568     }
569
570     // end of global word
571     buffer[index++] = fDarcHeader->GetEndOfGlobal();
572     const AliMpRegionalTrigger* reg = AliMpDDLStore::Instance()->GetRegionalTrigger(); 
573
574     Int_t nCrate = reg->GetNofTriggerCrates()/2;
575     // 8 regional cards per DDL
576     for (Int_t iReg = 0; iReg < nCrate; ++iReg) {
577
578         // crate info
579       AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->GetTriggerCrate(iDDL, iReg);
580
581       if (!crate) 
582         AliWarning(Form("Missing crate number %d in DDL %d\n", iReg, iDDL));
583
584       // regional info tree, make sure that no reg card missing
585       AliMUONRegionalTrigger* regTrg  = triggerStore.FindRegional(crate->GetId());
586       if (!regTrg) 
587         AliError(Form("Missing regional board %d in trigger Store\n", crate->GetId()));
588     
589       // Regional card header
590       word = 0;
591
592       // set darc status word
593       fRegHeader->SetDarcWord(word);
594
595       regOut    = regTrg->GetOutput();
596       regInpLpt = regTrg->GetLocalOutput(0);
597       regInpHpt = regTrg->GetLocalOutput(1);
598
599       // fill darc word, not darc status for the moment (empty)
600       //see  AliMUONRegHeader.h for details
601       AliBitPacking::PackWord((UInt_t)eventPhys,word,31,31); 
602       AliBitPacking::PackWord((UInt_t)serialNb,word,20,25); 
603       AliBitPacking::PackWord((UInt_t)version,word,8,15);
604       AliBitPacking::PackWord((UInt_t)crate->GetId(),word,16,19);
605       AliBitPacking::PackWord((UInt_t)regOut,word,0,7); 
606       fRegHeader->SetWord(word);
607
608
609       // fill header later, need local response
610       Int_t indexReg = index;
611       index += kRegHeaderLength;
612
613       // 11 regional scaler word
614       if (fScalerEvent) {
615         memcpy(&buffer[index], fRegHeader->GetScalers(), kRegScalerLength*4);
616         index += kRegScalerLength;
617       }
618
619       // end of regional word
620       buffer[index++] = fRegHeader->GetEndOfReg();
621       
622       // 16 local card per regional board
623       //      UShort_t localMask = 0x0;
624       
625       Int_t nLocalBoard = AliMpConstants::LocalBoardNofChannels();
626
627       for (Int_t iLoc = 0; iLoc < nLocalBoard; iLoc++) {
628           
629         // slot zero for Regional card
630         Int_t localBoardId = crate->GetLocalBoardId(iLoc);
631
632         if (localBoardId) { // if not empty slot
633           AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(localBoardId);
634
635           if (localBoard->IsNotified()) {// if notified board 
636             AliMUONLocalTrigger* locTrg = triggerStore.FindLocal(localBoardId);
637
638             locCard = locTrg->LoCircuit();
639             locDec  = locTrg->GetLoDecision();
640             trigY   = locTrg->LoTrigY();
641             posY    = locTrg->LoStripY();
642             posX    = locTrg->LoStripX();
643             devX    = locTrg->LoDev();
644             sdevX   = locTrg->LoSdev();
645                   
646             AliDebug(4,Form("loctrg %d, posX %d, posY %d, devX %d\n", 
647                             locTrg->LoCircuit(),locTrg->LoStripX(),locTrg->LoStripY(),locTrg->LoDev()));  
648             //packing word
649             word = 0;
650             LocalWordPacking(word, (UInt_t)iLoc, (UInt_t)locDec, (UInt_t)trigY, (UInt_t)posY, 
651                              (UInt_t)posX, (UInt_t)sdevX, (UInt_t)devX);
652
653             buffer[index++] = (locTrg->GetX1Pattern() | (locTrg->GetX2Pattern() << 16));
654             buffer[index++] = (locTrg->GetX3Pattern() | (locTrg->GetX4Pattern() << 16));
655             buffer[index++] = (locTrg->GetY1Pattern() | (locTrg->GetY2Pattern() << 16));
656             buffer[index++] = (locTrg->GetY3Pattern() | (locTrg->GetY4Pattern() << 16));
657             buffer[index++] = (Int_t)word; // data word
658                       
659                 
660           }
661           // fill copy card X-Y inputs from the notified cards 
662           if (localBoard->GetInputXfrom() && localBoard->GetInputYfrom()) 
663           {
664             // not triggered
665             locDec = 0; trigY = 1; posY = 15;    
666             posX   = 0; devX  = 0; sdevX = 1;
667             LocalWordPacking(word, (UInt_t)iLoc, (UInt_t)locDec, (UInt_t)trigY, (UInt_t)posY, 
668                              (UInt_t)posX, (UInt_t)sdevX, (UInt_t)devX);
669
670             Int_t localFromId = localBoard->GetInputXfrom();
671             AliMUONLocalTrigger* locTrgfrom  = triggerStore.FindLocal(localFromId);
672
673             buffer[index++] = 0; // copy only X3-4 & Y1-4
674             buffer[index++] = (locTrgfrom->GetX3Pattern() | (locTrgfrom->GetX4Pattern() << 16));
675             buffer[index++] = (locTrgfrom->GetY1Pattern() | (locTrgfrom->GetY2Pattern() << 16));
676             buffer[index++] = (locTrgfrom->GetY3Pattern() | (locTrgfrom->GetY4Pattern() << 16));
677             buffer[index++] = word;
678           }
679
680         } else { 
681           // fill with 10CDEAD word for empty slots
682           for (Int_t i = 0; i < fLocalStruct->GetLength(); i++)
683               buffer[index++] = fLocalStruct->GetDisableWord(); 
684         }// condition localBoard
685           
686         // 45 regional scaler word
687         if (fScalerEvent) {
688           memcpy(&buffer[index], fLocalStruct->GetScalers(), kLocScalerLength*4);
689           index += kLocScalerLength;
690         }
691           
692         // end of local structure words
693         buffer[index++] = fLocalStruct->GetEndOfLocal();
694           
695       } // local card 
696       // fill regional header with local output
697       fRegHeader->SetInput(regInpLpt, 0);
698       fRegHeader->SetInput(regInpHpt, 1);
699       memcpy(&buffer[indexReg],fRegHeader->GetHeader(),kRegHeaderLength*4);
700       
701     } // Regional card
702     
703
704     // writting onto disk
705     // write DDL's
706     fHeader->fSize = (index + headerSize) * 4;// total length in bytes
707     file[iDDL]->WriteBuffer((char*)fHeader,headerSize*4);
708     file[iDDL]->WriteBuffer((char*)buffer,sizeof(int)*index);
709   
710   }
711   delete[] buffer;
712
713   return kTRUE;
714 }
715
716 //____________________________________________________________________
717 void AliMUONRawWriter::SetScalersNumbers()
718 {
719   /// set numbers for scaler events for trigger headers
720   /// since this is provided by the experiment
721   /// put dummy numbers to check the monitoring
722
723   fDarcHeader->SetScalersNumbers();
724   fRegHeader->SetScalersNumbers();
725   fLocalStruct->SetScalersNumbers();
726  
727   fScalerEvent = kTRUE;
728 }
729