From: phille Date: Sun, 11 Mar 2007 20:09:21 +0000 (+0000) Subject: New classes that updates histograms contniously during run. X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=792f66f1393e00e8abefe42ab6f735a7ca6d12e0 New classes that updates histograms contniously during run. TH1F Histograms for each crystal are written to file at the end of run. There is one root file for each readoutpaartition. --- diff --git a/HLT/PHOS/AliHLTPHOSRcuHistogramProducer.cxx b/HLT/PHOS/AliHLTPHOSRcuHistogramProducer.cxx new file mode 100644 index 00000000000..bfad40f6005 --- /dev/null +++ b/HLT/PHOS/AliHLTPHOSRcuHistogramProducer.cxx @@ -0,0 +1,212 @@ +/************************************************************************** + * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. * + * * + * Authors: Boris Polichtchouk & Per Thomas Hille for the ALICE * + * offline/HLT Project. Contributors are mentioned in the code where * + * appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +#include "AliHLTPHOSRcuHistogramProducer.h" +#include +#include "stdio.h" +#include +#include "AliHLTPHOSRcuCellEnergyDataStruct.h" +#include "TFile.h" + +/************************************************************************* +* Class AliHLTPHOSRcuHistogramProducer accumulating histograms * +* with amplitudes per PHOS channel * +* It is intended to run at the HLT farm * +* and it fills the histograms with amplitudes per channel. * +* Usage example see in PHOS/macros/Shuttle/AliPHOSCalibHistoProducer.C * +**************************************************************************/ +AliHLTPHOSRcuHistogramProducer:: AliHLTPHOSRcuHistogramProducer(): fEventCount(0), fEquippmentID(0), fModuleID(0), fRcuX(0), fRcuZ(0) +{ + cout << "WARNING: You cannot invoke the AliHLTPHOSRcuHistogramProducer without arguments" << endl; + cout << "Usage AliHLTPHOSRcuHistogramProducer(ModuleID, X. Z)" << endl; + // Reset(); + // Init(); +} + +AliHLTPHOSRcuHistogramProducer::AliHLTPHOSRcuHistogramProducer(AliHLTUInt8_t moduleID, AliHLTUInt8_t rcuX, AliHLTUInt8_t rcuZ) +{ + SetModuleID(moduleID); + SetRcuX(rcuX); + SetRcuZ(rcuZ); + Init(); +} + +AliHLTPHOSRcuHistogramProducer::~ AliHLTPHOSRcuHistogramProducer() +{ + +} + + +void +AliHLTPHOSRcuHistogramProducer::Init() +{ + char tmpHistoName[256]; + int geomx; + int geomz; + + + for(int x = 0; x < N_XCOLUMNS_RCU; x ++) + { + for(int z = 0; z < N_ZROWS_RCU; z ++) + { + for(int gain = 0; gain < N_GAINS; gain ++) + { + geomx = x + N_XCOLUMNS_RCU*fRcuX; + geomz = z + N_ZROWS_RCU*fRcuZ; + + fEnergyAverageValues[x][z][gain] = 0; + fAccumulatedValues[x][z][gain] = 0; + fTimingAverageValues[x][z][gain] = 0; + fHits[x][z][gain] = 0; + sprintf(tmpHistoName, "Edistribution_%d_%d_%d_%d",(int)fModuleID, geomx, geomz, gain); + fEnergyHistogramPtrs[x][z][gain] = 0; + + fEnergyHistogramPtrs[x][z][gain] = new TH1F( tmpHistoName, tmpHistoName, N_BINS, XBIN_LOW, XBIN_UP); + + sprintf(tmpHistoName, "TOFdistribution_%d_%d_%d_%d",(int)fModuleID, geomx, geomz, gain); + + fTimingHistogramPtrs[x][z][gain] = 0; + + fTimingHistogramPtrs[x][z][gain] = new TH1F(tmpHistoName , tmpHistoName, N_BINS, XBIN_LOW, XBIN_UP); + + fCellAccEnergy.fAccumulatedEnergies[x][z][gain] = 0; + fCellAccEnergy.fHits[x][z][gain] = 0; + fCellAccEnergy.fModuleID = 0; + fCellAccEnergy.fRcuX = 0; + fCellAccEnergy.fRcuZ = 0; + } + } + } +} + +int +AliHLTPHOSRcuHistogramProducer::GetEquippmentId() +{ + return fEquippmentID; +} + + +void +AliHLTPHOSRcuHistogramProducer::SetRcuX(AliHLTUInt8_t X) +{ + fRcuX = X; + fCellAccEnergy.fRcuX = X; +} + + +void +AliHLTPHOSRcuHistogramProducer::SetRcuZ(AliHLTUInt8_t Z) +{ + fRcuZ = Z; + fCellAccEnergy.fRcuZ = Z; +} + + +void +AliHLTPHOSRcuHistogramProducer::SetModuleID(AliHLTUInt8_t moduleID) +{ + fModuleID = moduleID; +} + + +void +AliHLTPHOSRcuHistogramProducer::SetEquippmentId(int id) +{ + fEquippmentID = id; +} + + +void +AliHLTPHOSRcuHistogramProducer::FillEnergy(AliHLTUInt8_t x, AliHLTUInt8_t z, AliHLTUInt8_t gain, float energy) +{ + fCellAccEnergy.fAccumulatedEnergies[x][z][gain] += energy; + fCellAccEnergy.fHits[x][z][gain] ++; + fEnergyHistogramPtrs[x][z][gain]->Fill(energy); +} + + +void +AliHLTPHOSRcuHistogramProducer::FillTime(AliHLTUInt8_t x, AliHLTUInt8_t z, AliHLTUInt8_t gain, float time) +{ + fTimingHistogramPtrs[x][z][gain]->Fill(time); +} + +const AliHLTPHOSRcuCellAccumulatedEnergyDataStruct& +AliHLTPHOSRcuHistogramProducer::GetCellAccumulatedEnergies() +{ + // return &fCellAccEnergy ; + return fCellAccEnergy ; +} + +int +AliHLTPHOSRcuHistogramProducer::IncrementEventCounter() +{ + fEventCount ++; + return fEventCount; +} + + +void +AliHLTPHOSRcuHistogramProducer::Reset() +{ + for(int x = 0; x < N_XCOLUMNS_RCU; x ++) + { + for(int z = 0; z < N_ZROWS_RCU; z ++) + { + for(int gain = 0; gain < N_GAINS; gain ++) + { + fEnergyAverageValues[x][z][gain] = 0; + fAccumulatedValues[x][z][gain] = 0; + fTimingAverageValues[x][z][gain] = 0; + fHits[x][z][gain] = 0; + } + } + } + + for(int i = 0; i IsOpen()) return; + + cout <<"printing histograms"<< endl; + cout <<"histofile-Getname() =" << histoFile->GetName() << endl; + + for(int x = 0; x < N_XCOLUMNS_RCU; x ++) + { + for(int z = 0; z < N_ZROWS_RCU; z ++) + { + for(int gain = 0; gain < N_GAINS; gain ++) + { + fEnergyHistogramPtrs[x][z][gain]->Write(); + } + } + } + + cout << "printing histograms, finished"<< endl; + histoFile->Close(); + +} diff --git a/HLT/PHOS/AliHLTPHOSRcuHistogramProducer.h b/HLT/PHOS/AliHLTPHOSRcuHistogramProducer.h new file mode 100644 index 00000000000..ccbf60510d8 --- /dev/null +++ b/HLT/PHOS/AliHLTPHOSRcuHistogramProducer.h @@ -0,0 +1,65 @@ +#ifndef ALIHLTPHOSRCUHISTOGRAMPRODUCER_H +#define ALIHLTPHOSRCUHISTOGRAMPRODUCER_H + +/* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +#include "AliHLTPHOSDefinitions.h" +#include "AliHLTPHOSCommonDefs.h" +#include "TH1.h" +//#include "AliHLTPHOSModuleCellAccumulatedEnergyDataStruct.h" +#include "AliHLTPHOSRcuCellAccumulatedEnergyDataStruct.h" + +#define XBIN_LOW 0 +#define XBIN_UP 1023 +#define N_BINS 1023 + +class AliHLTPHOSRcuHistogramProducer +{ + public: + AliHLTPHOSRcuHistogramProducer(); + AliHLTPHOSRcuHistogramProducer(AliHLTUInt8_t moduleID, AliHLTUInt8_t rcuX, AliHLTUInt8_t rcuZ); + + virtual ~AliHLTPHOSRcuHistogramProducer(); + int GetEquippmentId(); + const AliHLTPHOSRcuCellAccumulatedEnergyDataStruct& GetCellAccumulatedEnergies(); + int IncrementEventCounter(); + void Init(); + void SetEquippmentId(int id); + void SetRcuX(AliHLTUInt8_t X); + void SetRcuZ(AliHLTUInt8_t Z); + void SetModuleID(AliHLTUInt8_t moduleID); + void FillEnergy(AliHLTUInt8_t x, AliHLTUInt8_t z, AliHLTUInt8_t gain, float energy); + void FillTime(AliHLTUInt8_t x, AliHLTUInt8_t z, AliHLTUInt8_t gain, float time); + void Reset(); + void WriteEnergyHistograms(); + + + protected: + + private: + AliHLTPHOSRcuHistogramProducer(const AliHLTPHOSRcuHistogramProducer & ); + AliHLTPHOSRcuHistogramProducer & operator = (const AliHLTPHOSRcuHistogramProducer &) + { + return *this; + }; + + TH1F *fEnergyHistogramPtrs[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; + TH1F *fTimingHistogramPtrs[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; + + Float_t fEnergyAverageValues[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; + Double_t fAccumulatedValues[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; + Float_t fTimingAverageValues[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; + AliHLTUInt32_t fHits[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; + int fEventCount; + AliHLTUInt32_t fEquippmentID; + Double_t fTmpChannelData[ALTRO_MAX_SAMPLES]; + // AliHLTPHOSModuleCellAccumulatedEnergyDataStruct* fOutPtr; + AliHLTPHOSRcuCellAccumulatedEnergyDataStruct fCellAccEnergy; + // AliHLTPHOSRcuCellAccumulatedEnergyDataStruct* fOutPtr; + AliHLTUInt8_t fModuleID; + AliHLTUInt8_t fRcuX; + AliHLTUInt8_t fRcuZ; +}; + +#endif diff --git a/HLT/PHOS/AliHLTPHOSRcuHistogramProducerComponent.cxx b/HLT/PHOS/AliHLTPHOSRcuHistogramProducerComponent.cxx new file mode 100644 index 00000000000..705f3d679c1 --- /dev/null +++ b/HLT/PHOS/AliHLTPHOSRcuHistogramProducerComponent.cxx @@ -0,0 +1,318 @@ +/************************************************************************** + * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. * + * * + * Authors: Boris Polichtchouk & Per Thomas Hille for the ALICE * + * offline/HLT Project. Contributors are mentioned in the code where * + * appropriate. * + * * + * Permission to use, copy, modify and distribute this software and its * + * documentation strictly for non-commercial purposes is hereby granted * + * without fee, provided that the above copyright notice appears in all * + * copies and that both the copyright notice and this permission notice * + * appear in the supporting documentation. The authors make no claims * + * about the suitability of this software for any purpose. It is * + * provided "as is" without express or implied warranty. * + **************************************************************************/ + +#include +#include "stdio.h" +#include +#include "AliHLTPHOSRcuCellEnergyDataStruct.h" +//#include "AliHLTPHOSModuleCellAccumulatedEnergyDataStruct.h" +#include "AliHLTPHOSRcuHistogramProducer.h" +#include "AliHLTPHOSRcuHistogramProducerComponent.h" + + + +const AliHLTComponentDataType AliHLTPHOSRcuHistogramProducerComponent::inputDataTypes[]={kAliHLTVoidDataType,{0,"",""}}; //'zero' terminated array +const AliHLTComponentDataType AliHLTPHOSRcuHistogramProducerComponent::outputDataType=kAliHLTVoidDataType; +AliHLTPHOSRcuHistogramProducerComponent gAliHLTPHOSRcuHistogramProducerComponent; + +//AliHLTPHOSHistogramProducerComponent gAliHLTPHOSHistogramProducerComponent; +/************************************************************************* +* Class AliHLTPHOSRcuHistogramProducerComponent accumulating histograms * +* with amplitudes per PHOS channel * +* It is intended to run at the HLT farm * +* and it fills the histograms with amplitudes per channel. * +* Usage example see in PHOS/macros/Shuttle/AliPHOSCalibHistoProducer.C * +**************************************************************************/ +AliHLTPHOSRcuHistogramProducerComponent:: AliHLTPHOSRcuHistogramProducerComponent():AliHLTProcessor(), fEventCount(0), fRcuHistoProducerPtr(0) +{ + // Reset(); +} + + + +AliHLTPHOSRcuHistogramProducerComponent::~ AliHLTPHOSRcuHistogramProducerComponent() +{ + +} + + +AliHLTPHOSRcuHistogramProducerComponent::AliHLTPHOSRcuHistogramProducerComponent(const AliHLTPHOSRcuHistogramProducerComponent & ) : AliHLTProcessor(), fEventCount(0), fRcuHistoProducerPtr(0) +{ + +} + + +int +AliHLTPHOSRcuHistogramProducerComponent::Deinit() +{ + cout << "AliHLTPHOSRcuHistogramProducerComponent::Deinit()" << endl; + fRcuHistoProducerPtr->WriteEnergyHistograms(); + return 0; +} + + +int +AliHLTPHOSRcuHistogramProducerComponent::DoDeinit() +{ + Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRcuHistogramProducer DoDeinit"); + return 0; +} + + +const char* +AliHLTPHOSRcuHistogramProducerComponent::GetComponentID() +{ + return "RcuHistogramProducer"; +} + + +void + AliHLTPHOSRcuHistogramProducerComponent::GetInputDataTypes( vector& list) +{ + const AliHLTComponentDataType* pType=inputDataTypes; + while (pType->fID!=0) + { + list.push_back(*pType); + pType++; + } +} + + +AliHLTComponentDataType +AliHLTPHOSRcuHistogramProducerComponent::GetOutputDataType() +{ + return AliHLTPHOSDefinitions::gkCellEnergyDataType; +} + + +void +AliHLTPHOSRcuHistogramProducerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier ) +{ + constBase = 30; + inputMultiplier = 1; +} + + +int AliHLTPHOSRcuHistogramProducerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, + AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, + AliHLTUInt32_t& size, vector& outputBlocks ) +{ + unsigned long ndx = 0; + UInt_t offset = 0; + UInt_t mysize = 0; + UInt_t tSize = 0; + const AliHLTComponentBlockData* iter = NULL; + AliHLTPHOSRcuCellEnergyDataStruct *cellDataPtr; + AliHLTUInt8_t* outBPtr; + + // outBPtr = outputPtr; + // fOutPtr = (AliHLTPHOSRcuCellAccumulatedEnergyDataStruct*)outBPtr; + int tmpCnt; + + for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) + { + iter = blocks+ndx; + cellDataPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)( iter->fPtr); + tmpCnt = cellDataPtr->fCnt; + + for(int i= 0; i <= tmpCnt; i ++) + { + fRcuHistoProducerPtr->FillEnergy(cellDataPtr->fValidData[i].fX, + cellDataPtr->fValidData[i].fZ, + cellDataPtr->fValidData[i].fGain, + cellDataPtr->fValidData[i].fEnergy); + } + } + + outBPtr = outputPtr; + fOutPtr = (AliHLTPHOSRcuCellAccumulatedEnergyDataStruct*)outBPtr; + const AliHLTPHOSRcuCellAccumulatedEnergyDataStruct &innPtr = fRcuHistoProducerPtr->GetCellAccumulatedEnergies(); + + fOutPtr->fModuleID = fModuleID; + fOutPtr->fRcuX = fRcuX; + fOutPtr->fRcuZ = fRcuZ; + + + for(int x=0; x < N_XCOLUMNS_RCU; x ++) + { + for(int z=0; z < N_XCOLUMNS_RCU; z ++) + { + for(int gain =0; gain < N_GAINS; gain ++) + { + fOutPtr->fAccumulatedEnergies[x][z][gain] = innPtr.fAccumulatedEnergies[x][z][gain]; + fOutPtr->fHits[x][z][gain] = innPtr.fHits[x][z][gain]; + } + } + } + + + //pushing data to shared output memory + mysize += sizeof(AliHLTPHOSRcuCellAccumulatedEnergyDataStruct); + AliHLTComponentBlockData bd; + FillBlockData( bd ); + bd.fOffset = offset; + bd.fSize = mysize; + bd.fDataType = AliHLTPHOSDefinitions::gkCellAccumulatedEnergyDataType; + bd.fSpecification = 0xFFFFFFFF; + outputBlocks.push_back( bd ); + tSize += mysize; + outBPtr += mysize; + + if( tSize > size ) + { + Logging( kHLTLogFatal, "HLT::AliHLTRcuHistogramProducerComponent::DoEvent", "Too much data", + "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu." + , tSize, size ); + return EMSGSIZE; + } + + fEventCount++; + return 0; +}//end DoEvent + + +int +AliHLTPHOSRcuHistogramProducerComponent::DoInit( int argc, const char** argv ) +{ + int iResult=0; + TString argument=""; + // fRcuHistoProducerPtr = new AliHLTPHOSRcuHistogramProducer(); + AliHLTUInt8_t tmpRcuX; + AliHLTUInt8_t tmpRcuZ; + AliHLTUInt8_t tmpModuleID; + Bool_t isSetEquippmentID = kFALSE; + + for(int i=0; i=0; i++) + { + argument=argv[i]; + + if (argument.IsNull()) + { + continue; + } + if (argument.CompareTo("-equipmentID") == 0) + { + if(i+1 <= argc) + { + fEquippmentID = atoi(argv[i+1]); + isSetEquippmentID = kTRUE; + } + else + { + iResult= -1; + Logging( kHLTLogFatal, "HLT::AliHLTPHOSRcuHistogramProducerComponent::DoInt( int argc, const char** argv )", "Missing argument", + "The argument -equippmentID expects a number"); + return iResult; + } + } + + int rcuIndex = (fEquippmentID - 1792)%N_RCUS_PER_MODULE; + // fModuleID = (fEquippmentID -1792 -rcuIndex)/N_RCUS_PER_MODULE; + tmpModuleID = ((fEquippmentID -1792 -rcuIndex)/N_RCUS_PER_MODULE); + SetModuleID(tmpModuleID); + + if(rcuIndex == 0) + { + tmpRcuX = 0; + tmpRcuZ = 0; + } + + if(rcuIndex == 1) + { + tmpRcuX = 0; + tmpRcuZ = 1; + } + + if(rcuIndex == 2) + { + tmpRcuX = 1; + tmpRcuZ = 0; + } + + if(rcuIndex == 3) + { + tmpRcuX = 1; + tmpRcuZ = 1; + } + + SetRcuX(tmpRcuX); + SetRcuZ(tmpRcuZ); + cout <<"********InitInfo************"<< endl; + cout <<"AliHLTPHOSRcuHistogramProducerComponent::SetCoordinate"<< endl; + cout <<"Equpippment ID =\t"<< fEquippmentID <"); + iResult = -2; + } + + + fRcuHistoProducerPtr = new AliHLTPHOSRcuHistogramProducer( tmpModuleID, tmpRcuX, tmpRcuZ); + + + return iResult; +} + + +void +AliHLTPHOSRcuHistogramProducerComponent::SetRcuX(AliHLTUInt8_t X) +{ + fRcuX = X; +} + + +void +AliHLTPHOSRcuHistogramProducerComponent::SetRcuZ(AliHLTUInt8_t Z) +{ + fRcuZ = Z; +} + + +void +AliHLTPHOSRcuHistogramProducerComponent::SetModuleID(AliHLTUInt8_t moduleID) +{ + fModuleID = moduleID; +} + + +void +AliHLTPHOSRcuHistogramProducerComponent::SetEquippmentId(int id) +{ + fEquippmentID = id; + fRcuHistoProducerPtr->SetEquippmentId(id); +} + + +int +AliHLTPHOSRcuHistogramProducerComponent::GetEquippmentId() +{ + return fEquippmentID; +} + + +AliHLTComponent* +AliHLTPHOSRcuHistogramProducerComponent::Spawn() +{ + return new AliHLTPHOSRcuHistogramProducerComponent; +} + + diff --git a/HLT/PHOS/AliHLTPHOSRcuHistogramProducerComponent.h b/HLT/PHOS/AliHLTPHOSRcuHistogramProducerComponent.h new file mode 100644 index 00000000000..3efba03f6ea --- /dev/null +++ b/HLT/PHOS/AliHLTPHOSRcuHistogramProducerComponent.h @@ -0,0 +1,61 @@ +#ifndef ALIHLTPHOSRCUHISTOGRAMPRODUCERCOMPONENT_H +#define ALIHLTPHOSRCUHISTOGRAMPRODUCERCOMPONENT_H + +/* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +#include "AliHLTProcessor.h" +#include "AliHLTPHOSDefinitions.h" +#include "AliHLTPHOSCommonDefs.h" +//#include "AliHLTPHOSModuleCellAccumulatedEnergyDataStruct.h" +#include "AliHLTPHOSRcuCellAccumulatedEnergyDataStruct.h" +#include "Rtypes.h" + +class AliHLTPHOSRcuHistogramProducer; + +class AliHLTPHOSRcuHistogramProducerComponent:public AliHLTProcessor +{ + public: + AliHLTPHOSRcuHistogramProducerComponent(); + virtual ~AliHLTPHOSRcuHistogramProducerComponent(); + virtual int DoInit( int argc, const char** argv ); + virtual int Deinit(); + virtual int DoDeinit(); + virtual int DoEvent(const AliHLTComponentEventData&, const AliHLTComponentBlockData*, AliHLTComponentTriggerData&, AliHLTUInt8_t*, + AliHLTUInt32_t&, std::vector >&); + virtual void GetInputDataTypes(std::vector >&); + virtual AliHLTComponentDataType GetOutputDataType(); + virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier); + virtual AliHLTComponent* Spawn(); + + virtual const char* GetComponentID(); + int GetEquippmentId(); + void SetRcuX(AliHLTUInt8_t X); + void SetRcuZ(AliHLTUInt8_t Z); + void SetModuleID(AliHLTUInt8_t moduleID); + void SetEquippmentId(int id); + + + private: + AliHLTPHOSRcuHistogramProducerComponent(const AliHLTPHOSRcuHistogramProducerComponent & ); + AliHLTPHOSRcuHistogramProducerComponent & operator = (const AliHLTPHOSRcuHistogramProducerComponent &) + { + return *this; + }; + int fEventCount; + AliHLTUInt8_t fRcuX; + AliHLTUInt8_t fRcuZ; + AliHLTUInt8_t fModuleID; + AliHLTPHOSRcuHistogramProducer* fRcuHistoProducerPtr; + AliHLTPHOSRcuCellAccumulatedEnergyDataStruct* fOutPtr; + + // AliHLTPHOSRcuCellAccumulatedEnergyDataStruct* fInnPtr; + // AliHLTPHOSRcuCellAccumulatedEnergyDataStruct& fInnPtr; + + static const AliHLTComponentDataType inputDataTypes[]; + static const AliHLTComponentDataType outputDataType; + + int fEquippmentID; +}; + +#endif