change in mapping
authorbnandi <bnandi@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Jun 2004 11:34:23 +0000 (11:34 +0000)
committerbnandi <bnandi@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 15 Jun 2004 11:34:23 +0000 (11:34 +0000)
PMD/AliPMDDDLRawData.cxx
PMD/AliPMDDDLRawData.h

index 1f32a0d..de121d5 100644 (file)
@@ -19,7 +19,9 @@
 #include <TBranch.h>
 #include <TMath.h>
 
+#include "AliRawDataHeader.h"
 #include "AliPMDdigit.h"
+#include "AliPMDRawStream.h"
 #include "AliPMDDDLRawData.h"
 
 
@@ -30,6 +32,7 @@ AliPMDDDLRawData::AliPMDDDLRawData():
 {
   // Default Constructor
   //
+
 }
 //____________________________________________________________________________
 
@@ -41,7 +44,7 @@ AliPMDDDLRawData::~AliPMDDDLRawData()
 }
 
 //____________________________________________________________________________
-void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
+void AliPMDDDLRawData::WritePMDRawData(TTree *treeD)
 {
   // write digits into raw data format
 
@@ -59,16 +62,10 @@ void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
   Int_t modulePerDDL        = 0;
 
 
+  AliRawDataHeader header;
   UInt_t sizeRawData = 0;
-  UInt_t magicWord   = 0x123456;
-  UInt_t detectorID  = 0;
-  UInt_t ddlID       = 0;
-  Int_t  flag        = 0;
-  Int_t  version     = 1;
-  UInt_t mHSize      = 3*sizeof(UInt_t);
   Int_t  totword     = 0;
 
-  UInt_t miniHeader[3];
   UInt_t buffer[kSize];
 
   Char_t filename[80];
@@ -76,7 +73,7 @@ void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
   Int_t mmodule = 0;
   for(Int_t iddl = 0; iddl < kDDL; iddl++)
     {
-      sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
+      sprintf(filename,"PMD_%d.ddl",AliPMDRawStream::kDDLOffset+iddl);
 #ifndef __DECCXX
       outfile.open(filename,ios::binary);
 #else
@@ -87,38 +84,30 @@ void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
        {
          modulePerDDL = 6;
          mmodule = 6*iddl;
-         detectorID = 0;
        }
       else if (iddl == 4)
        {
          modulePerDDL = 12;
          mmodule = 24;
-         detectorID = 1;
        }
       else if (iddl == 5)
        {
          modulePerDDL = 12;
-         mmodule = 36;
-         detectorID = 1;
+         mmodule = 30;
        }
 
-      miniHeader[0] = sizeRawData;
-      PackWord(0,23,magicWord,miniHeader[1]);
-      PackWord(24,31,detectorID,miniHeader[1]);
-      ddlID = iddl;
-      PackWord(0,15,ddlID,miniHeader[2]);
-      PackWord(16,23,flag,miniHeader[2]);
-      PackWord(24,31,version,miniHeader[2]);
-
 
-      // Write the Dummy Mini Header into the file
+      // Write the Dummy Data Header into the file
       Int_t bHPosition = outfile.tellp();
-      outfile.write((char*)(miniHeader),mHSize);
+      outfile.write((char*)(&header),sizeof(header));
 
 
       for(Int_t ium = 0; ium < modulePerDDL; ium++)
        {
          
+         if (iddl == 4 && ium == 6) mmodule = 36;
+         if (iddl == 5 && ium == 6) mmodule = 42;
+
          for (Int_t i = 0; i < kSize; i++)
            {
              buffer[i] = 0;
@@ -135,14 +124,16 @@ void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
 
        }
 
-      // Write real mini header
-      // take the pointer to the beginning of the mini header
+      // Write real data header
+      // take the pointer to the beginning of the data header
       // write the total number of words per ddl and bring the
       // pointer to the current file position and close it
       UInt_t cFPosition = outfile.tellp();
-      sizeRawData = cFPosition - bHPosition - mHSize;
+      sizeRawData = cFPosition - bHPosition - sizeof(header);
+      header.fSize = cFPosition - bHPosition;
+      header.SetAttribute(0);  // valid data
       outfile.seekp(bHPosition);
-      outfile.write((char*)(&sizeRawData),sizeof(UInt_t));
+      outfile.write((char*)(&header),sizeof(header));
       outfile.seekp(cFPosition);
 
       outfile.close();
@@ -151,71 +142,6 @@ void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
 
 }
 //____________________________________________________________________________
-
-void AliPMDDDLRawData::ReadPMDRawData(Int_t evtno)
-{
-  // reads the raw data
-  ifstream infile;
-
-  Char_t filename[80];
-
-  const Int_t kDDL = 6;
-  Int_t imodule = 0;
-
-  for(Int_t iddl = 0; iddl < kDDL; iddl++)
-    {
-      sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
-#ifndef __DECCXX
-      infile.open(filename,ios::binary);
-#else
-      infile.open(filename);
-#endif
-      
-      Int_t  ium;
-      Int_t  irow;
-      Int_t  icol;
-      UInt_t baseword;
-      UInt_t miniHeader[3];
-      UInt_t sizeRawData;
-      UInt_t mHSize = 3*sizeof(UInt_t);
-
-      infile.read((char*)(miniHeader), mHSize);
-      
-      sizeRawData = miniHeader[0];
-      Int_t totword = sizeRawData/4;
-      
-      UInt_t adc;
-      UInt_t chno;
-      UInt_t mcmno;
-      
-      for (Int_t iword = 0; iword < totword; iword++)
-       {
-         infile.read((char*)(&baseword),sizeof(UInt_t));
-         
-         UnpackWord(0,11,adc,baseword);
-         UnpackWord(12,17,chno,baseword);
-         UnpackWord(18,28,mcmno,baseword);
-         
-         GetRowCol(iddl, mcmno, chno, ium, irow, icol);
-         if (iddl < 4)
-           {
-             imodule = iddl*6 + ium;
-           }
-         else if (iddl == 4)
-           {
-             imodule = 24 + ium;
-           }
-         else if (iddl == 5)
-           {
-             imodule = 36 + ium;
-           }
-
-         
-       }
-
-    } // ddl loop
-}
-//____________________________________________________________________________
 void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
                                       Int_t ddlno, Int_t & totword,
                                       UInt_t *buffer)
@@ -227,6 +153,8 @@ void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
   UInt_t adc;
   Int_t  irownew = 0;
   Int_t  icolnew = 0;
+  Int_t  irownew1 = 0;
+  Int_t  icolnew1 = 0;
   Int_t  det, smn, irow, icol;
 
 
@@ -244,22 +172,44 @@ void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
       icol   = fPMDdigit->GetColumn();
       adc    = (UInt_t) fPMDdigit->GetADC();
 
+      //      cout << " imodule = " << imodule << " smn = " << smn << endl;
+
       if(smn < 12)
        {
-         irownew = icol;
-         icolnew = irow;
+         irownew1 = icol;
+         icolnew1 = irow;
        }
       else if( smn >= 12 && smn < 24)
        {
-         irownew = irow;
-         icolnew = icol;
+         irownew1 = irow;
+         icolnew1 = icol;
        }
 
+      if(smn < 6)
+       {
+         irownew = 95 - irownew1;
+         icolnew = icolnew1;
+       }
+      else if(smn >= 6 && smn < 12)
+       {
+         irownew = irownew1;
+         icolnew = 47 - icolnew1;
+       }
+      else if(smn >= 12 && smn < 18)
+       {
+         irownew = 47 - irownew1;
+         icolnew = icolnew1;
+       }
+      else if(smn >= 18 && smn < 24)
+       {
+         irownew = irownew1;
+         icolnew = 95 - icolnew1;
+       }
+      
 
 
       GetMCMCh(ddlno, ium, irownew, icolnew, mcmno, chno);
 
-
       baseword = 0;
       dataword = adc;
       PackWord(0, 11,dataword,baseword);
@@ -276,9 +226,6 @@ void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
       
       buffer[ient] = baseword;
       
-
-
-      
     }
 
 
