Modifes the Raw analyzer tuo use the new decoder,
authorphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 10 Jul 2007 11:15:38 +0000 (11:15 +0000)
committerphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 10 Jul 2007 11:15:38 +0000 (11:15 +0000)
files modified to use constants in the namespace
PhosHltConst

HLT/PHOS/AliHLTPHOSRawAnalyzer.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzerComponent.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzerCrude.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzerLMS.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzerPeakFinder.cxx

index 5d96d2f823d3d31531245e958e6bc3fa9c01fe04..47d4e0b462ba90894e5e144e90ec6316ab857855 100644 (file)
 using std::cout;
 using std::endl;
 
-AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
+//AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
+AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
 {
-  fFloatDataPtr = new double[1008];
+  //  fFloatDataPtr = new double[1008];
+ fIntDataPtr = new UInt_t[1008];
 }
 
 AliHLTPHOSRawAnalyzer::~AliHLTPHOSRawAnalyzer()
@@ -29,7 +31,8 @@ AliHLTPHOSRawAnalyzer::~AliHLTPHOSRawAnalyzer()
 
 }
 
-AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(AliHLTPHOSRawAnalyzer const&):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+//AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(AliHLTPHOSRawAnalyzer const&):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(AliHLTPHOSRawAnalyzer const&):fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
 {
 
 }
@@ -39,9 +42,10 @@ AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(AliHLTPHOSRawAnalyzer const&):fFloa
 * @param dtaPtr Data array for wich a subarray will be taken to perform the fit
 * @param fs the sampling frequency in entities of MHz. Needed in order to calculate physical time
 **/
-AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+//AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
 {
-  fFloatDataPtr = dtaPtr;  
+  //  fIntDataPtr = dtaPtr;  
   fSampleFrequency = fs;
 } //end  
 
@@ -57,7 +61,8 @@ AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fFloatDa
 void 
 AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, int N)
 {
-  fFloatDataPtr = dataPtr;  
+  //  fFloatDataPtr = dataPtr;  
+
   cout << "Baseline correction not yet implemeted" << endl;
 } //end BaselineCorrection
 
@@ -71,7 +76,7 @@ AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, int N)
 void 
 AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, double baselineValue)
 {
-  fFloatDataPtr = dataPtr;   
+  //  fFloatDataPtr = dataPtr;   
   printf("\nbaselineValue = %f\n", baselineValue);
   cout << "Baseline correction not yet implemeted" << endl;
 } //end BaslineCorrection
@@ -99,6 +104,21 @@ AliHLTPHOSRawAnalyzer::GetEnergy() const
 } //end GetEnergy
 
 
+/**
+ * Set data array. Overrides data data array set in the constructor.
+ **/
+//void 
+//AliHLTPHOSRawAnalyzer::SetData(double *data)
+//{
+//  fFloatDataPtr = data;
+//}
+void 
+AliHLTPHOSRawAnalyzer::SetData(UInt_t *data)
+{
+  //  fFloatDataPtr = data;
+  fIntDataPtr = data;
+}
+
 /**
  * Set data array. Overrides data data array set in the constructor.
  **/
@@ -108,6 +128,8 @@ AliHLTPHOSRawAnalyzer::SetData(double *data)
   fFloatDataPtr = data;
 }
 
+
+
 void 
 AliHLTPHOSRawAnalyzer::SetSampleFreq(double freq)
 {
@@ -165,6 +187,26 @@ AliHLTPHOSRawAnalyzer::SetAVector(Double_t *aVector, Int_t size)
 }
 
 
