som minor changes, committed to be in synch with build system
authorphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 17 Jul 2007 15:44:38 +0000 (15:44 +0000)
committerphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 17 Jul 2007 15:44:38 +0000 (15:44 +0000)
HLT/PHOS/AliHLTPHOSBase.h
HLT/PHOS/AliHLTPHOSMapper.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzer.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzer.h
HLT/PHOS/AliHLTPHOSRawAnalyzerComponent.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzerComponent.h
HLT/PHOS/AliHLTPHOSRawAnalyzerPeakFinder.cxx
HLT/PHOS/AliHLTPHOSRawAnalyzerPeakFinder.h
HLT/PHOS/AliHLTPHOSRawAnalyzerPeakFinderComponent.cxx
HLT/PHOS/AliHLTPHOSRcuHistogramProducer.cxx

index 938a463..dd82b38 100644 (file)
@@ -61,10 +61,31 @@ class  AliHLTPHOSBase
        }
     }
  
+  template<typename T> 
+    T  MaxValue(T *array, int N)
+    {
+      Double_t tmpMax = 0;
+
+      for(int i = 0; i < N; i++)
+       {
+         if(array[i] > tmpMax)
+           {
+             tmpMax = array[i];
+           }
+       }
+  
+      return tmpMax;
+    }
+
+
  private:
   AliHLTPHOSBase(const AliHLTPHOSBase & );
   AliHLTPHOSBase & operator = (const AliHLTPHOSBase &);
 
+
+  ///  const struct THIS IS STRANGE;
+
+
 };
 
 #endif
index 7c3824c..cff07b2 100644 (file)
@@ -61,13 +61,14 @@ AliHLTPHOSMapper::InitAltroMapping()
          hw2geomapPtr = new altromap[maxaddr +1]; 
 
 
-         for(int i=0; i<  nChannels; i ++)
+         for(int i=0; i< maxaddr + 1 ; i ++)
            {
              hw2geomapPtr[i].col = 0;
              hw2geomapPtr[i].row = 0;
              hw2geomapPtr[i].gain = 0;
            }
 
+
          printf("\n");
 
          for(int i=0; i<nChannels; i ++)
index 47d4e0b..e1f2df7 100644 (file)
  **************************************************************************/
 
 #include "AliHLTPHOSRawAnalyzer.h"
-#include <iostream>
+//#include <iostream>
 
-using std::cout;
-using std::endl;
+//using std::cout;
+//using std::endl;
 
-//AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fFloatDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
-AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer():fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
+AliHLTPHOSRawAnalyzer:: AliHLTPHOSRawAnalyzer(): AliHLTPHOSBase(), fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999)
 {
-  //  fFloatDataPtr = new double[1008];
  fIntDataPtr = new UInt_t[1008];
 }
 
@@ -31,21 +29,21 @@ AliHLTPHOSRawAnalyzer::~AliHLTPHOSRawAnalyzer()
 
 }
 
-//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)
 {
 
 }
+*/
+
 
 /**
 * Main constructor
 * @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):fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
+AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs): AliHLTPHOSBase(), fIntDataPtr(0), fSampleFrequency(10), fTau(2), fDTof(99999), fDAmpl(99999), fStartIndex(0)
 {
-  //  fIntDataPtr = dtaPtr;  
   fSampleFrequency = fs;
 } //end  
 
@@ -61,8 +59,6 @@ AliHLTPHOSRawAnalyzer::AliHLTPHOSRawAnalyzer(double *dtaPtr, double fs):fIntData
 void 
 AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, int N)
 {
-  //  fFloatDataPtr = dataPtr;  
-
   cout << "Baseline correction not yet implemeted" << endl;
 } //end BaselineCorrection
 
@@ -76,7 +72,6 @@ AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, int N)
 void 
 AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, double baselineValue)
 {
-  //  fFloatDataPtr = dataPtr;   
   printf("\nbaselineValue = %f\n", baselineValue);
   cout << "Baseline correction not yet implemeted" << endl;
 } //end BaslineCorrection
@@ -107,15 +102,9 @@ AliHLTPHOSRawAnalyzer::GetEnergy() const
 /**
  * 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;
 }
 
@@ -173,6 +162,7 @@ AliHLTPHOSRawAnalyzer::SetStartIndex(int index)
 }
 
 
+
 void 
 AliHLTPHOSRawAnalyzer::SetTVector(Double_t *tVector, Int_t size)
 {
@@ -180,6 +170,7 @@ AliHLTPHOSRawAnalyzer::SetTVector(Double_t *tVector, Int_t size)
 }
 
 
+
 void
 AliHLTPHOSRawAnalyzer::SetAVector(Double_t *aVector, Int_t size)
 {
@@ -187,28 +178,10 @@ 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
+UInt_t
+AliHLTPHOSRawAnalyzer::GetMaxValue(UInt_t *dta, Int_t size) const
 {
 
   Double_t tmpMax = 0;
index dcbd6d0..b7f518f 100644 (file)
@@ -5,19 +5,21 @@
 
 /* $Id$ */
 
