Implemented write and read methods (with real mapping for tracker chamber) (Christian)
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Sep 2005 09:28:35 +0000 (09:28 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 22 Sep 2005 09:28:35 +0000 (09:28 +0000)
MUON/AliMUONDigit.h
MUON/AliMUONRawData.cxx
MUON/AliMUONRawData.h
MUON/AliMUONReconstructor.cxx
MUON/AliMUONReconstructor.h
MUON/Config.C
MUON/README
MUON/mapping/data/DetElemIdToBusPatch.dat [new file with mode: 0644]

index 37cf08b..bdf7539 100644 (file)
@@ -37,6 +37,7 @@ class AliMUONDigit : public TObject {
     virtual void     SetDetElemId(Int_t id)    {fDetElemId = id;}
     virtual void     SetPadX(Int_t pad)        {fPadX = pad;}
     virtual void     SetPadY(Int_t pad)        {fPadY = pad;}
+    virtual void     SetSignal(Int_t q)        {fSignal = q;}
     virtual void     AddSignal(Int_t q)        {fSignal += q;}
     virtual void     AddPhysicsSignal(Int_t q) {fPhysics += q;}
     virtual void     SetHit(Int_t n)           {fHit = n;}    
index ba7ef6d..2df9c58 100644 (file)
@@ -29,6 +29,9 @@
 // Indranil Das (Adapted for runloader: Ch. Finck) july 05
 ////////////////////////////////////
 
+#include <fstream>
+#include <string>
+
 #include <TClonesArray.h>
 #include "AliMUONRawData.h"
 #include "AliMUONDigit.h"
 #include "AliMUONGlobalTrigger.h"
 
 #include "AliMUONGeometrySegmentation.h"
+#include "AliMUONGeometryModule.h"
+#include "AliMUONGeometryStore.h"
+#include "AliMUONSegmentationManager.h"
+#include "AliMpPlaneType.h"
+#include "AliMpVSegmentation.h"
+#include "AliMpHelper.h"
+#include "AliMpPad.h"
 #include "AliLog.h"
 #include "AliRun.h"
 
@@ -56,7 +66,7 @@
 
 ClassImp(AliMUONRawData) // Class implementation in ROOT context
 //__________________________________________________________________________
-  AliMUONRawData::AliMUONRawData(AliLoader* loader)
+AliMUONRawData::AliMUONRawData(AliLoader* loader)
   : TObject()
 {
   // Standard Constructor
@@ -68,13 +78,15 @@ ClassImp(AliMUONRawData) // Class implementation in ROOT context
   fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
 
   // initialize array
-  fSubEventArray[0] = new TClonesArray("AliMUONSubEventTracker",1000);
-  fSubEventArray[1] = new TClonesArray("AliMUONSubEventTracker",1000);
+  fSubEventArray = new TClonesArray("AliMUONSubEventTracker",1000);
 
 
   // ddl pointer
   fDDLTracker = new AliMUONDDLTracker();
   fDDLTrigger = new AliMUONDDLTrigger();
+
+  ReadBusPatchFile();
+
 }
 
 //__________________________________________________________________________
@@ -82,13 +94,12 @@ AliMUONRawData::AliMUONRawData()
   : TObject(),
     fMUONData(0),
     fLoader(0),
-    fFile1(0x0),
-    fFile2(0x0),
     fDDLTracker(0),
     fDDLTrigger(0)
-
 {
   // Default Constructor
+  fFile[0] = fFile[1] = 0x0;
+  
 }
 
 //_______________________________________________________________________
@@ -118,16 +129,17 @@ AliMUONRawData::~AliMUONRawData(void)
 {
   if (fMUONData)
     delete fMUONData;
-  if (fSubEventArray[0])
-    fSubEventArray[0]->Delete(); //using delete cos allocating memory in copy ctor.
-  if (fSubEventArray[1])
-    fSubEventArray[1]->Delete();
+  if (fSubEventArray)
+    fSubEventArray->Delete(); //using delete cos allocating memory in copy ctor.
 
   if (fDDLTracker)
     delete fDDLTracker;
   if (fDDLTrigger)
     delete fDDLTrigger;
 
+ fDetElemIdToBusPatch.Delete();
+ fBusPatchToDetElem.Delete();
+
   return;
 }
 //____________________________________________________________________
@@ -148,38 +160,38 @@ Int_t AliMUONRawData::Digits2Raw()
   for (Int_t ich = 0; ich < AliMUONConstants::NTrackingCh(); ich++) {
  
     // open files
-    idDDL = ich * 2  + 0x900;
+    idDDL = ich * 2  + 0x900; // official number for MUON
     sprintf(name, "MUON_%d.ddl",idDDL);
-    fFile1 = fopen(name,"w");
+    fFile[0] = fopen(name,"w");
 
     idDDL = (ich * 2) + 1 + 0x900;
     sprintf(name, "MUON_%d.ddl",idDDL);
-    fFile2 = fopen(name,"w");
+    fFile[1] = fopen(name,"w");
 
     WriteTrackerDDL(ich);
   
     // reset and close
-    fclose(fFile1);
-    fclose(fFile2);
+    fclose(fFile[0]);
+    fclose(fFile[1]);
     fMUONData->ResetDigits();
   }
  
   // trigger chambers
  
   // open files
-  idDDL = 0xA00;
+  idDDL = 0xA00;// official number for MUTR
   sprintf(name, "MUTR_%d.ddl",idDDL);
-  fFile1 = fopen(name,"w");
+  fFile[0] = fopen(name,"w");
 
   idDDL = 0xA00 + 1;
   sprintf(name, "MUTR_%d.ddl",idDDL);
-  fFile2 = fopen(name,"w");
+  fFile[1] = fopen(name,"w");
 
   WriteTriggerDDL();
   
   // reset and close
-  fclose(fFile1);
-  fclose(fFile2);
+  fclose(fFile[0]);
+  fclose(fFile[1]);
   fMUONData->ResetTrigger();
   
   fLoader->UnloadDigits();
@@ -189,19 +201,19 @@ Int_t AliMUONRawData::Digits2Raw()
 //____________________________________________________________________
 Int_t AliMUONRawData::WriteTrackerDDL(Int_t iCh)
 {
+  // writing DDL for tracker
+  // used inverse mapping
+
   // resets
   TClonesArray* muonDigits = 0;
-  fSubEventArray[0]->Clear();
-  fSubEventArray[1]->Clear();
+  fSubEventArray->Clear();
 
   //
-  TArrayI nbInBus[2];
+  TArrayI nbInBus;
 
-  nbInBus[0].Set(5000);
-  nbInBus[1].Set(5000);
+  nbInBus.Set(5000);
 
-  nbInBus[0].Reset();
-  nbInBus[1].Reset();
+  nbInBus.Reset();
 
   // DDL header
   AliRawDataHeader header = fDDLTracker->GetHeader();
@@ -228,173 +240,155 @@ Int_t AliMUONRawData::WriteTrackerDDL(Int_t iCh)
   Int_t cathode = 0;
   Int_t detElemId;
   Int_t nDigits;
-  const AliMUONDigit* digit;
 
-//   AliMUON *pMUON;
-//   AliMUONChamber* iChamber = 0x0;
-//   AliMUONGeometrySegmentation* segmentation2[2];
-
-//   pMUON = (AliMUON*) gAlice->GetModule("MUON");
-//   iChamber =  &(pMUON->Chamber(iCh));
-
-//   segmentation2[0]=iChamber->SegmentationModel2(1); // cathode 0
-//   segmentation2[1]=iChamber->SegmentationModel2(2); // cathode 1
-
-   AliDebug(1, Form("WriteDDL chamber %d\n", iCh+1));
-
-   //  for (Int_t iCath = 0; iCath < 2; iCath++) {
+  const AliMUONDigit* digit;
 
-    fMUONData->ResetDigits();
-    fMUONData->GetDigits();
-    muonDigits = fMUONData->Digits(iCh);
+  AliDebug(3, Form("WriteDDL chamber %d\n", iCh+1));
 
-    nDigits = muonDigits->GetEntriesFast();
-    AliDebug(2,Form("ndigits = %d\n",nDigits));
+  // getting digits
+  fMUONData->ResetDigits();
+  fMUONData->GetDigits();
+  muonDigits = fMUONData->Digits(iCh);
 
-    // open DDL file, on per 1/2 chamber
+  nDigits = muonDigits->GetEntriesFast();
+  AliDebug(3,Form("ndigits = %d\n",nDigits));
  
-    for (Int_t idig = 0; idig < nDigits; idig++) {
-
-      digit = (AliMUONDigit*) muonDigits->UncheckedAt(idig);
-
-      padX = digit->PadX();
-      padY = digit->PadY();
-      charge = digit->Signal();
-      charge &= 0xFFF;
-      cathode = digit->Cathode();
-      detElemId = digit->DetElemId();
-
-      // mapping
-//       if (detElemId == 0) {
-//     AliWarning("\ndetElemId = 0, old segmentation !\n");
-       GetDummyMapping(iCh, cathode, digit, busPatchId, manuId, channelId);
-//       } else {
-//       // mapping (not far from real one)
-//     AliMUONSegmentManuIndex* connect = segmentation2[iCath]->GetMpConnection(detElemId, padX, padY);
-//     if (connect != 0x0) {
-//       busPatchId = connect->GetBusPatchId(); 
-//       manuId     = connect->GetManuId();
-//       channelId  = connect->GetManuChannelId();
-//       AliDebug(3,Form("busPatchId %d, manuId: %d, channelId: %d\n", busPatchId, manuId, channelId));
-//     } else {
-//       busPatchId = 0; 
-//       manuId     = 0;
-//       channelId  = 0;
-//     }
-
-//       }
-      //packing word
-      AliBitPacking::PackWord((UInt_t)parity,word,29,31);
-      AliBitPacking::PackWord((UInt_t)manuId,word,18,28);
-      AliBitPacking::PackWord((UInt_t)channelId,word,12,17);
-      AliBitPacking::PackWord((UInt_t)charge,word,0,11);
-
-      // set sub Event
-      subEvent = new AliMUONSubEventTracker();
-      subEvent->AddData(word);
-      subEvent->SetBusPatchId(busPatchId);
-      if (digit->PadX() > 0) {
-       nbInBus[0][busPatchId]++;
-       AddData1(subEvent);
-      } else {
-       nbInBus[1][busPatchId]++;
-       AddData2(subEvent);
-      }
-      delete subEvent;
-    }
-    //   }
-  fSubEventArray[0]->Sort();
-  fSubEventArray[1]->Sort();
+  // loop over digit
+  for (Int_t idig = 0; idig < nDigits; idig++) {
+
+    digit = (AliMUONDigit*) muonDigits->UncheckedAt(idig);
+
+    padX = digit->PadX();
+    padY = digit->PadY();
+    charge = digit->Signal();
+    charge &= 0xFFF;
+    cathode = digit->Cathode();
+    detElemId = digit->DetElemId();
+
+    // inverse mapping
+    Int_t error = GetInvMapping(digit, busPatchId, manuId, channelId);
+    if (error) continue;
+
+    AliDebug(1,Form("input  IdDE %d busPatchId %d PadX %d PadY %d iCath %d \n", 
+                   detElemId, busPatchId, padX, padY, cathode));
+
+    AliDebug(3,Form("busPatchId %d, manuId %d channelId %d\n", busPatchId, manuId, channelId ));
+
+    //packing word
+    AliBitPacking::PackWord((UInt_t)parity,word,29,31);
+    AliBitPacking::PackWord((UInt_t)manuId,word,18,28);
+    AliBitPacking::PackWord((UInt_t)channelId,word,12,17);
+    AliBitPacking::PackWord((UInt_t)charge,word,0,11);
+
+    // set sub Event
+    subEvent = new AliMUONSubEventTracker();
+    subEvent->AddData(word);
+    subEvent->SetBusPatchId(busPatchId);
+       
+    // storing the number of identical buspatches
+    nbInBus[busPatchId]++;
+    AddData(subEvent);
+   
+    delete subEvent;
+  }
+
+  // sorting by buspatch
+  fSubEventArray->Sort();
 
   // gather datas from same bus patch
-   for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
-    nEntries = fSubEventArray[iDDL]->GetEntriesFast();
+  nEntries = fSubEventArray->GetEntriesFast();
+
+  for (Int_t i = 0; i < nEntries; i++) {
+    AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray->At(i);
+    busPatchId = temp->GetBusPatchId();
+
+    // add bus patch header, length and total length managed by subevent class
+    temp->SetTriggerWord(0xdeadbeef);
+    for (Int_t j = 0; j < nbInBus[busPatchId]-1; j++) {
+      AliMUONSubEventTracker* temp1 =  (AliMUONSubEventTracker*)fSubEventArray->At(++i);
+      temp->AddData(temp1->GetData(0));
+      fSubEventArray->RemoveAt(i) ;
+    }
+  }
+  fSubEventArray->Compress();
 
+  if (AliLog::GetGlobalDebugLevel() == 3) {
+    nEntries = fSubEventArray->GetEntriesFast();
     for (Int_t i = 0; i < nEntries; i++) {
-      AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
-      busPatchId = temp->GetBusPatchId();
-
-      // add bus patch header, length and total length managed by subevent class
-      temp->SetTriggerWord(0xdeadbeef);
-      for (Int_t j = 0; j < nbInBus[iDDL][busPatchId]-1; j++) {
-       AliMUONSubEventTracker* temp1 =  (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(++i);
-       temp->AddData(temp1->GetData(0));
-       fSubEventArray[iDDL]->RemoveAt(i) ;
+      AliMUONSubEventTracker* temp =  (AliMUONSubEventTracker*)fSubEventArray->At(i);
+      printf("busPatchid back %d\n",temp->GetBusPatchId());
+      for (Int_t j = 0; j < temp->GetLength(); j++) {
+       printf("manuId back %d, ",temp->GetManuId(j));
+       printf("channelId back %d, ",temp->GetChannelId(j));
+       printf("charge back %d\n",temp->GetCharge(j));
       }
     }
-    fSubEventArray[iDDL]->Compress();
-
-    if (AliLog::GetGlobalDebugLevel() == 3) {
-      nEntries = fSubEventArray[iDDL]->GetEntriesFast();
-      for (Int_t i = 0; i < nEntries; i++) {
-       AliMUONSubEventTracker* temp =  (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
-       printf("busPatchid back %d\n",temp->GetBusPatchId());
-       for (Int_t j = 0; j < temp->GetLength(); j++) {
-         printf("manuId back %d, ",temp->GetManuId(j));
-         printf("channelId back %d, ",temp->GetChannelId(j));
-         printf("charge back %d\n",temp->GetCharge(j));
-       }
-      }
-      printf("\n");
-    }
-  
-   }
+    printf("\n");
+  }
   
   Int_t iBusPatch;
-  Int_t iEntries;
+  Int_t iEntries = 0;
   Int_t length;
 
+  // open DDL file, on per 1/2 chamber
   for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
  
-
     // filling buffer
-    nEntries = fSubEventArray[iDDL]->GetEntriesFast();
+    nEntries = fSubEventArray->GetEntriesFast();
     buffer = new Int_t [(2048+24)*50]; // 24 words in average for one buspatch and 2048 manu info at most
 
     indexBlk = 0;
     indexDsp = 0;
     index = 0;
     iBusPatch = 0;
-    iEntries = 0;
 
+    // two blocks A and B per DDL
     for (Int_t iBlock = 0; iBlock < 2; iBlock++) {
 
       // block header
-      //    fDDLTracker->SetTotalBlkLength(0xFFFFFFFF);
       length = fDDLTracker->GetBlkHeaderLength();
       memcpy(&buffer[index],fDDLTracker->GetBlkHeader(),length*4);
       indexBlk = index;
       index += length; 
 
+      // 5 DSP's per block
       for (Int_t iDsp = 0; iDsp < 5; iDsp++) {
 
        // DSP header
-       //      fDDLTracker->SetTotalDspLength(0xEEEEEEEE);
        length = fDDLTracker->GetDspHeaderLength();
        memcpy(&buffer[index],fDDLTracker->GetDspHeader(),length*4);
        indexDsp = index;
        index += length; 
 
+       // 5 buspatches per DSP
        for (Int_t i = 0; i < 5; i++) {
 
-         iBusPatch = i + iBlock*25 + iDsp*5 + 50*(2*iCh + iDDL);
+         // assuming busPatchId begins at 100 (to be discussed ChF)
+         iBusPatch = i + iBlock*25 + iDsp*5 + 50*(2*(iCh+1) + iDDL);
+         AliDebug(3,Form("busPatchId %d", iBusPatch));
 
-         AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(iEntries);
-         if (nEntries > 0) 
+         AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray->At(iEntries);
+         if (nEntries > 0) {
            busPatchId = temp->GetBusPatchId();
-          else
-           busPatchId = -1;
-
+           AliDebug(3,Form("busPatchId %d", temp->GetBusPatchId()));
+         } else
+            busPatchId = -1;
+        
+         // check if buspatchid has digit
          if (busPatchId == iBusPatch) {
            // add bus patch structure
            length = temp->GetHeaderLength();
            memcpy(&buffer[index],temp->GetAddress(),length*4);
            index += length;
-           for (Int_t j = 0; j < temp->GetLength(); j++) 
+           for (Int_t j = 0; j < temp->GetLength(); j++) {
              buffer[index++] =  temp->GetData(j);
+             AliDebug(3,Form("busPatchId %d, manuId %d channelId %d\n", temp->GetBusPatchId(), 
+                             temp->GetManuId(j), temp->GetChannelId(j) ));
+           }
            if (iEntries < nEntries-1)
-             iEntries++;
+              iEntries++;
          } else {
+           // writting anyhow buspatch structure (empty ones)
            buffer[index++] = 4; // total length
            buffer[index++] = 0; // raw data length
            buffer[index++] = iBusPatch; // bus patch
@@ -411,18 +405,13 @@ Int_t AliMUONRawData::WriteTrackerDDL(Int_t iCh)
       buffer[indexBlk] = index - indexBlk; // block length
       buffer[indexBlk+1] = index - indexBlk - fDDLTracker->GetBlkHeaderLength();
     }
-    if (iDDL == 0) {
-      // write DDL 1
-      header.fSize = (index + headerSize) * 4;// total length in bytes
-      fwrite((char*)(&header),headerSize*4,1,fFile1);
-      fwrite(buffer,sizeof(int),index,fFile1);
-    } 
-    if (iDDL == 1) {
-      // write DDL 2
-      header.fSize = (index + headerSize) * 4;// total length in bytes
-      fwrite((char*)(&header),headerSize*4,1,fFile2);
-      fwrite(buffer,sizeof(int),index,fFile2);
-    }
+    
+    //writting onto disk
+    // write DDL 1 & 2
+    header.fSize = (index + headerSize) * 4;// total length in bytes
+    fwrite((char*)(&header),headerSize*4,1,fFile[iDDL]);
+    fwrite(buffer,sizeof(int),index,fFile[iDDL]);
+   
     delete[] buffer;
   }
 
@@ -450,6 +439,7 @@ Int_t AliMUONRawData::WriteTriggerDDL()
   AliMUONGlobalTrigger* gloTrg;
   AliMUONLocalTrigger* locTrg = 0x0;
 
+  // getting information from trigger
   fMUONData->GetTriggerD();
 
   // global trigger for trigger pattern
@@ -475,7 +465,7 @@ Int_t AliMUONRawData::WriteTriggerDDL()
   // stored the local card id that's fired
   for (Int_t i = 0; i <  nEntries; i++) {
     locTrg = (AliMUONLocalTrigger*)localTrigger->At(i);
-    isFired[locTrg->LoCircuit()] = 1;
+    isFired[locTrg->LoCircuit()] = 1; // storing local boards with informations
   }
 
   if (!nEntries)
@@ -483,6 +473,7 @@ Int_t AliMUONRawData::WriteTriggerDDL()
 
   buffer = new Int_t [672]; // [16(local)*5 words + 3 words]*8(reg) + 8 words = 672
 
+  // open DDL file, on per 1/2 chamber
   for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
     
     index = 0; 
@@ -509,6 +500,7 @@ Int_t AliMUONRawData::WriteTriggerDDL()
     memcpy(&buffer[index],fDDLTrigger->GetEnhancedHeader(),length*4);
     index += length; 
 
+    // 8 regional cards per DDL
     for (Int_t iReg = 0; iReg < 8; iReg++) {
 
       subEvent = new AliMUONSubEventTrigger();
@@ -527,6 +519,7 @@ Int_t AliMUONRawData::WriteTriggerDDL()
       buffer[index++] = 0;// 2 words of regional input
       buffer[index++] = 0;
 
+      // 16 local card per regional board
       for (Int_t iLoc = 0; iLoc < 16; iLoc++) {
 
        iLocCard = iLoc + iReg*16 + iDDL*128;
@@ -585,84 +578,93 @@ Int_t AliMUONRawData::WriteTriggerDDL()
     buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word
     buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word for 64 bits transfer purpose
 
-    
-    if (iDDL == 0) {
-      // write DDL 1
-      header.fSize = (index + headerSize) * 4;// total length in bytes
-      fwrite((char*)(&header),headerSize*4,1,fFile1);
-      fwrite(buffer,sizeof(int),index,fFile1);
-    } 
-    if (iDDL == 1) {
-      // write DDL 2
-      header.fSize = (index + headerSize) * 4;// total length in bytes
-      fwrite((char*)(&header),headerSize*4,1,fFile2);
-      fwrite(buffer,sizeof(int),index,fFile2);
-    }
+    // writting onto disk
+    // write DDL 1
+    header.fSize = (index + headerSize) * 4;// total length in bytes
+    fwrite((char*)(&header),headerSize*4,1,fFile[iDDL]);
+    fwrite(buffer,sizeof(int),index,fFile[iDDL]);
+  
   }
   delete[] buffer;
 
   return kTRUE;
 }
+
 //____________________________________________________________________
-void AliMUONRawData::GetDummyMapping(Int_t iCh, Int_t iCath, const AliMUONDigit* digit,
+Int_t AliMUONRawData::GetInvMapping(const AliMUONDigit* digit,
                                     Int_t &busPatchId, UShort_t &manuId, UChar_t &channelId)
 {
-// Dummy mapping for tracker
-
-  Int_t offsetX = 0; // offet row
-  Int_t offsetY = 0; // offset columns
-  Int_t offsetCath = 0; //offset from one cathod to the other
-  Int_t maxChannel = 0; // maximum nb of channel in 1/2 chamber
-  Int_t id;
-      switch (iCh+1) {
-      case 1:
-      case 2:
-      case 3:
-      case 4:
-       offsetX = 512;
-       offsetY = 256;
-       offsetCath = 65536;
-       maxChannel = (offsetY * offsetX + 2* offsetY + offsetCath);
-       break;
-      case 5:
-      case 6:
-      case 7:
-      case 8:
-      case 9:
-      case 10:
-       offsetX = 1024;
-       offsetY = 0;
-       offsetCath = 65536;
-       maxChannel = (256 * offsetX + offsetX + offsetCath);
-       break;
-      }
-      // dummy mapping
-      // manu Id directly from a matrix 8*8, same segmentation for B and NB
-      // 50 buspatches for 1/2 chamber
-
-      id =  (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY +
-            offsetCath * iCath);
-      Int_t chPerBus = maxChannel/50;
-      busPatchId = id/chPerBus; // start at zero 
-      if (digit->PadX() > 0)
-       busPatchId += 50*iCh*2;
-      else 
-       busPatchId += 50*(2*iCh+1);
-      // 64 manu cards for one buspatch
-      manuId = (id % chPerBus)/64; //start at zero 
-      manuId &= 0x7FF; // 11 bits 
-
-      // channel id
-      channelId = (id % chPerBus) % 64; //start at zero 
-      channelId &= 0x3F; // 6 bits
 
-     
-      AliDebug(2,Form("id: %d, busPatchId %d, manuId: %d, channelId: %d, maxchannel: %d, chPerBus %d\n",
-                     id, busPatchId, manuId, channelId, maxChannel, chPerBus));
+  // Inverse mapping for tracker
+
+  // information from digits
+  Int_t iCath = digit->Cathode();
+  Int_t idDE  = digit->DetElemId();
+  Int_t padX  = digit->PadX();
+  Int_t padY  = digit->PadY();
+
+  if (idDE >= 500) { // Since in AliMpSlat pads begin at (0,0) 
+    padX--;         // while in AliMUONSt345Seg. they begin at (1,1)
+    padY--;
+  }
+
+  // segmentation
+  AliMpPlaneType plane;
+  AliMpPlaneType plane1 = kBendingPlane;
+  AliMpPlaneType plane2 = kNonBendingPlane;
+
+  if (idDE < 500) { // should use GetDirection somehow (ChF)
+    if ( ((idDE % 100) % 2) != 0 ) {
+      plane1 = kNonBendingPlane;
+      plane2 = kBendingPlane;
+    }
+  }
+  // station 345 bending == cath0 for the moment
+   plane = (iCath == 0) ? plane1 : plane2;
+
+  AliMpVSegmentation* seg = AliMUONSegmentationManager::Segmentation(idDE, plane);
+  AliMpPad pad = seg->PadByIndices(AliMpIntPair(padX,padY),kTRUE);
+
+  if(!pad.IsValid()) {
+     AliWarning(Form("No elec. for idDE: %d, padx: %d pady %d, charge: %d\n",
+                 idDE, digit->PadX(), digit->PadY(), digit->Signal()));
+    return kTRUE;
+  }
+
+  // Getting Manu id
+  manuId = pad.GetLocation().GetFirst();
+  manuId &= 0x7FF; // 11 bits 
 
-      AliDebug(2,Form("id: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d, charge %d\n",
-                     id, busPatchId, manuId, channelId, digit->PadX(), digit->PadY(), digit->Signal()));
+  // Getting channel id
+  channelId =  pad.GetLocation().GetSecond();
+  channelId &= 0x3F; // 6 bits
 
+  // Getting buspatch id
+  TArrayI* vec = GetBusfromDE(idDE);
+  Int_t pos;
+
+  if (idDE < 500) { // station 1 & 2
+    // set 32 manus for one bus patch ? (ChF)
+    pos = manuId/32;
+  } else {
+    // offset of 100 in manuId for following bus patch
+    pos = manuId/100;
+  }
+
+ //  if (pos >(int_t) vec.size())
+//     AliWarning("pos greater than size\n");
+  busPatchId = vec->At(pos);
+
+  if (plane ==  kNonBendingPlane) // for Non-Bending manuid+= 1000;
+    manuId += 1000; // tmp solution til one finds something better  (ChF)
+  
+  AliDebug(3,Form("idDE: %d, busPatchId %d, manuId: %d, channelId:%d\n",
+                 idDE, busPatchId, manuId, channelId));
+
+  AliDebug(3,Form("idDE: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady: %d, charge: %d\n",
+                 idDE, busPatchId, manuId, channelId, digit->PadX(), digit->PadY(), digit->Signal()));
+
+  return kFALSE; // no error
 }
 
 //____________________________________________________________________
@@ -712,6 +714,9 @@ Int_t AliMUONRawData::Raw2Digits(AliRawReader* rawReader)
 //____________________________________________________________________
 Int_t AliMUONRawData::ReadTrackerDDL(AliRawReader* rawReader)
 {
+  // reading tracker DDL
+  // filling the TClonesArray in MUONData
+  //
 
   AliMUONSubEventTracker* subEventTracker = new AliMUONSubEventTracker();
   AliMUONDigit* digit = new AliMUONDigit();
@@ -733,109 +738,113 @@ Int_t AliMUONRawData::ReadTrackerDDL(AliRawReader* rawReader)
 
   Int_t totalDDLSize, totalBlockSize, totalDspSize , totalBusPatchSize, dataSize; 
 
+  UShort_t  charge; 
+  Int_t padX, padY,iCath;
 
-  for(Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++){                // loops over tracking chambers
+  for(Int_t iDDL = 0; iDDL < 20; iDDL++) { // DDL loop
+    AliDebug(3, Form("Chamber %d\n", iDDL/2 +1 ));
 
-    UShort_t  charge; 
-    Int_t padX, padY,iCath;
+    rawReader->Select(0X9, iDDL, iDDL);  //Select the DDL file to be read  
 
-    for(Int_t iDDL = 0; iDDL < 2; iDDL++){                                         // DDL loop
+    rawReader->ReadHeader();
 
-      //rawReader = new AliRawReaderFile(iEvent);
-      rawReader->Select(0X9,(2*iCh)+iDDL,(2*iCh)+iDDL);  //Select the DDL file to be read  
+    totalDDLSize = (rawReader->GetDataSize()+sizeof(AliRawDataHeader))/4; // 4 is multiplied to convert byte 2 word
 
-      rawReader->ReadHeader();
+    if(totalDDLSize>blankDDLSize){      // Compare the DDL header with an empty DDL header size to read the file
 
-      totalDDLSize = (rawReader->GetDataSize()+sizeof(AliRawDataHeader))/4; // 4 is multipiled to convert byte 2 word
+      Int_t totalDataWord = rawReader->GetDataSize()/4 ;
+      UInt_t *buffer = new UInt_t[totalDataWord];
+      for(Int_t i = 0; i < totalDataWord; i++) { 
+       UInt_t& temp = buffer[i]; 
+       rawReader->ReadNextInt(temp);      // takes the whole result into buffer variable for future analysis
+      }
 
-      if(totalDDLSize>blankDDLSize){      // Compare the DDL header with an empty DDL header size to read the file
+      Char_t parity;
+      Int_t buspatchId;
+      UChar_t channelId;
+      UShort_t  manuId;//,charge; 
+      Int_t idDE;//,padX, padY,iCath;
+      Int_t indexDsp, indexBusPatch, index = 0;
 
 
-       Int_t totalDataWord = rawReader->GetDataSize()/4 ;
-       UInt_t *buffer = new UInt_t[totalDataWord];
-       for(Int_t i=0;i<totalDataWord;i++){
-         UInt_t& temp = buffer[i]; 
-          rawReader->ReadNextInt(temp);      // takes the whole result into buffer variable for future analysis
-       }
+      for(Int_t iBlock = 0; iBlock < 2 ;iBlock++){  // loop over 2 blocks
+       totalBlockSize = buffer[index];
+         
+       if(totalBlockSize > blankBlockSize){        // compare block header
+         index += blockHeaderSize;
 
-       Char_t parity;
-       Int_t buspatchId;
-       UChar_t channelId;
-       UShort_t  manuId;//,charge; 
-       Int_t id;//,padX, padY,iCath;
-       Int_t indexDsp, indexBusPatch, index = 0;
+         for(Int_t iDsp = 0; iDsp < 5 ;iDsp++){   //DSP loop
+           totalDspSize = buffer[index];
+           indexDsp = index;
 
+           if(totalDspSize > blankDspSize){       // Compare DSP Header
+             index += dspHeaderSize;
+               
+             for(Int_t iBusPatch = 0; iBusPatch < 5 ; iBusPatch++){  
+               totalBusPatchSize = buffer[index];
+               indexBusPatch = index;
+               buspatchId = buffer[index+2];
 
-       for(Int_t iBlock = 0; iBlock < 2 ;iBlock++){  // loop over 2 blocks
-         totalBlockSize = buffer[index];
-         
-         if(totalBlockSize > blankBlockSize){        // compare block header
-           index += blockHeaderSize;
+               if(totalBusPatchSize > buspatchHeaderSize){    //Check Buspatch header
+                 index += buspatchHeaderSize;
+                 dataSize = totalBusPatchSize - buspatchHeaderSize;
 
-           for(Int_t iDsp = 0; iDsp < 5 ;iDsp++){   //DSP loop
-             totalDspSize = buffer[index];
-             indexDsp = index;
+                 if(dataSize>0) {
 
-             if(totalDspSize > blankDspSize){       // Compare DSP Header
-               index += dspHeaderSize;
-               
-               for(Int_t iBusPatch = 0; iBusPatch < 5 ; iBusPatch++){  
-                 totalBusPatchSize = buffer[index];
-                 indexBusPatch = index;
-                 buspatchId = buffer[index+2];
+                   for(Int_t iData = 0; iData < dataSize ;iData++) {
 
-                 if(totalBusPatchSize > buspatchHeaderSize){    //Check Buspatch header
-                   index += buspatchHeaderSize;
-                   dataSize = totalBusPatchSize - buspatchHeaderSize;
+                     subEventTracker->SetData(buffer[index++],iData);   //Set to extract data
+                     parity = subEventTracker->GetParity(iData);
+                     manuId = subEventTracker->GetManuId(iData);
+                     channelId = subEventTracker->GetChannelId(iData);
+                     charge = subEventTracker->GetCharge(iData);
+                     digit->SetSignal(charge); // set charge
 
-                   if(dataSize>0) {
+                     Int_t error = GetMapping(buspatchId,manuId,channelId,digit); // Get Back the hits at pads
+                     if (error) continue;
 
-                     for(Int_t iData = 0; iData < dataSize ;iData++) {
+                     padX = digit->PadX();
+                     padY = digit->PadY();
+                     iCath = digit->Cathode();  
+                     idDE = digit->DetElemId();
 
-                       subEventTracker->SetData(buffer[index++],iData);   //Set to extract data
-                       parity = subEventTracker->GetParity(iData);
-                       manuId = subEventTracker->GetManuId(iData);
-                       channelId = subEventTracker->GetChannelId(iData);
-                       charge = subEventTracker->GetCharge(iData);
-                       digit->AddSignal(charge); // set charge
+                     AliDebug(1,Form("output  IdDE %d busPatchid %d PadX %d PadY %d iCath %d \n", 
+                                     idDE, buspatchId, padX, padY, iCath));
+               
 
-                       GetInvDummyMapping(iCh,buspatchId,manuId,channelId,digit); // Get Back the hits at pads
-                       padX = digit->PadX();
-                       padY = digit->PadY();
-                       iCath = digit->Cathode();  
-                       id = digit->DetElemId();
+                     AliDebug(3,Form("idDE %d Padx %d Pady %d, Cath %d, charge %d",idDE, padX, padY, iCath, charge));
+                     // fill digits
+                     //        fMUONData->AddDigit(iCh, *digit);
+                     fMUONData->AddDigit(iDDL/2, *digit);
 
-                       // fill digits
-                       fMUONData->AddDigit(iCh, *digit);
 
-                     } // data loop
-                   } // dataSize test
-                 } // testing buspatch
+                   } // data loop
+                 } // dataSize test
+               } // testing buspatch
 
-                 index = indexBusPatch + totalBusPatchSize;
+               index = indexBusPatch + totalBusPatchSize;
 
-               }  //buspatch loop
+             }  //buspatch loop
                
                
-             }  // dsp test
+           }  // dsp test
 
-             index = indexDsp + totalDspSize;
+           index = indexDsp + totalDspSize;
              
-           }  // dsp loop
+         }  // dsp loop
 
-         }   //block test
+       }   //block test
 
-         index = totalBlockSize;
+       index = totalBlockSize;
 
-       }  //block loop
+      }  //block loop
 
-       delete []buffer;
-      } //loop checking the header size of DDL
+      delete[] buffer;
+    } //loop checking the header size of DDL
 
-      //delete rawReader;
-    } // DDL loop
+    //delete rawReader;
+  } // DDL loop
 
-  } // Chamber loop
 
   delete subEventTracker;
   delete digit;
@@ -844,88 +853,83 @@ Int_t AliMUONRawData::ReadTrackerDDL(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________
-void AliMUONRawData:: GetInvDummyMapping(Int_t iCh, Int_t buspatchId, UShort_t manuId, 
+Int_t AliMUONRawData::GetMapping(Int_t busPatchId, UShort_t manuId, 
                                         UChar_t channelId, AliMUONDigit* digit )
 {
-  Int_t offsetX = 0; // offet row
-  Int_t offsetY = 0; // offset columns
-  Int_t offsetCath = 0; //offset from one cathod to the other
-  Int_t maxChannel = 0; // maximum nb of channel in 1/2 chamber
-  //Int_t id;
-  Bool_t flag;
-  switch (iCh+1) {
-  case 1:
-  case 2:
-  case 3:
-  case 4:
-    offsetX = 512;
-    offsetY = 256;
-    offsetCath = 65536;
-    maxChannel = (offsetY * offsetX + 2* offsetY + offsetCath);
-    break;
-  case 5:
-  case 6:
-  case 7:
-  case 8:
-  case 9:
-  case 10:
-    offsetX = 1024;
-    offsetY = 0;
-    offsetCath = 65536;
-    maxChannel = (256 * offsetX + offsetX + offsetCath);
-    break;
+
+ // mapping  for tracker
+
+  // getting DE from buspatch
+  Int_t  idDE = GetDEfromBus(busPatchId);
+  AliDebug(3,Form("idDE: %d busPatchId %d\n", idDE, busPatchId));
+
+  // segmentation
+  Int_t iCath;
+  Int_t iCath1 = 0;
+  Int_t iCath2 = 1;
+
+  AliMpPlaneType plane;
+
+  if (manuId > 1000) { // again tmp solution (ChF) (+1000 for Non-Bending plane
+    plane = kNonBendingPlane;
+  } else {
+    plane = kBendingPlane;
   }
-  // dummy mapping
-  // manu Id directly from a matrix 8*8, same segmentation for B and NB
-  // 50 buspatches for 1/2 chamber
-  
-  if(buspatchId >= 50*(2*iCh + 1)){          // condn to find the sign of padX
-    buspatchId = buspatchId - 50*(2*iCh + 1);
-    flag = kTRUE;
+
+  if (idDE < 500) { // should use GetDirection somehow (ChF)
+    if ( ((idDE % 100) % 2) != 0 ) {
+      iCath1 = 1;
+      iCath2 = 0;
+    }
   }
-  else{
-    buspatchId = buspatchId - 50*2*iCh;
-    flag = kFALSE;
+
+  iCath = (manuId > 1000) ? iCath2 : iCath1;
+
+  if (manuId > 1000) manuId -= 1000; // back to normal manuId
+
+  AliMpVSegmentation* seg = AliMUONSegmentationManager::Segmentation(idDE, plane);
+  AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,(Int_t)channelId),kTRUE);
+
+  if(!pad.IsValid()){
+    AliWarning(Form("No pad for idDE: %d, busPatchId %d, manuId: %d, channelId: %d\n",
+                 idDE, busPatchId, manuId, channelId));
+    return kTRUE;
+  } // return error
+
+  // Getting padX
+  Int_t padX = pad.GetIndices().GetFirst();
+
+ // Getting padY
+  Int_t padY = pad.GetIndices().GetSecond();
+     
+  if (idDE >= 500) { // Since in AliMpSlat pads begin at (0,0) 
+    padX++;         // while in AliMUONSt345Seg. they begin at (1,1)
+    padY++;
   }
-  
-  Int_t chPerBus = maxChannel/50;
-  
-  Int_t id = buspatchId*chPerBus + 64*manuId + channelId;
-  Int_t iCath, padX,padY;
-  if(id >= (offsetY + offsetCath))           // find cathode plane
-    iCath = 1;
-  else
-    iCath = 0;
-  
-  if(iCh<4)
-    padX = TMath::Nint((Float_t)(id - offsetY - offsetCath*iCath)/offsetX);
-  else
-    padX = (id - offsetY - offsetCath*iCath)/offsetX;
-  
-  padY = id - (padX*offsetX + offsetY + offsetCath*iCath);
-  
-  if(flag)                                 //Detect the sign of padX
-    padX = -padX;
-  else
-    padX = padX;
-  
+  // storing into digits
   digit->SetPadX(padX);
   digit->SetPadY(padY);
   digit->SetCathode(iCath);
-  digit->SetDetElemId(id);
+  digit->SetDetElemId(idDE);
 
-  return;
+  AliDebug(3,Form("idDE: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d\n",
+                 idDE, busPatchId, manuId, channelId, padX, padY));
+  return kFALSE;
 }
 
 //____________________________________________________________________
 Int_t AliMUONRawData::ReadTriggerDDL(AliRawReader* rawReader)
 {
+
+  // reading DDL for trigger
+
   AliMUONSubEventTrigger* subEventTrigger = new AliMUONSubEventTrigger();
   AliMUONGlobalTrigger* globalTrigger = 0x0;
   AliMUONLocalTrigger* localTrigger = new  AliMUONLocalTrigger();
 
 
-  //Int_t ddlHeaderSize = fDDLTrigger->GetHeaderSize();    // we dont need this, as size of ddl data is same for triger and no trigger
+  //Int_t ddlHeaderSize = fDDLTrigger->GetHeaderSize();    
+  // we dont need this, as size of ddl data is same for triger and no trigger
 
   Int_t ddlEnhanceHeaderSize = fDDLTrigger->GetHeaderLength(); 
   Int_t regHeaderLength      = subEventTrigger->GetRegHeaderLength() ;
@@ -937,7 +941,8 @@ Int_t AliMUONRawData::ReadTriggerDDL(AliRawReader* rawReader)
   UShort_t Y1Pattern, Y2Pattern, Y3Pattern, Y4Pattern;
 
 
-  for(Int_t iDDL = 0; iDDL < 2; iDDL++){                        //DDL loop
+  // loop over the two ddl's
+  for(Int_t iDDL = 0; iDDL < 2; iDDL++) { //DDL loop
 
     rawReader->Select(0XA,iDDL,iDDL);  //Select the DDL file to be read  
 
@@ -963,6 +968,7 @@ Int_t AliMUONRawData::ReadTriggerDDL(AliRawReader* rawReader)
 
     index += ddlEnhanceHeaderSize;
 
+    // 8 regional boards
     for (Int_t iReg = 0; iReg < 8; iReg++) {           //loop over regeonal card
 
 
@@ -970,10 +976,12 @@ Int_t AliMUONRawData::ReadTriggerDDL(AliRawReader* rawReader)
 
       index += regHeaderLength;
 
+      // 16 local cards per regional board
       for (Int_t iLoc = 0; iLoc < 16; iLoc++) {         //loop over local card
          
        Int_t iLocIndex = index;
 
+       // 5 word trigger information
        for(Int_t iData = 0; iData < 5 ;iData++ ){
          subEventTrigger->SetLocalData(buffer[index++],5*iLoc+iData);   //read local data
        }
@@ -999,7 +1007,7 @@ Int_t AliMUONRawData::ReadTriggerDDL(AliRawReader* rawReader)
          localTrigger->SetLoLpt(loLpt);
          localTrigger->SetLoHpt(loHpt);
 
-
+         //getting pattern from subvent
          X1Pattern = subEventTrigger->GetX1(iLoc);
          X2Pattern = subEventTrigger->GetX2(iLoc);
          X3Pattern = subEventTrigger->GetX3(iLoc);
@@ -1026,13 +1034,11 @@ Int_t AliMUONRawData::ReadTriggerDDL(AliRawReader* rawReader)
          
       } // local card loop
        
-    } // regeinal card loop
+    } // regional card loop
       
     delete [] buffer;
-    //delete rawReader;
   } // DDL loop
 
-
   delete subEventTrigger;
   delete globalTrigger;
   delete localTrigger;
@@ -1061,7 +1067,74 @@ AliMUONGlobalTrigger* AliMUONRawData::GetGlobalTriggerPattern(Int_t gloTrigPat)
   }
 
   return (new AliMUONGlobalTrigger(globalSinglePlus, globalSingleMinus,
-                                                      globalSingleUndef, globalPairUnlike, 
-                                                       globalPairLike));  
+                                  globalSingleUndef, globalPairUnlike, 
+                                  globalPairLike));  
+
+}
+//____________________________________________________________________
+Int_t AliMUONRawData::GetDEfromBus(Int_t busPatchId)
+{
+  // getting DE id from bus patch
+  Long_t it = fBusPatchToDetElem.GetValue(busPatchId);
+
+ if ( it ) 
+   return (Int_t)it;
+ else 
+   return -1;
+}
+
+//____________________________________________________________________
+TArrayI*  AliMUONRawData::GetBusfromDE(Int_t idDE)
+{
+  // getting bus patch from DE id 
+
+  return (TArrayI*)fDetElemIdToBusPatch.GetValue(idDE);
+}
+//____________________________________________________________________
+void AliMUONRawData::ReadBusPatchFile()
+{
+
+  // idDE <> buspatch map
+  
+  // reading file
+   TString dirPath = gSystem->Getenv("ALICE_ROOT");
+   dirPath += "/MUON/mapping/data/"; 
+
+   TString infile = dirPath + "DetElemIdToBusPatch.dat";
+
+   ifstream in(infile, ios::in);
+   if (!in) AliError("DetElemIdToBusPatch.dat not found.");
+       
+   char line[80];
+
+   while ( in.getline(line,80) ) {
+
+      if ( line[0] == '#' ) continue;
+
+      TString tmp(AliMpHelper::Normalize(line));
+
+      Int_t blankPos = tmp.First(' ');
+
+      TString sDE(tmp(0, blankPos));
+
+      Int_t idDE = atoi(sDE.Data());
+      
+      TString busPatch(tmp(blankPos + 1, tmp.Length()-blankPos));
+
+      TArrayI busPatchList;
+      // decoding range of buspatch
+      AliMpHelper::DecodeName(busPatch,';',busPatchList);
+      
+      // filling buspatch -> idDE
+      for (Int_t i = 0; i < busPatchList.GetSize(); i++)
+       fBusPatchToDetElem.Add((Long_t)busPatchList[i],(Long_t)idDE);
+
+
+      // filling idDE -> buspatch list (vector)
+      fDetElemIdToBusPatch.Add((Long_t)idDE, (Long_t)(new TArrayI(busPatchList))); 
+
+    }
+
+  in.close();
 
 }
index 05597e8..3f945b7 100644 (file)
@@ -4,11 +4,14 @@
  * See cxx source for full Copyright notice                               */
 
 /* Raw data class for trigger and tracker chambers */
-
+#include <map>
+#include <vector>
 #include <TObject.h>
+#include <TExMap.h>
 #include "AliMUONSubEventTracker.h"
 
 class TClonesArray;
+class TArrayI;
 class AliLoader;
 class AliMUONData;
 class AliMUONDigit;
@@ -29,28 +32,31 @@ class AliMUONRawData : public TObject
   Int_t   Digits2Raw();
   Int_t   Raw2Digits(AliRawReader* rawReader);
 
+  Int_t ReadTrackerDDL(AliRawReader* rawReader);
+  Int_t ReadTriggerDDL(AliRawReader* rawReader);
+
   AliMUONData*   GetMUONData() {return fMUONData;}
 
-  void AddData1(const AliMUONSubEventTracker* event) {
-    TClonesArray &temp = *fSubEventArray[0];
+  void AddData(const AliMUONSubEventTracker* event) {
+    TClonesArray &temp = *fSubEventArray;
     new(temp[temp.GetEntriesFast()])AliMUONSubEventTracker(*event); 
   }
 
-  void AddData2(const AliMUONSubEventTracker* event) {
-    TClonesArray &temp = *fSubEventArray[1];
-    new(temp[temp.GetEntriesFast()])AliMUONSubEventTracker(*event); 
-  }
 
-  void GetDummyMapping(Int_t iCh, Int_t iCath, const AliMUONDigit* digit, Int_t &busPatchId,
+  // could be private function (public for debugging)
+  Int_t GetInvMapping(const AliMUONDigit* digit, Int_t &busPatchId,
                       UShort_t &manuId, UChar_t &channelId);
 
-  void GetInvDummyMapping(Int_t iCh, Int_t buspatchId, UShort_t manuId, 
+  Int_t GetMapping(Int_t buspatchId, UShort_t manuId, 
                          UChar_t channelId, AliMUONDigit* digit );
 
 
   Int_t GetGlobalTriggerPattern(const AliMUONGlobalTrigger* gloTrg);
   AliMUONGlobalTrigger* GetGlobalTriggerPattern(Int_t gloTrg);
 
+  Int_t GetDEfromBus(Int_t busPatchId);
+  TArrayI* GetBusfromDE(Int_t idDE);
+
  protected:
   AliMUONRawData();                  // Default constructor
   AliMUONRawData (const AliMUONRawData& rhs); // copy constructor
@@ -62,20 +68,21 @@ class AliMUONRawData : public TObject
  
   AliLoader*    fLoader;             //! alice loader
  
-  FILE*         fFile1;              //! DDL binary file pointer one per 1/2 chamber
-  FILE*         fFile2;              //! DDL binary file pointer one per 1/2 chamber
+  FILE*         fFile[2];            //! DDL binary file pointer one per 1/2 chamber
 
-  TClonesArray* fSubEventArray[2];   //! array to sub event tracker
+  TClonesArray* fSubEventArray;   //! array to sub event tracker
    
   AliMUONDDLTracker* fDDLTracker;      //! DDL tracker class pointers
   AliMUONDDLTrigger* fDDLTrigger;      //! DDL trigger class pointers
 
+  TExMap fDetElemIdToBusPatch;
+  TExMap fBusPatchToDetElem;
+
   // writing raw data
   Int_t WriteTrackerDDL(Int_t iCh);
   Int_t WriteTriggerDDL();
 
-  Int_t ReadTrackerDDL(AliRawReader* rawReader);
-  Int_t ReadTriggerDDL(AliRawReader* rawReader);
+  void  ReadBusPatchFile();
 
   ClassDef(AliMUONRawData,1) // MUON cluster reconstructor in ALICE
 };
index 20f01e7..14666a5 100644 (file)
@@ -163,10 +163,17 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
     //----------------------- raw2digits & raw2trigger-------------------
     if (!loader->TreeD()) loader->MakeDigitsContainer();
 
-    dataCluster->MakeBranch("D,GLT");
-    dataCluster->SetTreeAddress("D,GLT");
-    rawData->Raw2Digits(rawReader);
-    dataCluster->Fill("D,GLT"); 
+    // tracking branch
+    dataCluster->MakeBranch("D");
+    dataCluster->SetTreeAddress("D");
+    rawData->ReadTrackerDDL(rawReader);
+    dataCluster->Fill("D"); 
+
+    // trigger branch
+    dataCluster->MakeBranch("GLT");
+    dataCluster->SetTreeAddress("GLT");
+    rawData->ReadTriggerDDL(rawReader);
+    dataCluster->Fill("GLT"); 
 
     loader->WriteDigits("OVERWRITE");
 
@@ -175,7 +182,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
      
     // tracking branch
     dataCluster->MakeBranch("RC");
-    dataCluster->SetTreeAddress("D,RC");
+    dataCluster->SetTreeAddress("RC");
     recoCluster->Digits2Clusters(); 
     dataCluster->Fill("RC"); 
 
@@ -234,8 +241,8 @@ void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
   AliMUONData* muonData = new AliMUONData(loader,"MUON","MUON");
 
    // declaration  
-  Int_t iEvent, nPart;
-  Int_t nTrackHits, nPrimary;
+  Int_t iEvent;// nPart;
+  Int_t nTrackHits;// nPrimary;
   Double_t fitFmin;
   TArrayF vertex(3);
 
@@ -247,35 +254,35 @@ void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
   AliMUONTrack* recTrack = 0;
   AliMUONTrackParam* trackParam = 0;
   AliMUONTriggerTrack* recTriggerTrack = 0;
-  TParticle* particle = new TParticle();
-  AliGenEventHeader* header = 0;
+//   TParticle* particle = new TParticle();
+//   AliGenEventHeader* header = 0;
   iEvent = runLoader->GetEventNumber(); 
   runLoader->GetEvent(iEvent);
 
   // vertex calculation (maybe it exists already somewhere else)
   vertex[0] = vertex[1] = vertex[2] = 0.;
-  nPrimary = 0;
-  if ( (header = runLoader->GetHeader()->GenEventHeader()) ) {
-    header->PrimaryVertex(vertex);
-  } else {
-    runLoader->LoadKinematics("READ");
-    runLoader->TreeK()->GetBranch("Particles")->SetAddress(&particle);
-    nPart = (Int_t)runLoader->TreeK()->GetEntries();
-    for(Int_t iPart = 0; iPart < nPart; iPart++) {
-      runLoader->TreeK()->GetEvent(iPart);
-      if (particle->GetFirstMother() == -1) {
-       vertex[0] += particle->Vx();
-       vertex[1] += particle->Vy();
-       vertex[2] += particle->Vz();
-       nPrimary++;
-      }
-      if (nPrimary) {
-       vertex[0] /= (double)nPrimary;
-       vertex[1] /= (double)nPrimary;
-       vertex[2] /= (double)nPrimary;
-      }
-    }
-  }
+ //  nPrimary = 0;
+//   if ( (header = runLoader->GetHeader()->GenEventHeader()) ) {
+//     header->PrimaryVertex(vertex);
+//   } else {
+//     runLoader->LoadKinematics("READ");
+//     runLoader->TreeK()->GetBranch("Particles")->SetAddress(&particle);
+//     nPart = (Int_t)runLoader->TreeK()->GetEntries();
+//     for(Int_t iPart = 0; iPart < nPart; iPart++) {
+//       runLoader->TreeK()->GetEvent(iPart);
+//       if (particle->GetFirstMother() == -1) {
+//     vertex[0] += particle->Vx();
+//     vertex[1] += particle->Vy();
+//     vertex[2] += particle->Vz();
+//     nPrimary++;
+//       }
+//       if (nPrimary) {
+//     vertex[0] /= (double)nPrimary;
+//     vertex[1] /= (double)nPrimary;
+//     vertex[2] /= (double)nPrimary;
+//       }
+//     }
+//   }
   // setting ESD MUON class
   AliESDMuonTrack* theESDTrack = new  AliESDMuonTrack() ;
 
@@ -349,10 +356,14 @@ void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
 
   //} // end loop on event  
   loader->UnloadTracks(); 
-  if (!header)
-    runLoader->UnloadKinematics();
+ //  if (!header)
+//     runLoader->UnloadKinematics();
   delete theESDTrack;
   delete muonData;
-  delete particle;
   // delete particle;
+}//_____________________________________________________________________________
+void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliRawReader* /*rawReader*/, AliESD* esd) const
+{
+  // don't need rawReader ???
+  FillESD(runLoader, esd);
 }
index 221ba65..91c0b26 100644 (file)
@@ -27,8 +27,8 @@ class AliMUONReconstructor: public AliReconstructor
     virtual void         FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/, 
                                 AliESD* /*esd*/) const {return;}
     virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
-    virtual void         FillESD(AliRunLoader* /*runLoader*/, 
-                                AliRawReader* /*rawReader*/, AliESD* /*esd*/) const {return;}
+    virtual void         FillESD(AliRunLoader* runLoader, 
+                                AliRawReader* /*rawReader*/, AliESD* esd) const;
 
  
   ClassDef(AliMUONReconstructor, 0)   // class for the MUON reconstruction
index a4971f1..ce9e2d7 100644 (file)
@@ -148,8 +148,10 @@ void Config(char directory[100]="", char option[6]="param")
   AliSHIL *SHIL = new AliSHILv2("SHIL", "Shielding Version 2");
   //=================== MUON Subsystem ===========================
   cout << ">>> Config.C: Creating AliMUONv1 ..."<<endl;
+
   // New MUONv1 version (geometry defined via builders)
   AliMUON *MUON = new AliMUONv1("MUON", "default");
+  //AliMUON *MUON = new AliMUONv1("MUON", "AliMUONFactoryV3"); // New segmentation  
   // If align = true, the detection elements transformations
   // are taken from the input files and not from the code
   //MUON->SetAlign(true);
index 885c8c0..45c8a5a 100644 (file)
@@ -79,7 +79,6 @@ MUONTestTrigger() or MUONTestTrigger("galice.root",##) for the event number ##
 
 ....
 
-
 ============================================================
  How to check the Geometry 
 ============================================================
@@ -168,11 +167,34 @@ gener->SetOrigin(0,0,0);        // Vertex position
 gener->SetSigma(0,0,0.0);       // Sigma in (X,Y,Z) (cm) on IP position
 gener->Init();
  
-===========================================================
+================================================================
  csh Script for the full reconstruction with raw data generator
-===========================================================
-See file AlirootRun_MUONtest.script
-in $ALICE_ROOT/MUON
+================================================================
+The rawdata generation and analysis is working with the new segmentation.
+So the config file must use the version "AliMUONFactoryV3"
+
+Generation
+The method AliSimulation::SetWriteRawData("MUON") enables on 
+the muon rawdata generation
+aliroot -b << EOF  
+AliSimulation MuonSim("$ALICE_ROOT/MUON/Config.C")
+MuonSim.SetWriteRawData("MUON")
+MuonSim.Run(10)
+.q
+EOF
+
+Reconstruction
+aliroot -b << EOF 
+AliReconstruction MuonRec("galice.root");
+MuonRec.SetInput("$YOUR_WORKING_DIRECTORY/");  Do not forget the slash at the end!
+MuonRec.SetRunVertexFinder(kFALSE);
+MuonRec.SetRunLocalReconstruction("MUON");
+MuonRec.SetRunTracking("");
+MuonRec.SetFillESD("MUON");
+MuonRec.Run();
+.q
+EOF
+
 
 
 ============================================================
diff --git a/MUON/mapping/data/DetElemIdToBusPatch.dat b/MUON/mapping/data/DetElemIdToBusPatch.dat
new file mode 100644 (file)
index 0000000..568088b
--- /dev/null
@@ -0,0 +1,166 @@
+# Chamber 1
+100 100-124
+101 125-149
+102 150-174
+103 175-199
+# Chamber 2
+200 200-224
+201 225-249
+202 250-274
+203 275-299
+# Chamber 3
+300 300-324
+301 325-349
+302 350-374
+303 375-399
+# Chamber 4
+400 400-424
+401 425-449
+402 450-474
+403 475-499
+# Chamber 5
+500 500-501
+501 502-505
+502 506-509
+503 510-511
+504 512-513
+505 514-515
+506 516-517
+507 518-521
+508 522-525
+509 526-527
+510 528-531
+511 532-535
+512 536-537
+513 538-539
+514 540-541
+515 542-543
+516 544-547
+517 548-551
+# Chamber 6
+600 600-601
+601 602-605
+602 606-609
+603 610-611
+604 612-613
+605 614-615
+606 616-617
+607 618-621
+608 622-625
+609 626-627
+610 628-631
+611 632-635
+612 636-637
+613 638-639
+614 640-641
+615 642-643
+616 644-647
+617 648-651
+# Chamber 7
+700 700-703
+701 704-707
+702 708-711
+703 712-715
+704 716-719
+705 720-721
+706 722-723
+707 724-725
+708 726-727
+709 728-731
+710 732-735
+711 736-739
+712 740-743
+713 744-747
+714 748-751
+715 752-755
+716 756-759
+717 760-763
+718 764-765
+719 766-767
+720 768-769
+721 770-771
+722 772-775
+723 776-779
+724 780-783
+725 784-787
+# Chamber 8
+800 800-803
+801 804-807
+802 808-811
+803 812-815
+804 816-819
+805 820-821
+806 822-823
+807 824-825
+808 826-827
+809 828-831
+810 832-835
+811 836-839
+812 840-843
+813 844-847
+814 848-851
+815 852-855
+816 856-859
+817 860-863
+818 864-865
+819 866-867
+820 868-869
+821 870-871
+822 872-875
+823 876-879
+824 880-883
+825 884-887
+# Chamber 9
+900 900-903
+901 904-907
+902 908-911
+903 912-915
+904 916-919
+905 920-923
+906 924-925
+907 926-927
+908 928-931
+909 932-935
+910 936-939
+911 940-943
+912 944-947
+913 948-951
+914 952-955
+915 956-959
+916 960-963
+917 964-967
+918 968-971
+919 972-973
+920 974-975
+921 976-979
+922 980-983
+923 984-987
+924 988-991
+925 992-995
+# Chamber 10
+1000 1000-1003
+1001 1004-1007
+1002 1008-1011
+1003 1012-1015
+1004 1016-1019
+1005 1020-1023
+1006 1024-1025
+1007 1026-1027
+1008 1028-1031
+1009 1032-1035
+1010 1036-1039
+1011 1040-1043
+1012 1044-1047
+1013 1048-1051
+1014 1052-1055
+1015 1056-1059
+1016 1060-1063
+1017 1064-1067
+1018 1068-1071
+1019 1072-1073
+1020 1074-1075
+1021 1076-1079
+1022 1080-1083
+1023 1084-1087
+1024 1088-1091
+1025 1092-1095