+UInt_t
+AliHLTPHOSRawAnalyzer::GetMaxValue(UInt_t *dta, Int_t size) const
+{
+
+  Double_t tmpMax = 0;
+
+  for(int i = 0; i < size; i++)
+    {
+      if(dta[i] > tmpMax)
+       {
+         tmpMax = dta[i];
+       }
+    }
+  
+  return tmpMax;
+
+}
+
+
+/*
 Double_t
 AliHLTPHOSRawAnalyzer::GetMaxValue(Double_t *dta, Int_t size) const
 {
@@ -182,3 +224,4 @@ AliHLTPHOSRawAnalyzer::GetMaxValue(Double_t *dta, Int_t size) const
   return tmpMax;
 
 }
+*/
index 2627c9c46d8f827ac7163b2952b33b5ea5990362..7e647dffa14b50a8e004aa301d3282ba405de48e 100644 (file)
 /// - @ref GetComponentID
 /// - @ref Spawn
 
-
-
 #include "AliHLTPHOSRawAnalyzer.h"
 #include "AliHLTPHOSRawAnalyzerComponent.h"
 #include "AliRawReaderMemory.h"
 #include "AliCaloRawStream.h"
 #include "AliHLTPHOSRcuCellEnergyDataStruct.h"
 #include "AliHLTPHOSRcuChannelDataStruct.h"
+#include "AliHLTDDLDecoder.h"
+#include "AliHLTAltroData.h"
 
+#include "AliHLTPHOSMapper.h"
 
 using namespace std;
 
@@ -46,7 +47,7 @@ using namespace std;
 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTPHOSProcessor(), fAnalyzerPtr(0), 
 fSendChannelData(kFALSE),fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
 {
-
+  fMapperPtr = new AliHLTPHOSMapper();
 } 
 
 //_________________________________________________________________________________________________
