--- /dev/null
+/**************************************************************************
+ * 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 <iostream>
+#include "stdio.h"
+#include <cstdlib>
+#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 <ALTRO_MAX_SAMPLES; i++)
+ {
+ fTmpChannelData[i] = 0;
+ }
+}
+
+void
+AliHLTPHOSRcuHistogramProducer::WriteEnergyHistograms()
+{
+ char tmpFileName[256];
+ sprintf(tmpFileName,"/home/aliphoshlt/rundir/outdata/calibHisto_%d_%d_%d.root", (int)fModuleID, (int)fRcuX, (int)fRcuZ);
+ TFile *histoFile = new TFile(tmpFileName,"update");
+ char hname[128];
+ if(!histoFile) return;
+ if(!histoFile->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();
+
+}
--- /dev/null
+#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
--- /dev/null
+/**************************************************************************
+ * 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 <iostream>
+#include "stdio.h"
+#include <cstdlib>
+#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<AliHLTComponentDataType>& 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<AliHLTComponentBlockData>& 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<argc && iResult>=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 <<endl;
+ cout <<"Module ID =\t"<< (int) tmpModuleID<<endl;
+ cout <<"RCUX =\t\t" << (int)tmpRcuX << endl;
+ cout <<"RCUZ =\t\t" << (int)tmpRcuZ << endl;
+ }
+
+ if(isSetEquippmentID == kFALSE)
+ {
+ 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;
+ }
+
+
+ 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;
+}
+
+
--- /dev/null
+#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<AliHLTComponentBlockData, std::allocator<AliHLTComponentBlockData> >&);
+ virtual void GetInputDataTypes(std::vector<AliHLTComponentDataType, std::allocator<AliHLTComponentDataType> >&);
+ 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
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff