Production of raw data from simulated digits
authormbroz <Michal.Broz@cern.ch>
Fri, 30 Jan 2015 20:18:11 +0000 (21:18 +0100)
committermbroz <Michal.Broz@cern.ch>
Fri, 30 Jan 2015 20:18:11 +0000 (21:18 +0100)
AD/ADsim/AliAD.cxx
AD/ADsim/AliAD.h
AD/ADsim/AliADBuffer.cxx
AD/ADsim/AliADBuffer.h

index 6b9138d..a5dc3bd 100644 (file)
@@ -55,6 +55,7 @@
 #include "AliDigitizationInput.h"
 #include "AliADdigit.h"
 #include "AliADSDigit.h"
+#include "AliADBuffer.h"
 #include "AliDAQ.h"
 #include "AliRawReader.h"
 #include "AliCDBManager.h"
@@ -375,15 +376,109 @@ void AliAD::Hits2SDigits(){
 
 void AliAD::Digits2Raw()
 {
-       // produces raw data from digits
-       // for AD not implemented yet (needs detailed hardware info)
+          //
+   //  Converts digits of the current event to raw data
+   //
+   AliAD *fAD = (AliAD*)gAlice->GetDetector("AD");
+   fLoader->LoadDigits();
+   TTree* digits = fLoader->TreeD();
+   if (!digits) {
+      Error("Digits2Raw", "no digits tree");
+      return;
+   }
+   TClonesArray * ADdigits = new TClonesArray("AliADdigit",1000);
+   fAD->SetTreeAddress();              
+   digits->GetBranch("ADDigit")->SetAddress(&ADdigits); 
+  
+   const char *fileName    = AliDAQ::DdlFileName("AD",0);
+   AliADBuffer* buffer  = new AliADBuffer(fileName);
+   
+   // Get Trigger information first
+   // Read trigger inputs from trigger-detector object
+   AliDataLoader * dataLoader = fLoader->GetDigitsDataLoader();
+   if( !dataLoader->IsFileOpen() ) 
+        dataLoader->OpenFile("READ");
+   AliTriggerDetector* trgdet = (AliTriggerDetector*)dataLoader->GetDirectory()->Get("Trigger");
+   UInt_t triggerInfo = 0;
+   if(trgdet) {
+      triggerInfo = trgdet->GetMask() & 0xffff;
+   }
+   else {
+      AliError(Form("There is no trigger object for %s",fLoader->GetName()));
+   }
+
+   buffer->WriteTriggerInfo((UInt_t)triggerInfo); 
+   buffer->WriteTriggerScalers(); 
+   buffer->WriteBunchNumbers(); 
+  
+   // Now retrieve the channel information: charge smaples + time and 
+   // dump it into ADC and Time arrays
+   Int_t nEntries = Int_t(digits->GetEntries());
+   Short_t aADC[16][kNClocks];
+   Float_t aTime[16];
+   Float_t aWidth[16];
+   Bool_t  aIntegrator[16];
+   Bool_t  aBBflag[16];
+   Bool_t  aBGflag[16];
+  
+   for (Int_t i = 0; i < nEntries; i++) {
+     fAD->ResetDigits();
+     digits->GetEvent(i);
+     Int_t ndig = ADdigits->GetEntriesFast(); 
+   
+     if(ndig == 0) continue;
+     for(Int_t k=0; k<ndig; k++){
+         AliADdigit* fADDigit = (AliADdigit*) ADdigits->At(k);
+
+        Int_t iChannel       = fADDigit->PMNumber();
+        
+        for(Int_t iClock = 0; iClock < kNClocks; ++iClock) aADC[iChannel][iClock] = fADDigit->ChargeADC(iClock);
+        aTime[iChannel]      = fADDigit->Time(); //divide by resolution
+        aWidth[iChannel]     = fADDigit->Width(); //divide by resolution
+        aIntegrator[iChannel]= fADDigit->Integrator();
+        aBBflag[iChannel]    = fADDigit->GetBBflag();
+        aBGflag[iChannel]    = fADDigit->GetBGflag();
+        
+         //AliDebug(1,Form("DDL: %s\tdigit number: %d\tPM number: %d\tADC: %d\tTime: %f",
+                        //fileName,k,fADDigit->PMNumber(),aADC[iChannel][AliADdigit::kNClocks/2],aTime[iChannel])); 
+     }        
+   }
+
+   // Now fill raw data        
+   Int_t iCIU=0;
+   for (Int_t  iV0CIU = 0; iV0CIU < 8; iV0CIU++) {
+   
+      if(iV0CIU != 2 && iV0CIU != 5) {
+               buffer->WriteEmptyCIU();
+        continue;
+       }
+      // decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 2 CIUs) : 
+      for(Int_t iChannel_Offset = iCIU*8; iChannel_Offset < (iCIU*8)+8; iChannel_Offset=iChannel_Offset+4) { 
+         for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
+             buffer->WriteChannel(iChannel, aADC[iChannel], aIntegrator[iChannel]);       
+         }
+         buffer->WriteBeamFlags(&aBBflag[iChannel_Offset],&aBGflag[iChannel_Offset]); 
+         buffer->WriteMBInfo(); 
+         buffer->WriteMBFlags();   
+         buffer->WriteBeamScalers(); 
+      } 
+
+      for(Int_t iChannel = iCIU*8 + 7; iChannel >= iCIU*8; iChannel--) {
+          buffer->WriteTiming(aTime[iChannel], aWidth[iChannel]); 
+      } // End of decoding of one CIU card
+      iCIU++;    
+  } // end of decoding the eight CIUs
+
+     
+  delete buffer;
+  fLoader->UnloadDigits();  
 }
 
 //_____________________________________________________________________________
 
 Bool_t AliAD::Raw2SDigits(AliRawReader* rawReader)
 {
-       // reads raw data to produce digits
-       // for AD not implemented yet (needs detailed hardware info)
+       // reads raw data to produce sdigits
+       // for AD not implemented yet 
        return kTRUE;
 }