-#include "Rtypes.h"
+//#include "Rtypes.h"
 
-class AliHLTPHOSRawAnalyzer
+#include "AliHLTPHOSBase.h"
+
+class AliHLTPHOSRawAnalyzer: public AliHLTPHOSBase
 {
  public:
   AliHLTPHOSRawAnalyzer();
   virtual ~AliHLTPHOSRawAnalyzer();
   AliHLTPHOSRawAnalyzer(double *dataPtr, double fs);
-  AliHLTPHOSRawAnalyzer(const AliHLTPHOSRawAnalyzer & );
-  AliHLTPHOSRawAnalyzer & operator = (const AliHLTPHOSRawAnalyzer &)
-    {
-      return *this;
-    }
+  //  AliHLTPHOSRawAnalyzer(const AliHLTPHOSRawAnalyzer & );
+  //  AliHLTPHOSRawAnalyzer & operator = (const AliHLTPHOSRawAnalyzer &)
+  //   {
+  //      return *this;
+  //   }
 
   void BaselineCorrection(double *dataPtr, int N);
   void BaselineCorrection(double *dataPtr, double baselineValue);  
@@ -32,20 +34,22 @@ class AliHLTPHOSRawAnalyzer
   void SetStartIndex(int startIndex);
   void MakeInitialGuess();
   void MakeInitialGuess(int treshold);
+  
+
   virtual void SetTVector(Double_t *tVector, Int_t size);
   virtual void SetAVector(Double_t *aVector, Int_t size);
 
+
   /**
    *Abstratct class documentation
    */
   virtual void Evaluate(Int_t start = 0, Int_t lenght = 100) = 0;
   //  Double_t GetMaxValue(Double_t *dta, Int_t size) const;
-  UInt_t GetMaxValue(UInt_t *dta, Int_t size) const;
+  //  UInt_t GetMaxValue(UInt_t *dta, Int_t size) const;
 
  protected:
   Double_t   *fFloatDataPtr;   /**<Float representation of data that should be fitted */
   UInt_t   *fIntDataPtr;   /**<data that should be fitted */
-
   double     fSampleFrequency; /**<The ADC sample frequency in MHz used under data taking */
   double     fDTofGuess;       /**<Initial guess for t0*/
   double     fDAmplGuess;      /**<Initial guess for amplitude*/
index 5c10748..6787fd3 100644 (file)
 #include "AliHLTDDLDecoder.h"
 #include "AliHLTAltroData.h"
 #include "AliHLTPHOSMapper.h"
+#include "AliHLTAltroBunch.h"
 
-
-using namespace std;
+//using namespace std;
 
 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTPHOSRcuProcessor(), fAnalyzerPtr(0), 
-fSendChannelData(kFALSE),fOutPtr(0)
+                                                                fSendChannelData(kFALSE),fOutPtr(0), fMapperPtr(0), fDecoderPtr(0), 
+                                                                fAltroDataPtr(0), fAltroBunchPtr(0) 
 {
   fMapperPtr = new AliHLTPHOSMapper();
+  
 } 
 
 
@@ -90,12 +92,18 @@ AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData
   UInt_t tSize            = 0;
   Int_t tmpChannelCnt     = 0;
   AliHLTUInt8_t* outBPtr;
+
+  AliHLTAltroBunch *bunchPtr;
+
   outBPtr = outputPtr;
   const AliHLTComponentBlockData* iter = NULL; 
   unsigned long ndx;
 
+
+
   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
     {
+      //      Int_t tmpChannelCnt= 0;
       iter = blocks+ndx;
       mysize = 0;
       offset = tSize;
@@ -114,18 +122,60 @@ AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData
 
       while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
        {
+         //      if(fAltroDataPtr->fDataSize != 0)
+         //        {
+         //          cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent, dumping data, size ="<< fAltroDataPtr->fDataSize<< endl;
+         //          DumpData(fAltroDataPtr->fData, fAltroDataPtr->fDataSize, 4);
+         //          if(fAltroDataPtr->fIsComplete == true)
+         //            {
+         //              while(fAltroDataPtr->NextBunch(fAltroBunchPtr) == true)
+         //                {
+         //          cout << "bunchsize =" << fAltroBunchPtr->fBunchSize <<endl;
+         //                }
 
          fAnalyzerPtr->SetData(fAltroDataPtr->fData);
          fAnalyzerPtr->Evaluate(0, fAltroDataPtr->fDataSize -2);  
+         
+         if(MaxValue(fAltroDataPtr->fData, fAltroDataPtr->fDataSize) > 100)
+           {
+             DumpData(fAltroDataPtr->fData,fAltroDataPtr->fDataSize, 4);
+           }
+
+         //      cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent, cnt = " <<tmpChannelCnt <<endl;
+         //      cout << "branch =" <<  fAltroDataPtr->GetBranch()<< "  card = " <<fAltroDataPtr->GetCard() <<  "chip = " <<  fAltroDataPtr->GetChip() <<" channel"
+         
+         
+                 
+         //  fAnalyzerPtr->SetData(fAltroBunchPtr->fData);
+         //      fAnalyzerPtr->Evaluate(0, fAltroBunchPtr->fBunchSize);  
+         //      DumpData();
+
+         /*
+           cout << "AliHLTPHOSRawAnalyzerComponent::DoEven. dumping data"  << endl;
+           DumpData(fAltroBunchPtr->fData, fAltroBunchPtr->fBunchSize,4);
+           cout << endl;
+           cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent. finnsihed dumping data"  << endl;
+         */
+
          fOutPtr->fValidData[tmpChannelCnt].fZ  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].row;
          fOutPtr->fValidData[tmpChannelCnt].fX  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].col; 
+         fOutPtr->fValidData[tmpChannelCnt].fGain  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].gain; 
          fOutPtr->fValidData[tmpChannelCnt].fEnergy  = (float)fAnalyzerPtr->GetEnergy();
          fOutPtr->fValidData[tmpChannelCnt].fTime    = (float)fAnalyzerPtr->GetTiming();
          tmpChannelCnt ++;