@@ -129,10 +130,19 @@ AliHLTPHOSRawAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, doub
 int 
 AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
 {
-  AliHLTUInt8_t tmpMod    = 0;
-  AliHLTUInt8_t tmpZ      = 0;
-  AliHLTUInt8_t tmpX      = 0;
-  AliHLTUInt8_t tmpGain   = 0;
+  //  cout << "AliHLTPHOSRawAnalyzerComponent::DoEven" << endl;
+  //  cout << "AliHLTPHOSRawAnalyzerComponent::DoEven" << endl;
+  //  cout << "evtData.fStructSize" <<  evtData.fStructSize << endl;
+  // cout << "evtData.fEventID"    <<  evtData.fEventID << endl ;
+  cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent: evtData.fBlockCnt = "   <<  evtData.fBlockCnt << endl ;
+  // cout << "size =" << size << endl;
+  //  cout << "blocks->fSize ="      <<  blocks->fSize << endl;
+  //  cout << "blocks->fOffset ="    <<  blocks->fOffset << endl;
+
+  //  AliHLTUInt8_t tmpMod    = 0;
+  //  AliHLTUInt8_t tmpZ      = 0;
+  // AliHLTUInt8_t tmpX      = 0;
+  //  AliHLTUInt8_t tmpGain   = 0;
   Int_t sampleCnt         = 0;
   Int_t processedChannels = 0;
   UInt_t offset           = 0; 
@@ -147,29 +157,165 @@ AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData
   const AliHLTComponentBlockData* iter = NULL; 
   unsigned long ndx;
 
+
   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
     {
+      printf("\nNEW DDL BLOCK\n");
+
       iter = blocks+ndx;
       mysize = 0;
       offset = tSize;
 
       if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType )
        {
-         continue;
+         cout <<"WARNING: notAliHLTPHOSDefinitions::fgkDDLPackedRawDataTyp  "  << endl;
+         //      continue;
        }
 
-      fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
-      fAnalyzerPtr->SetData(fTmpChannelData);
+
+      fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
+
+      fDecoderPtr->Decode();
+
+      fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
+
+      int tmpCnt = 0;
+      printf("\n********** NEW EVENT ************\n");
+      printf("\n********************************");
+      printf("\n********************************");
+      printf("\n********************************\n");
+      
+      while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
+       {
+         
+         //      fDecoderPtr->NextChannel(fAltroDataPtr);
+
+         fAnalyzerPtr->SetData(fAltroDataPtr->fData);
+         fAnalyzerPtr->Evaluate(0, fAltroDataPtr->fDataSize);  
+         //      fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
+         
+
+
+         fOutPtr->fValidData[tmpChannelCnt].fGain = fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].gain;
+         fOutPtr->fValidData[tmpChannelCnt].fZ  = fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].row;
+         fOutPtr->fValidData[tmpChannelCnt].fX  = fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].col; 
+         fOutPtr->fValidData[tmpChannelCnt].fEnergy  = (float)fAnalyzerPtr->GetEnergy();
+         fOutPtr->fValidData[tmpChannelCnt].fTime    = (float)fAnalyzerPtr->GetTiming();
+         tmpChannelCnt ++;
+
+         
+         if(tmpCnt < 1)
+           {
+             
+             printf("\n******New ALTRO BLOCK**********\n");
+             printf("tmpCnt = %d \n", tmpCnt);
+             printf("size = %d\n", fAltroDataPtr->fDataSize);
+             printf("harware adress = %d\n", fAltroDataPtr->fHadd);
+             //              DumpData(fAltroDataPtr->fData,  fAltroDataPtr->fDataSize, 4);
+             DumpData(fAltroDataPtr->fData,  128, 4);
+             //          cout << "gain =" <<fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].gain  << endl;
+             //          cout << "row =" <<fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].row  << endl;
+             //          cout << "col =" <<fMapperPtr->ALTRO_MAP[fAltroDataPtr->fHadd].col  << endl; 
+             //          cout << "Channel = " << fAltroDataPtr->GetChannel()<< endl; 
+             //          cout << "Chip = " << fAltroDataPtr->GetChip()<< endl; 
+             //          cout << "Card = " << fAltroDataPtr->GetCard()<< endl;
+             //          cout << "Branch = " << fAltroDataPtr->GetBranch()<< endl;
+             //          DumpData(fAltroDataPtr->fData, fAltroDataPtr->fDataSize , 4); 
+             printf("\n****** END altroblock **********\n");
+           }
+
+         tmpCnt ++; 
+
+         //      printf("harware adress = %d\n", fAltroDataPtr->fHadd);
+         //      printf("size = %d\n", fAltroDataPtr->fDataSize);
+       }
+               
+
+      mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
+      //     cout <<"Pushing data block" << endl;
+   
+      fOutPtr->fCnt =  tmpChannelCnt;
+      AliHLTComponentBlockData bd;
+      FillBlockData( bd );
+      bd.fOffset = offset;
+      bd.fSize = mysize;
+      bd.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
+      bd.fSpecification = 0xFFFFFFFF;
+      outputBlocks.push_back( bd );
+      tSize += mysize;
+      outBPtr += mysize;
+      
+      if( tSize > size )
+       {
+         cout <<"kHLTLogFatal, HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent Too much data Data written over allowed buffer. Amount written:"
+              << tSize << " allowed" << size << endl;
+         Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
+                  "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
+                  , tSize, size );
+         return EMSGSIZE;
+       }
+     
+      printf("\nEND  DDL BLOCK\n");
+
+    }
+
+  fPhosEventCount++; 
+
+  if(fPrintInfo == kTRUE)
+    {
+      if(fPhosEventCount%fPrintInfoFrequncy == 0)
+       {
+         cout <<"Analyzing event " <<  fPhosEventCount  << "for Equippment " << fkEquippmentID << endl; 
+       }  
+    }
+  size = tSize;
+
+  return 0;
+}//end DoEvent
+
+
+
+
+
+         //      printf("\nRawAnalyzer: printing data\n");
+
+
+         /*
+         int cnt = 0;
+          
+         for(int i=0; i< 100; i ++)
+           {
+             if(cnt%4 == 0) printf("\n");
+             printf(":%d\t",fAltroDataPtr->fData[i] );
+             cnt ++;
+           }
+         */
+             //        }
+
+      
+
+
+      //      while( fDecoderPtr->NextChannel(fAltroDataPtr))
+      //       { 
+      //         fAnalyzerPtr->SetData(fTmpChannelData);
+      //       }
+
+      /* 
+
       fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
       fOutPtr->fRcuX = fRcuX;
       fOutPtr->fRcuZ = fRcuZ;
       fOutPtr->fModuleID = fModuleID;
       tmpChannelCnt = 0;
-
-      while(fPHOSRawStream->Next())
+      
+     while(fPHOSRawStream->Next())
        {
-         //      cout << "rawanalyze fPHOSRawStream->Next()" <<endl;
          if (fPHOSRawStream->IsNewHWAddress())
            {
              if(processedChannels > 0)
@@ -198,12 +344,16 @@ AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData
            {
              tmpStartIndex = fPHOSRawStream->GetTime();
            }
-         
          fTmpChannelData[fPHOSRawStream->GetTime()] =  fPHOSRawStream->GetSignal();
          sampleCnt ++;
+
        }
 
       tmpChannelCnt ++;
+
+      cout <<"tmpChannnelCnt =" << tmpChannelCnt << endl;   
+      //      DumpChannelData(fTmpChannelData);
       fAnalyzerPtr->SetData(fTmpChannelData);
       fAnalyzerPtr->Evaluate(0, sampleCnt);
       fOutPtr->fValidData[tmpChannelCnt].fGain = tmpGain;
@@ -214,11 +364,11 @@ AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData
       ResetDataPtr(tmpStartIndex, sampleCnt);
 
       sampleCnt = 0;
-
       fOutPtr->fCnt =  tmpChannelCnt;
       AliHLTComponentBlockData bd;
       FillBlockData( bd );
       bd.fOffset = offset;
+
       bd.fSize = mysize;
       bd.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
       bd.fSpecification = 0xFFFFFFFF;
@@ -234,9 +384,11 @@ AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData
                   , tSize, size );
          return EMSGSIZE;
        }
+      */
 