index e3b9cef..6d1ab22 100644 (file)
@@ -30,9 +30,9 @@ public:
   AliDigitizer*  CreateDigitizer(AliDigitizationInput* digInput) const;
   virtual AliTriggerDetector* CreateTriggerDetector() const { return new AliADTrigger();}
   
-  virtual    void   Hits2Digits();
-  virtual    void   Hits2SDigits();
-  virtual    void     Digits2Raw();
+  virtual    void       Hits2Digits();
+  virtual    void       Hits2SDigits();
+  virtual    void       Digits2Raw();
   virtual    Bool_t     Raw2SDigits(AliRawReader*);
   virtual    void      SetADATwoInstalled(Bool_t b){fSetADATwoInstalled = b;} // ecv
   virtual    void      SetADCTwoInstalled(Bool_t b){fSetADCTwoInstalled = b;} // ecv
index 80b6dea..fdc150c 100644 (file)
@@ -151,12 +151,10 @@ void AliADBuffer::WriteChannel(Int_t channel, Short_t *adc, Bool_t integrator){
 }
 
 //_____________________________________________________________________________
-void AliADBuffer::WriteBeamFlags() {
-
-//void AliADBuffer::WriteBeamFlags(Bool_t *bbFlag, Bool_t *bgFlag) {
+void AliADBuffer::WriteBeamFlags(Bool_t *bbFlag, Bool_t *bgFlag) {
   // The method writes information about
   // the Beam-Beam and Beam-Gas flags i.e. 
-  // 10  shorts for the 4 channels 
+  // 6  words for the 4 channels 
   // of half a CIU card
 
   // Beam-beam and beam-gas flags are available
@@ -165,29 +163,23 @@ void AliADBuffer::WriteBeamFlags() {
   // and would allow to simulate neighbouring samples, this code
   // should be extended in order to fill all (or fraction) of the
   // flags
-  /*/
-  UShort_t data = 0;
-  
-  for(Int_t iEvOfInt = 0; iEvOfInt < kNClocks; iEvOfInt=iEvOfInt+2) {
-        for(Int_t iChannel = 0; iChannel < 4; iChannel++) {
-         data = 0;
-         if (bbFlag[iChannel]) data |= ((bbFlag[iChannel] & 0x1) << 2*iChannel);
-         if (bgFlag[iChannel]) data |= ((bgFlag[iChannel] & 0x1) << 2*iChannel+1);
-         
-         if(iEvOfInt < (kNClocks - 1)) {      
-            if (bbFlag[iChannel]) data |= ((bbFlag[iChannel] & 0x1) << 8 + 2*iChannel);
-            if (bgFlag[iChannel]) data |= ((bgFlag[iChannel] & 0x1) << 8 + 2*iChannel+1);
-         }
-         f->WriteBuffer((char*)&data,sizeof(data));
-        }
-      }
-   data = 0;
-   f->WriteBuffer((char*)&data,sizeof(data));//Empty short in the end
-   /*/
-  for(Int_t i = 0; i < 6; i++) {
-       UInt_t data = 0;
-       f->WriteBuffer((char*)&data,sizeof(data));
-       }
+  for(Int_t i = 0; i < 2; i++) {
+    UInt_t data = 0;
+    f->WriteBuffer((char*)&data,sizeof(data));
+  }
+  {
+    UInt_t data = 0;
+    for(Int_t iChannel = 0; iChannel < 4; ++iChannel) {
+      if (bbFlag[iChannel]) data |= (1 << (2*iChannel + 16));
+      if (bgFlag[iChannel]) data |= (1 << (2*iChannel + 17));
+    }
+    f->WriteBuffer((char*)&data,sizeof(data));
+  }  
+  for(Int_t i = 0; i < 3; i++) {
+    UInt_t data = 0;
+    f->WriteBuffer((char*)&data,sizeof(data));
+  }
+
 }
 
 //_____________________________________________________________________________
@@ -235,8 +227,6 @@ void AliADBuffer::WriteBeamScalers() {
   }
 }
 
-
-
 //_____________________________________________________________________________
 void AliADBuffer::WriteTiming(Float_t time, Float_t width) {
   // It writes the timing information into a raw data file. 
@@ -247,3 +237,13 @@ void AliADBuffer::WriteTiming(Float_t time, Float_t width) {
   data |= (TMath::Nint(width) & 0x7f) << 12;
   f->WriteBuffer((char*)&data,sizeof(data));
 }
+
+//_____________________________________________________________________________
+void AliADBuffer::WriteEmptyCIU() {
+  // The method writes holes in stream due to missing CIUs Ad has 2 vrt. to 8 VZERO 
+  // There are 182 words per CIU
+  for(Int_t i = 0; i < 182; i++) {
+      UInt_t data = 0;
+      f->WriteBuffer((char*)&data,sizeof(data));
+  }
+}
index 06f4920..237b3b9 100644 (file)
@@ -27,7 +27,7 @@ public:
   void    WriteBunchNumbers();  
 
   void    WriteChannel(Int_t channel, Short_t *adc, Bool_t integrator);
-  void    WriteBeamFlags();
+  void    WriteBeamFlags(Bool_t *bbFlag, Bool_t *bgFlag);
   
   void    WriteMBInfo();
   void    WriteMBFlags();
@@ -35,6 +35,8 @@ public:
   void    WriteBeamScalers();
 
   void    WriteTiming(Float_t time, Float_t width);
+  
+  void   WriteEmptyCIU();
 
 private:
   AliADBuffer(const AliADBuffer &source); // copy constructor