+         //            }
+         //          else
+         //            {
+         //              cout << "AliHLTPHOSRawAnalyzerComponent::DoEvent, WARNING, altroblock is incomplete" << endl;
+         //            }
+                 
        }
+        
+      //  }
+    
 
       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
-
       fOutPtr->fCnt =  tmpChannelCnt;
       AliHLTComponentBlockData bd;
       FillBlockData( bd );
@@ -172,6 +222,7 @@ AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
 {
   cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
   fAltroDataPtr = new AliHLTAltroData();
+  fAltroBunchPtr = new AliHLTAltroBunch();
   fDecoderPtr = new AliHLTDDLDecoder();
   fSendChannelData = kFALSE;
   fPrintInfo = kFALSE;
index 4b88139..80c3bbf 100644 (file)
@@ -11,6 +11,7 @@ class AliHLTPHOSRcuChannelDataStruct;
 class AliHLTPHOSMapper;
 class AliHLTDDLDecoder;
 class AliHLTAltroData;
+class AliHLTAltroBunch;
 
 class AliHLTPHOSRawAnalyzerComponent: public AliHLTPHOSRcuProcessor
 {
@@ -40,6 +41,7 @@ class AliHLTPHOSRawAnalyzerComponent: public AliHLTPHOSRcuProcessor
   AliHLTPHOSMapper *fMapperPtr;
   AliHLTDDLDecoder *fDecoderPtr;
   AliHLTAltroData  *fAltroDataPtr;
+  AliHLTAltroBunch *fAltroBunchPtr;
 };
 #endif
 
index 082ea95..9c103da 100644 (file)
  **************************************************************************/
 
 #include "AliHLTPHOSRawAnalyzerPeakFinder.h"
-#include <iostream>
+//#include <iostream>
 #include <cmath>
 
+
 using std::cout;
 using std::endl;
 
 ClassImp(AliHLTPHOSRawAnalyzerPeakFinder) 
 
 
-AliHLTPHOSRawAnalyzerPeakFinder::AliHLTPHOSRawAnalyzerPeakFinder(const AliHLTPHOSRawAnalyzerPeakFinder&):AliHLTPHOSRawAnalyzer() , fTVectorPtr(0), fAVectorPtr(0), fTVectorSize(0), fAVectorSize(0)
-{
+  //AliHLTPHOSRawAnalyzerPeakFinder::AliHLTPHOSRawAnalyzerPeakFinder(const AliHLTPHOSRawAnalyzerPeakFinder&):AliHLTPHOSRawAnalyzer() , fTVectorPtr(0), fAVectorPtr(0), fTVectorSize(0), fAVectorSize(0)
+  //{
 
 
-}
+  //}
 
 
 /**
@@ -51,6 +52,8 @@ AliHLTPHOSRawAnalyzerPeakFinder::~AliHLTPHOSRawAnalyzerPeakFinder()
 
 } //end AliHLTPHOSRawAnalyzerPeakFinder
 
+
+
 void 
 AliHLTPHOSRawAnalyzerPeakFinder::SetTVector(Double_t *tVec, Int_t size)
 {
@@ -91,6 +94,7 @@ AliHLTPHOSRawAnalyzerPeakFinder::SetAVector(Double_t *aVec, Int_t size)
 }
 
 
+
 //___________________________________________________________________
 void 
 AliHLTPHOSRawAnalyzerPeakFinder::Evaluate(Int_t start, Int_t length)
@@ -99,6 +103,10 @@ AliHLTPHOSRawAnalyzerPeakFinder::Evaluate(Int_t start, Int_t length)
   fDAmpl = 0;
   Int_t tmpLength;
 
+  //  cout << "AliHLTPHOSRawAnalyzerPeakFinder::Evaluate(), dumping data" << endl; 
+
+  //  DumpData(fIntDataPtr, length, 16);
+
   if(fTVectorPtr == 0 || fAVectorPtr == 0)
     {
 
@@ -130,8 +138,10 @@ AliHLTPHOSRawAnalyzerPeakFinder::Evaluate(Int_t start, Int_t length)
       if(fDAmpl > 900)
        {
          //      Double_t tmpMax = GetMaxValue(fFloatDataPtr, tmpLength);
-         Double_t tmpMax = GetMaxValue(fIntDataPtr, tmpLength);
-                                 
+         //      Double_t tmpMax = GetMaxValue(fIntDataPtr, tmpLength);
+         Double_t tmpMax = MaxValue(fIntDataPtr, tmpLength); 
+         
          if(tmpMax == 1023)
            {
              fDAmpl = tmpMax;
index eda89c4..13a3bc8 100644 (file)
@@ -3,19 +3,21 @@
 /* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                          */
 
-#include <Rtypes.h>
-#include "TObject.h"
+//#include <Rtypes.h>
+//#include "TObject.h"
 #include "AliHLTPHOSRawAnalyzer.h"
+//#include "AliHLTPHOSBase.h"
 
 class AliHLTPHOSRawAnalyzerPeakFinder : public AliHLTPHOSRawAnalyzer
 {
  public:
   AliHLTPHOSRawAnalyzerPeakFinder();
-  AliHLTPHOSRawAnalyzerPeakFinder(const AliHLTPHOSRawAnalyzerPeakFinder & );
-  AliHLTPHOSRawAnalyzerPeakFinder & operator = (const AliHLTPHOSRawAnalyzerPeakFinder &)
-    {
-      return *this; 
-    }
+  //  AliHLTPHOSRawAnalyzerPeakFinder(const AliHLTPHOSRawAnalyzerPeakFinder & );
+  //  AliHLTPHOSRawAnalyzerPeakFinder & operator = (const AliHLTPHOSRawAnalyzerPeakFinder &)
+  //    {
+  //     return *this; 
+  //    }
+
   virtual ~AliHLTPHOSRawAnalyzerPeakFinder();
 
 
index 984f9a8..26ebec2 100644 (file)
 
 #include "AliHLTPHOSRawAnalyzerPeakFinderComponent.h"
 #include "AliHLTPHOSRawAnalyzerPeakFinder.h"
-#include <cstdlib>
-#include "AliHLTPHOSCommonDefs.h"
-
-
+//#include <cstdlib>
+//#include "AliHLTPHOSCommonDefs.h"
 
 
 AliHLTPHOSRawAnalyzerPeakFinderComponent gAliHLTPHOSRawAnalyzerPeakFinderComponent;
index edf31fb..142828b 100644 (file)
@@ -128,7 +128,9 @@ AliHLTPHOSRcuHistogramProducer::SetModuleID(AliHLTUInt8_t moduleID)
 void 
 AliHLTPHOSRcuHistogramProducer::FillEnergy(AliHLTUInt8_t x, AliHLTUInt8_t z,  AliHLTUInt8_t gain, float energy)
 {
-  //  cout << "AliHLTPHOSRcuHistogramProducer::FillEnergy x = " << (int)x<< "  z=  " << (int)z<<endl;
+  //  cout << "AliHLTPHOSRcuHistogramProducer::FillEnergy x = " << (int)x<< "  z=  " << (int)z;
+  //  cout << " Energy =" <<  energy;
+  //  cout << " Accumulated energy" <<fCellAccEnergy.fAccumulatedEnergies[x][z][gain] << endl; 
   //See header file for documentation
   fCellAccEnergy.fAccumulatedEnergies[x][z][gain] += energy;
   fCellAccEnergy.fHits[x][z][gain] ++;