}
}
+ 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
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 ++)
**************************************************************************/
#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];
}
}
-//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
void
AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, int N)
{
- // fFloatDataPtr = dataPtr;
-
cout << "Baseline correction not yet implemeted" << endl;
} //end BaselineCorrection
void
AliHLTPHOSRawAnalyzer::BaselineCorrection(double *dataPtr, double baselineValue)
{
- // fFloatDataPtr = dataPtr;
printf("\nbaselineValue = %f\n", baselineValue);
cout << "Baseline correction not yet implemeted" << endl;
} //end BaslineCorrection
/**
* 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;
}
}
+
void
AliHLTPHOSRawAnalyzer::SetTVector(Double_t *tVector, Int_t size)
{
}
+
void
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;
/* $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);
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*/
#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();
+
}
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;
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 );
{
cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
fAltroDataPtr = new AliHLTAltroData();
+ fAltroBunchPtr = new AliHLTAltroBunch();
fDecoderPtr = new AliHLTDDLDecoder();
fSendChannelData = kFALSE;
fPrintInfo = kFALSE;
class AliHLTPHOSMapper;
class AliHLTDDLDecoder;
class AliHLTAltroData;
+class AliHLTAltroBunch;
class AliHLTPHOSRawAnalyzerComponent: public AliHLTPHOSRcuProcessor
{
AliHLTPHOSMapper *fMapperPtr;
AliHLTDDLDecoder *fDecoderPtr;
AliHLTAltroData *fAltroDataPtr;
+ AliHLTAltroBunch *fAltroBunchPtr;
};
#endif
**************************************************************************/
#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)
+ //{
-}
+ //}
/**
} //end AliHLTPHOSRawAnalyzerPeakFinder
+
+
void
AliHLTPHOSRawAnalyzerPeakFinder::SetTVector(Double_t *tVec, Int_t size)
{
}
+
//___________________________________________________________________
void
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)
{
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;
/* 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();
#include "AliHLTPHOSRawAnalyzerPeakFinderComponent.h"
#include "AliHLTPHOSRawAnalyzerPeakFinder.h"
-#include <cstdlib>
-#include "AliHLTPHOSCommonDefs.h"
-
-
+//#include <cstdlib>
+//#include "AliHLTPHOSCommonDefs.h"
AliHLTPHOSRawAnalyzerPeakFinderComponent gAliHLTPHOSRawAnalyzerPeakFinderComponent;
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] ++;