@@ -290,22 +237,23 @@ void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t um,
 {
   // This part will be modified once the final track layout on the PCB is
   // designed. This will only change the coordinate of the individual cell
-  UInt_t ch[16][4] = { {3, 2, 29, 28},
-                      {5, 1, 31, 27},
-                      {6, 0, 30, 26},
-                      {7, 4, 25, 24},
-                      {8, 9, 20, 23},
-                      {10, 14, 16, 22},
-                      {11, 15, 17, 21},
-                      {12, 13, 18, 19},
-                      {35, 34, 61, 60},
-                      {37, 33, 63, 59},
-                      {38, 32, 62, 58},
-                      {39, 36, 57, 56},
-                      {40, 41, 52, 55},
-                      {42, 46, 48, 54},
-                      {43, 47, 49, 53},
-                      {44, 45, 50, 51} };
+
+  static const UInt_t kCh[16][4] = { {12, 13, 18, 19},
+                                    {11, 15, 17, 21},
+                                    {10, 14, 16, 22},
+                                    {8, 9, 20, 23},
+                                    {7, 4, 25, 24},
+                                    {6, 0, 30, 26},
+                                    {5, 1, 31, 27},
+                                    {3, 2, 29, 28},
+                                    {44, 45, 50, 51},
+                                    {43, 47, 49, 53},
+                                    {42, 46, 48, 54},
+                                    {40, 41, 52, 55},
+                                    {39, 36, 57, 56},
+                                    {38, 32, 62, 58},
+                                    {37, 33, 63, 59},
+                                    {35, 34, 61, 60} };
   
   if (ddlno == 0 || ddlno == 1)
     {
@@ -315,8 +263,8 @@ void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t um,
       Int_t irowdiv = row/16;
       Int_t icoldiv = col/4;
 
-      mcmno = 72*um + 6*icoldiv + irowdiv;
-      chno  = ch[irownew][icolnew];
+      mcmno = 72*um + 12*irowdiv + icoldiv;
+      chno  = kCh[irownew][icolnew];
     }
   else if (ddlno == 2 || ddlno == 3)
     {
@@ -326,105 +274,30 @@ void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t um,
       Int_t irowdiv = row/16;
       Int_t icoldiv = col/4;
       
-      mcmno = 72*um + 3*icoldiv + irowdiv;
-      chno  = ch[irownew][icolnew];
+      mcmno = 72*um + 24*irowdiv + icoldiv;
+      chno  = kCh[irownew][icolnew];
     }
-  else if (ddlno == 4)
+  else if (ddlno == 4 || ddlno == 5)
     {
-      // CPV plane,  SU Mod = 1, 2
-      Int_t irownew = row%16;
-      Int_t icolnew = col%4;
-      Int_t irowdiv = row/16;
-      Int_t icoldiv = col/4;
+      // CPV plane,  SU Mod = 1, 3 : ddl = 4
+      // CPV plane,  SU Mod = 2, 4 : ddl = 5
 
-      mcmno = 72*um + 6*icoldiv + irowdiv;
-      chno  = ch[irownew][icolnew];
-    }
-  else if (ddlno == 5)
-    {
-      // CPV plane,  SU Mod = 3, 4
       Int_t irownew = row%16;
       Int_t icolnew = col%4;
       Int_t irowdiv = row/16;
       Int_t icoldiv = col/4;
-      
-      mcmno = 72*um + 3*icoldiv + irowdiv;
-      chno  = ch[irownew][icolnew];
-    }
 
-}
-//____________________________________________________________________________
-
-void AliPMDDDLRawData::GetRowCol(Int_t ddlno, UInt_t mcmno, UInt_t chno,
-                                Int_t &um, Int_t &row, Int_t &col)
-{
-  UInt_t ch[64] = { 9, 5, 1, 0, 13, 4, 8, 12,
-                   16, 17, 20, 24, 28, 29, 21, 25,
-                   22, 26, 30, 31, 18, 27, 23, 19,
-                   15, 14, 11, 7, 3, 2, 10, 6,
-                   41, 37, 33, 32, 45, 36, 40, 44,
-                   48, 49, 52, 56, 60, 61, 53, 57,
-                   54, 58, 62, 63, 50, 59, 55, 51,
-                   47, 46, 43, 39, 35, 34, 42, 38 };
-
-  if (ddlno == 1 || ddlno == 2)
-    {
-      um  = mcmno/72;
-      Int_t mcmnonew = mcmno - 72*um;
-      Int_t rowcol  = ch[chno];
-      Int_t irownew = rowcol/4;
-      Int_t icolnew = rowcol%4;
-      
-      Int_t remmcm  = mcmnonew%6;
-      Int_t divmcm  = mcmnonew/6;
-      
-      row = 16*remmcm + irownew;
-      col =  4*divmcm + icolnew;
-    }
-  else   if (ddlno == 3 || ddlno == 4)
-    {
-      um  = mcmno/72;
-      Int_t mcmnonew = mcmno - 72*um;
-      Int_t rowcol  = ch[chno];
-      Int_t irownew = rowcol/4;
-      Int_t icolnew = rowcol%4;
-      
-      Int_t remmcm  = mcmnonew%3;
-      Int_t divmcm  = mcmnonew/3;
-      
-      row = 16*remmcm + irownew;
-      col =  4*divmcm + icolnew;
-    }
-  else if (ddlno == 4)
-    {
-      um  = mcmno/144;
-      Int_t mcmnonew = mcmno - 72*um;
-      Int_t rowcol  = ch[chno];
-      Int_t irownew = rowcol/4;
-      Int_t icolnew = rowcol%4;
-      
-      Int_t remmcm  = mcmnonew%6;
-      Int_t divmcm  = mcmnonew/6;
-      
-      row = 16*remmcm + irownew;
-      col =  4*divmcm + icolnew;
-    }
-  else if (ddlno == 5)
-    {
-      um  = mcmno/144;
-      Int_t mcmnonew = mcmno - 72*um;
-      Int_t rowcol  = ch[chno];
-      Int_t irownew = rowcol/4;
-      Int_t icolnew = rowcol%4;
-      
-      Int_t remmcm  = mcmnonew%3;
-      Int_t divmcm  = mcmnonew/3;
-      
-      row = 16*remmcm + irownew;
-      col =  4*divmcm + icolnew;
+      if(um < 6)
+       {
+         mcmno = 72*um + 12*irowdiv + icoldiv;
+       }
+      else if(um >= 6)
+       {
+         mcmno = 72*um + 24*irowdiv + icoldiv;
+       }
+      chno  = kCh[irownew][icolnew];
     }
 
-
 }
 //____________________________________________________________________________
 