-    }
-  
+
+      
+/*
   fPhosEventCount++; 
 
   if(fPrintInfo == kTRUE)
@@ -247,20 +399,32 @@ AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData
        }  
     }
   size = tSize;
+
   return 0;
 }//end DoEvent
+*/
+
 
 
 //_________________________________________________________________________________________________
 int
 AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
 {
+
+cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
+
+  fAltroDataPtr = new AliHLTAltroData();
+  fDecoderPtr = new AliHLTDDLDecoder();
   fSendChannelData = kFALSE;
   fPrintInfo = kFALSE;
   Reset();
   fRawMemoryReader = new AliRawReaderMemory();
   fPHOSRawStream = new  AliCaloRawStream(fRawMemoryReader,"PHOS");
-  fPHOSRawStream->SetOldRCUFormat(kFALSE);
+
+  //  fPHOSRawStream->SetOldRCUFormat(kFALSE);
+
+  fPHOSRawStream->SetOldRCUFormat(kTRUE);
+
   int iResult=0;
   TString argument="";
   iResult = ScanArguments(argc, argv);
@@ -271,7 +435,7 @@ AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
       cout << "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>" << endl;
       Logging( kHLTLogFatal, "HLT::AliHLTPHOSRcuHistogramProducerComponent::DoInt( int argc, const char** argv )", "Missing argument",
               "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>");
-      iResult = -2
+      iResult = -3
     }
   else
     {
@@ -279,8 +443,13 @@ AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
     }
 
   return iResult;
+
+
+return 0;
+
 }
 
+/*
 //_________________________________________________________________________________________________
 void
 AliHLTPHOSRawAnalyzerComponent::DumpData(int gain) const
@@ -300,6 +469,7 @@ AliHLTPHOSRawAnalyzerComponent::DumpData(int gain) const
        } 
     }
 }
+*/
 
 
 //_________________________________________________________________________________________________
