change in mapping

diff --git a/PMD/AliPMDDDLRawData.cxx b/PMD/AliPMDDDLRawData.cxx
index 1f32a0d75f1996ade0cfae0d0fc449967880acce..de121d57bccb88e10b17765077f37cec6feadd20 100644 (file)
--- a/PMD/AliPMDDDLRawData.cxx
+++ b/PMD/AliPMDDDLRawData.cxx
@@ -19,7 +19,9 @@
 #include <TBranch.h>
 #include <TMath.h>
 
 #include <TBranch.h>
 #include <TMath.h>
 

+#include "AliRawDataHeader.h"

 #include "AliPMDdigit.h"
 #include "AliPMDdigit.h"

+#include "AliPMDRawStream.h"

 #include "AliPMDDDLRawData.h"
 
 
 #include "AliPMDDDLRawData.h"
 
 


@@ -30,6 +32,7 @@ AliPMDDDLRawData::AliPMDDDLRawData():
 {
   // Default Constructor
   //
 {
   // 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
 
 {
   // write digits into raw data format
 


@@ -59,16 +62,10 @@ void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
   Int_t modulePerDDL        = 0;
 
 
   Int_t modulePerDDL        = 0;
 
 

+  AliRawDataHeader header;

   UInt_t sizeRawData = 0;
   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;
 
   Int_t  totword     = 0;
 

-  UInt_t miniHeader[3];

   UInt_t buffer[kSize];
 
   Char_t filename[80];
   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++)
     {
   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
 #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;
        {
          modulePerDDL = 6;
          mmodule = 6*iddl;

-         detectorID = 0;

        }
       else if (iddl == 4)
        {
          modulePerDDL = 12;
          mmodule = 24;
        }
       else if (iddl == 4)
        {
          modulePerDDL = 12;
          mmodule = 24;

-         detectorID = 1;

        }
       else if (iddl == 5)
        {
          modulePerDDL = 12;
        }
       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();
       Int_t bHPosition = outfile.tellp();

-      outfile.write((char*)(miniHeader),mHSize);
+      outfile.write((char*)(&header),sizeof(header));

 
 
       for(Int_t ium = 0; ium < modulePerDDL; ium++)
        {
          
 
 
       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;
          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();
       // 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.seekp(bHPosition);

-      outfile.write((char*)(&sizeRawData),sizeof(UInt_t));
+      outfile.write((char*)(&header),sizeof(header));

       outfile.seekp(cFPosition);
 
       outfile.close();
       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)
 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;
   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;
 
 
   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();
 
       icol   = fPMDdigit->GetColumn();
       adc    = (UInt_t) fPMDdigit->GetADC();
 

+      //      cout << " imodule = " << imodule << " smn = " << smn << endl;
+

       if(smn < 12)
        {
       if(smn < 12)
        {

-         irownew = icol;
-         icolnew = irow;
+         irownew1 = icol;
+         icolnew1 = irow;

        }
       else if( smn >= 12 && smn < 24)
        {
        }
       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);
 
 
 
       GetMCMCh(ddlno, ium, irownew, icolnew, mcmno, chno);
 

-

       baseword = 0;
       dataword = adc;
       PackWord(0, 11,dataword,baseword);
       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;
       
       
       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
 {
   // 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)
     {
   
   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;
 
       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)
     {
     }
   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;
       
       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;
       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];

     }
 
     }
 

-

 }
 //____________________________________________________________________________
 
 }
 //____________________________________________________________________________
 

diff --git a/PMD/AliPMDDDLRawData.h b/PMD/AliPMDDDLRawData.h
index 897a9f904505400338db68ecd9379eb929482fa1..26ff0e3ad82f8a9c16304418b03f3074c90ce168 100644 (file)
--- a/PMD/AliPMDDDLRawData.h
+++ b/PMD/AliPMDDDLRawData.h
@@ -29,14 +29,11 @@ class AliPMDDDLRawData:public TObject
   AliPMDDDLRawData();
   virtual ~AliPMDDDLRawData();
 
   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 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, 
   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
 
   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
 
 };
 #endif