index 897a9f9..26ff0e3 100644 (file)
@@ -29,14 +29,11 @@ class AliPMDDDLRawData:public TObject
   AliPMDDDLRawData();
   virtual ~AliPMDDDLRawData();
 
-  void WritePMDRawData(TTree *treeD, Int_t evtno);
-  void ReadPMDRawData(Int_t evtno);
+  void WritePMDRawData(TTree *treeD);
   void GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium, Int_t ddlno,
                       Int_t & totword, UInt_t *buffer);
   void GetMCMCh(Int_t ddlno, Int_t um, Int_t row, Int_t col,
                UInt_t &mcmno, UInt_t &chno);
-  void GetRowCol(Int_t ddlno, UInt_t mcmno, UInt_t chno,
-                Int_t &um, Int_t &row, Int_t &col);
   void PackWord(UInt_t startbit, UInt_t stopbit, UInt_t dataword, 
                UInt_t &packedword);
   void UnpackWord(UInt_t startbit, UInt_t stopbit, UInt_t &dataword, 
@@ -48,7 +45,7 @@ class AliPMDDDLRawData:public TObject
   TClonesArray *fDigits;    //! List of digits
   AliPMDdigit  *fPMDdigit;  //! Pointer to digits
 
-  ClassDef(AliPMDDDLRawData,1)    // To make RAW Data
+  ClassDef(AliPMDDDLRawData,2)    // To make RAW Data
 };
 #endif