@@ -349,6 +519,8 @@ AliHLTPHOSRawAnalyzerComponent::Reset()
 
 } // end Reset
 
+
+
 //_________________________________________________________________________________________________
 void
 AliHLTPHOSRawAnalyzerComponent::ResetDataPtr(int startindex, int sampleCnt)
index 6e778dc47b0467fe0d1ee03cb4bb8830ee920e36..a88af3dcc220b72ffd42f575cdb9ae71f9e0ae36 100644 (file)
@@ -70,11 +70,18 @@ AliHLTPHOSRawAnalyzerCrude::Evaluate(int start, int length)
 
   for(int i=start; i<length; i++)
     {
-      if(fFloatDataPtr[i] >  tmpAmplitudeMax)
+      //      if(fFloatDataPtr[i] >  tmpAmplitudeMax)
+      //       {
+      //         tmpAmplitudeMax = fFloatDataPtr[i];
+      //         tmpTime = i;               
+      //       }
+
+      if(fIntDataPtr[i] >  tmpAmplitudeMax)
        {
-         tmpAmplitudeMax = fFloatDataPtr[i];
+         tmpAmplitudeMax = fIntDataPtr[i];
          tmpTime = i;               
        }
+
     }
        
   fDAmpl = tmpAmplitudeMax;
index 9eddecc73ada4cbb3e88083614b861cb00c8f1be..e05b8c3fdb5639a34a88b1b4c11091a2ae95adde 100644 (file)
@@ -44,7 +44,8 @@ AliHLTPHOSRawAnalyzerLMS::AliHLTPHOSRawAnalyzerLMS():AliHLTPHOSRawAnalyzer()
 //_____________________________________________________________________________________________________
 AliHLTPHOSRawAnalyzerLMS::AliHLTPHOSRawAnalyzerLMS(double *dtaPtr, double fs):AliHLTPHOSRawAnalyzer() 
 {
-  fFloatDataPtr = dtaPtr;  
+  //  fFloatDataPtr = dtaPtr;  
+
   fSampleFrequency = fs;
 } //end   AliHLTPHOSRawAnalyzerLMS 
 
index 559bdf3cc1d59c5f9b1e8c3defc3a7941e09db23..082ea95a9e5e5949bf8874a28f41cc24bcd06c75 100644 (file)
@@ -105,8 +105,7 @@ AliHLTPHOSRawAnalyzerPeakFinder::Evaluate(Int_t start, Int_t length)
     }
   else
     {
-     
+
       if(length <  fTVectorSize)
        {
          tmpLength = length;
@@ -118,17 +117,21 @@ AliHLTPHOSRawAnalyzerPeakFinder::Evaluate(Int_t start, Int_t length)
       
       for(int i=0; i < tmpLength; i++)
        {  
-         fDAmpl += fAVectorPtr[i]*fFloatDataPtr[i];    
+         //      fDAmpl += fAVectorPtr[i]*fFloatDataPtr[i];    
+         fDAmpl += fAVectorPtr[i]*fIntDataPtr[i];   
        }
 
       for(int i=0; i < tmpLength; i++)
        {   
-         fDTof += fTVectorPtr[i]*fFloatDataPtr[i]; 
+         //      fDTof += fTVectorPtr[i]*fFloatDataPtr[i]; 
+         fDTof += fTVectorPtr[i]*fIntDataPtr[i]; 
        }
       
       if(fDAmpl > 900)
        {
-         Double_t tmpMax = GetMaxValue(fFloatDataPtr, tmpLength);
+         //      Double_t tmpMax = GetMaxValue(fFloatDataPtr, tmpLength);
+         Double_t tmpMax = GetMaxValue(fIntDataPtr, tmpLength);
+                                 
          if(tmpMax == 1023)
            {
              fDAmpl = tmpMax;