* provided "as is" without express or implied warranty. *
**************************************************************************/
-
-/// @class AliHLTPHOSRawAnalyzerComponent
-/// Base class of PHOS HLT online raw analysis component.
-/// The class provides a common interface for the implementation of PHOS
-/// HLT raw data
-/// processors components. The class is intended for processing of
-/// arrays of raw data samples to evaluate energy and timing.
-/// The Energy will be given in entities of ADC leves ranging from 0 to
-/// 1023. Timing will be given in entities of samples periods.
-/// Drived clases must implement the fucntions
-/// - @ref GetComponentID
-/// - @ref Spawn
-
-
-
#include "AliHLTPHOSRawAnalyzer.h"
#include "AliHLTPHOSRawAnalyzerComponent.h"
-#include "AliRawReaderMemory.h"
-#include "AliCaloRawStream.h"
-#include <iostream>
#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
#include "AliHLTPHOSRcuChannelDataStruct.h"
-
-using namespace std;
-
-
-const AliHLTComponentDataType AliHLTPHOSRawAnalyzerComponent::fgkInputDataTypes[]={kAliHLTVoidDataType,{0,"",""}}; //'zero' terminated array
-int AliHLTPHOSRawAnalyzerComponent::fgEventCount = 0;
-
-
-
-//_________________________________________________________________________________________________
-AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTProcessor(), fAnalyzerPtr(0),
-fkEquippmentID(0), fModuleID(0), fRcuX(0), fRcuZ(0),fRcuZOffset(0), fRcuXOffset(0),fPrintInfo(kFALSE),fSendChannelData(kFALSE),fPrintInfoFrequncy(1000),
-fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
+#include "AliHLTDDLDecoder.h"
+#include "AliHLTAltroData.h"
+#include "AliHLTPHOSMapper.h"
+#include "AliHLTAltroBunch.h"
+#include "AliHLTPHOSSanityInspector.h"
+#include "AliHLTPHOSBaseline.h"
+#include "TFile.h"
+#include "TTree.h"
+#include "TClonesArray.h"
+//using namespace std;
+
+AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTPHOSRcuProcessor(), fAnalyzerPtr(0),
+ fSendChannelData(kFALSE),fOutPtr(0), fMapperPtr(0), fDecoderPtr(0),
+ fAltroDataPtr(0), fAltroBunchPtr(0), fUseBaselineSubtraction(false), fDebugCnt(0)
{
-
+ fMapperPtr = new AliHLTPHOSMapper();
+
}
-//_________________________________________________________________________________________________
+
AliHLTPHOSRawAnalyzerComponent::~AliHLTPHOSRawAnalyzerComponent()
{
- /**
- *Default destructor
- */
- if(fRawMemoryReader != 0)
- {
- delete fRawMemoryReader;
- }
- if(fPHOSRawStream != 0)
- {
- delete fPHOSRawStream;
- }
+ delete fMapperPtr;
}
-//_________________________________________________________________________________________________
-AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent(const AliHLTPHOSRawAnalyzerComponent & ) : AliHLTProcessor(), fAnalyzerPtr(0),
-fkEquippmentID(0), fModuleID(0), fRcuX(0), fRcuZ(0),fRcuZOffset(0), fRcuXOffset(0),fPrintInfo(kFALSE),fSendChannelData(kFALSE),fPrintInfoFrequncy(1000),
-fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
-{
- /**
- *Copy Constructor
- */
-}
-//_________________________________________________________________________________________________
int
AliHLTPHOSRawAnalyzerComponent::Deinit()
{
- //See base class for documentation
- cout << "Deinit" << endl;
+ Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerComponen Deinit");
return 0;
}
-//_________________________________________________________________________________________________
-int
-AliHLTPHOSRawAnalyzerComponent::DoDeinit()
-{
- //See base class or for documentation
- cout << "DoDeinit" << endl;
- Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerComponen DoDeinit");
- if(fRawMemoryReader !=0)
- {
- delete fRawMemoryReader;
- }
-
- if(fPHOSRawStream != 0)
- {
- delete fPHOSRawStream;
- }
- return 0;
-
-}
-
-//_________________________________________________________________________________________________
const char*
AliHLTPHOSRawAnalyzerComponent::GetComponentID()
{
- //Returns the component ID
return "AliPhosTestRaw";
}
-//_________________________________________________________________________________________________
void
AliHLTPHOSRawAnalyzerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
- //See Base class for documentation
const AliHLTComponentDataType* pType=fgkInputDataTypes;
while (pType->fID!=0) {
list.push_back(*pType);
}
}
-//_________________________________________________________________________________________________
+
AliHLTComponentDataType
AliHLTPHOSRawAnalyzerComponent::GetOutputDataType()
{
- //See Base class for documentation
return AliHLTPHOSDefinitions::fgkCellEnergyDataType;
}
-//_________________________________________________________________________________________________
void
AliHLTPHOSRawAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
{
- //See Base class for documentation
constBase = 30;
- inputMultiplier = 1;
+ inputMultiplier = 1.2;
}
-//_________________________________________________________________________________________________
+
+//int
+//AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventD // AliHLTPHOSRcuCellEnergyDebugDataStruct* fOutPtr;ata& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData,
+// AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
int
-AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
+AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData,
+ AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
{
- //See base class for documentation
- 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;
UInt_t mysize = 0;
UInt_t tSize = 0;
- Int_t tmpChannelCnt = 0;
- Int_t tmpStartIndex = 0;
+ Float_t baseline = 0;
AliHLTUInt8_t* outBPtr;
- unsigned long first;
- unsigned long last;
+ AliHLTAltroBunch *bunchPtr;
outBPtr = outputPtr;
const AliHLTComponentBlockData* iter = NULL;
unsigned long ndx;
+
+ // printf("\n% \n", ndx);
+
+ // cout << "evtData block count = " << evtData.fBlockCnt << endl;
+
+
+ fDebugCnt++;
+
for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
{
+ // cout <<"TP0"<< endl;
+
+ Int_t tmpChannelCnt = 0;
iter = blocks+ndx;
mysize = 0;
offset = tSize;
+ // cout <<"TP1"<< endl;
+ Int_t *dt = (Int_t*)(reinterpret_cast<UChar_t*>( iter->fPtr ));
+ // cout <<"TP2"<< endl;
+ Int_t crazyness = 0;
if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType )
{
- continue;
+ // cout <<"WARNING: not AliHLTPHOSDefinitions::fgkDDLPackedRawDataType " << endl;
+ // cout << "equippment "<< fkEquippmentID << " Event count =" << fDebugCnt <<" AliHLTPHOSRawAnalyzerComponent::DoEvent , ERROR"<< endl;
+ continue;
+
+ // if(fPhosEventCount < 10)
+ // {
+ // continue; //!!!!! Commented out to read TPC data, remember to put back
+ // }
+ }
+ else
+ {
+ // cout << "equippment " << fkEquippmentID << " Event count =" << fDebugCnt << " Dat type is: AliHLTPHOSDefinitions::fgkDDLPackedRawDataType" << endl;
+ }
+
+ if( fPhosEventCount%100 == 0)
+ {
+ cout << "event count = "<< fPhosEventCount <<endl;
+
+ }
+
+
+ /*
+ printf("\Common data header for equippment %d\n", fkEquippmentID);
+ printf("Event#: %d -- RCU X: %d - RCU Z: %d\n\n", fPhosEventCount, fRcuX, fRcuZ);
+
+ for(Int_t n = 0; n < 8; n++)
+ {
+ printf("CDH(%d): 0x%X\n", n, dt[n]);
}
- fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
- fAnalyzerPtr->SetData(fTmpChannelData);
+ printf("\n");
+ */
+
+
+ fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
+ // fDecoderPtr->SetMemory2(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
+ fDecoderPtr->Decode();
+
fOutPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
- mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
fOutPtr->fRcuX = fRcuX;
fOutPtr->fRcuZ = fRcuZ;
- fOutPtr->fModuleID = fModuleID;
- tmpChannelCnt = 0;
-
- while(fPHOSRawStream->Next())
+ fOutPtr->fModuleID =fModuleID;
+
+ while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
{
- if (fPHOSRawStream->IsNewHWAddress())
+
+ // if(fAltroDataPtr->fDataSize != 72)
+ // if(fAltroDataPtr->fDataSize != 142)
+ if(fAltroDataPtr->fDataSize != (fNTotalSamples +2))
{
- if(processedChannels > 0)
- {
- fAnalyzerPtr->SetData(fTmpChannelData);
- fAnalyzerPtr->Evaluate(0, sampleCnt);
- fOutPtr->fValidData[tmpChannelCnt].fGain = tmpGain;
- fOutPtr->fValidData[tmpChannelCnt].fZ = tmpZ;
- fOutPtr->fValidData[tmpChannelCnt].fX = tmpX;
- fOutPtr->fValidData[tmpChannelCnt].fEnergy = (float)fAnalyzerPtr->GetEnergy();
- fOutPtr->fValidData[tmpChannelCnt].fTime = (float)fAnalyzerPtr->GetTiming();
- ResetDataPtr(tmpStartIndex, sampleCnt);
- tmpChannelCnt ++;
- sampleCnt = 0;
- }
-
- tmpMod = (AliHLTUInt8_t)fPHOSRawStream->GetModule() ;
- tmpX =(AliHLTUInt8_t)fPHOSRawStream->GetRow() - fRcuXOffset;
- tmpZ =(AliHLTUInt8_t)fPHOSRawStream->GetColumn() - fRcuZOffset;
- tmpGain = fPHOSRawStream->IsLowGain();
- processedChannels ++;
+ cout << "Error, fDataSize = " << fAltroDataPtr->fDataSize << endl;
+ continue;
}
-
- if(sampleCnt == 0)
+
+ crazyness = fSanityInspectorPtr->CheckInsanity(fAltroDataPtr->fData, fAltroDataPtr->fDataSize - 2);
+ fAnalyzerPtr->SetData(fAltroDataPtr->fData); // AliHLTPHOSRcuCellEnergyDebugDataStruct* fOutPtr;
+ fAnalyzerPtr->Evaluate(0, fAltroDataPtr->fDataSize -2);
+
+ fOutPtr->fValidData[tmpChannelCnt].fZ = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].zRow;
+ fOutPtr->fValidData[tmpChannelCnt].fX = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].xCol;
+ fOutPtr->fValidData[tmpChannelCnt].fGain = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].gain;
+ if(fUseBaselineSubtraction)
+ {
+ baseline = fBaselines[fOutPtr->fValidData[tmpChannelCnt].fX][fOutPtr->fValidData[tmpChannelCnt].fZ][ fOutPtr->fValidData[tmpChannelCnt].fGain];
+ }
+ fOutPtr->fValidData[tmpChannelCnt].fEnergy = (float)fAnalyzerPtr->GetEnergy() - baseline;
+ fOutPtr->fValidData[tmpChannelCnt].fTime = (float)fAnalyzerPtr->GetTiming();
+ fOutPtr->fValidData[tmpChannelCnt].fCrazyness = (int)crazyness;
+ for(Int_t sample = 0; sample < fNTotalSamples; sample++)
{
- tmpStartIndex = fPHOSRawStream->GetTime();
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ (fOutPtr->fValidData[tmpChannelCnt].fData)[sample] = fAltroDataPtr->fData[sample] - (int)baseline;
}
- fTmpChannelData[fPHOSRawStream->GetTime()] = fPHOSRawStream->GetSignal();
- sampleCnt ++;
+ tmpChannelCnt ++;
+
}
-
- tmpChannelCnt ++;
- fAnalyzerPtr->SetData(fTmpChannelData);
- fAnalyzerPtr->Evaluate(0, sampleCnt);
- fOutPtr->fValidData[tmpChannelCnt].fGain = tmpGain;
- fOutPtr->fValidData[tmpChannelCnt].fZ = tmpZ;
- fOutPtr->fValidData[tmpChannelCnt].fX = tmpX;
- fOutPtr->fValidData[tmpChannelCnt].fEnergy = fAnalyzerPtr->GetEnergy();
- fOutPtr->fValidData[tmpChannelCnt].fTime = fAnalyzerPtr->GetTiming();
- ResetDataPtr(tmpStartIndex, sampleCnt);
-
- sampleCnt = 0;
-
fOutPtr->fCnt = tmpChannelCnt;
+ mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
+
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;
+ cout <<"kHLTLogFatal, HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent Too much dataData 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;
}
-
+
+ // fDecoderPtr->GetFailureRate();
+
}
- fgEventCount++;
+
+ fPhosEventCount++;
+
+ // cout << "event cunt =" << fPhosEventCount << endl;
if(fPrintInfo == kTRUE)
{
- if(fgEventCount%fPrintInfoFrequncy == 0)
+ if(fPhosEventCount%fPrintInfoFrequncy == 0)
{
- cout <<"Analyzing event " << fgEventCount << "for Equippment " << fkEquippmentID << endl;
+ cout <<"Analyzing event " << fPhosEventCount << "for Equippment " << fkEquippmentID << endl;
}
}
- size = tSize;
+
return 0;
}//end DoEvent
-//_________________________________________________________________________________________________
int
AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
{
- // See headerfile for documentation
+ cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
+ fAltroDataPtr = new AliHLTAltroData();
+ fAltroBunchPtr = new AliHLTAltroBunch();
+ fDecoderPtr = new AliHLTDDLDecoder();
+ fSanityInspectorPtr = new AliHLTPHOSSanityInspector();
fSendChannelData = kFALSE;
fPrintInfo = kFALSE;
Reset();
- fRawMemoryReader = new AliRawReaderMemory();
- fPHOSRawStream = new AliCaloRawStream(fRawMemoryReader,"PHOS");
- fPHOSRawStream->SetOldRCUFormat(kFALSE);
int iResult=0;
TString argument="";
- Bool_t isSetEquippmentID = kFALSE;
+ iResult = ScanArguments(argc, argv);
- for(int i=0; i<argc && iResult>=0; i++)
+ for(int i = 0; i < argc; i++)
{
- argument=argv[i];
-
- if (argument.IsNull())
- {
- continue;
- }
-
- if (argument.CompareTo("-equipmentID") == 0)
+ if(!strcmp("-baselinefile", argv[i]))
{
- cout << "AliHLTPHOSRawAnalyzerComponent:DoInit argument = -equipmentID " <<endl;
- if(i+1 <= argc)
- {
- SetEquippmentID((AliHLTUInt16_t)atoi(argv[i+1]));
- cout << "AliHLTPHOSRawAnalyzerComponent:DoInit setting equippment ID to " << fkEquippmentID <<endl;
- fRawMemoryReader->SetEquipmentID(fkEquippmentID);
- SetCoordinates(fkEquippmentID);
- 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;
- }
+ cout << "Getting baselines from " << argv[i+1] << endl;
+ SetBaselines(argv[i+1]);
}
-
-
- if (argument.CompareTo("-datatype") == 0)
- {
- if(i+1 <= argc)
- {
- argument=argv[i+1];
- if(argument.CompareTo("channeldata") == 0)
- {
- cout << "AliHLTPHOSRawAnalyzerComponent::DoIni setting sendChannelData = kTRUE "<< endl;
- fSendChannelData = kTRUE;
- }
- }
- }
-
- if (argument.CompareTo("-printinfo") == 0)
- {
- if(i+1 <= argc)
- {
- argument=argv[i+1];
- fPrintInfoFrequncy = atoi(argv[i+1]);
- fPrintInfo = kTRUE;
- cout << "AliHLTPHOSRawAnalyzerComponent::DoIni setting printinfo = kTRUE, with update frequency every "<< fPrintInfoFrequncy << "th event" <<endl;
- }
- else
- {
- cout << "WARNING: asking for event info, but no update frequency is specified, otipn is ignored" << endl;
- }
- }
-
}
+
-
- if(isSetEquippmentID == kFALSE)
+ if(fIsSetEquippmentID == kFALSE)
{
+ 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;
}
-
- return 0;
-}
-
-//_________________________________________________________________________________________________
-void
-AliHLTPHOSRawAnalyzerComponent::DumpData(int gain) const
-{
- //Dumping data to std out
- for(int mod = 0; mod < N_MODULES; mod ++)
+ else
{
- printf("\n *********** MODULE %d ************\n", mod);
- for(int row = 0; row < N_ROWS_MOD; row ++)
- {
- for(int col = 0; col < N_COLUMNS_MOD; col ++)
- {
- if( fMaxValues[mod][row][col][0] != 0)
- {
- cout << fMaxValues[mod][row][col][gain] << "\t";
- }
- }
- }
+ iResult = 0;
+ // fRawMemoryReader->SetEquipmentID(fkEquippmentID);
}
+
+ // return iResult;
+ // return 0;
+ return iResult;
}
-//_________________________________________________________________________________________________
-void
-AliHLTPHOSRawAnalyzerComponent::DumpChannelData(Double_t *data) const
-{
- //shutting up the code checker
- cout << endl;
- for(int i=0; i< ALTRO_MAX_SAMPLES; i++)
- {
- if (data[i] != 0)
- {
- cout <<i <<"\t";
- }
- }
- cout << endl;
-
- for(int i=0; i< ALTRO_MAX_SAMPLES; i++)
- {
- if (data[i] != 0)
- {
- cout <<data[i] <<"\t";
- }
- }
-
- cout << endl;
-}
-
-//_________________________________________________________________________________________________
void
AliHLTPHOSRawAnalyzerComponent::Reset()
{
- //shutting code checker
for(int mod = 0; mod < N_MODULES; mod ++)
{
- for(int row = 0; row < N_ROWS_MOD; row ++)
+ for(int row = 0; row < N_ZROWS_MOD; row ++)
{
- for(int col = 0; col < N_COLUMNS_MOD; col ++)
+ for(int col = 0; col < N_XCOLUMNS_MOD; col ++)
{
for(int gain = 0; gain < N_GAINS; gain ++ )
{
}
}
}
-
+
ResetDataPtr(0, ALTRO_MAX_SAMPLES);
} // end Reset
-//_________________________________________________________________________________________________
+
void
AliHLTPHOSRawAnalyzerComponent::ResetDataPtr(int startindex, int sampleCnt)
{
- //shutting up the code checker
for(int i = startindex ; i< sampleCnt; i++)
{
fTmpChannelData[i] = 0;
}
}
-//_________________________________________________________________________________________________
void
-AliHLTPHOSRawAnalyzerComponent::SetEquippmentID(AliHLTUInt16_t id)
+AliHLTPHOSRawAnalyzerComponent::SetBaselines(const char* file)
{
- ///Changing the value of the constant fkEquippmentID
- ///by virue of const_cast as it should only be set once
- ///and then remain constant. It caannot be set in the class constructor
- ///because it should be set in the DoInit fucntion.
- AliHLTUInt16_t &ref = const_cast<AliHLTUInt16_t&>(fkEquippmentID);
- ref = id;
-}
-
-
-//_________________________________________________________________________________________________
-const AliHLTUInt16_t
-AliHLTPHOSRawAnalyzerComponent::GetEquippmentID() const
-{
- //shutting up the code checker
- return fkEquippmentID;
-}
-
-//_________________________________________________________________________________________________
-void
-AliHLTPHOSRawAnalyzerComponent::SetCoordinates(AliHLTUInt16_t equippmentID)
-{
- //shutting up the code checker
- int rcuIndex = (fkEquippmentID - 1792)%N_RCUS_PER_MODULE;
- fModuleID = (fkEquippmentID -1792 -rcuIndex)/N_RCUS_PER_MODULE;
-
- if(rcuIndex == 0)
- {
- fRcuX = 0;
- fRcuZ = 0;
- }
-
- if(rcuIndex == 1)
- {
- fRcuX = 0;
- fRcuZ = 1;
- }
-
- if(rcuIndex == 2)
+ fUseBaselineSubtraction = true;
+ AliHLTPHOSBaseline *baseline = 0;
+ TFile *baselineFile = TFile::Open(file);
+ TTree *baselineTree = (TTree*)baselineFile->Get("baselineTree");
+ TClonesArray *baselineArray = new TClonesArray("AliHLTPHOSBaseline", 7168);
+ baselineTree->SetBranchAddress("Baselines", &baselineArray);
+ baselineTree->GetEntry(0);
+ for(Int_t i = 0; i < baselineArray->GetEntriesFast(); i++)
{
- fRcuX = 1;
- fRcuZ = 0;
- }
-
- if(rcuIndex == 3)
- {
- fRcuX = 1;
- fRcuZ = 1;
+ baseline = (AliHLTPHOSBaseline*)baselineArray->At(i);
+ if((baseline->GetX() < ((fRcuX + 1)*N_XCOLUMNS_RCU)) && (baseline->GetX() >= fRcuX*N_XCOLUMNS_RCU))
+ {
+ if((baseline->GetZ() < ((fRcuZ + 1)*N_ZROWS_RCU)) && (baseline->GetZ() >= fRcuZ*N_ZROWS_RCU))
+ {
+ fBaselines[baseline->GetX() - fRcuX*N_XCOLUMNS_RCU][baseline->GetZ() - fRcuZ*N_ZROWS_RCU][baseline->GetGain()] = baseline->GetBaseline();
+ // cout << fBaselines[baseline->GetX() - fRcuX*N_XCOLUMNS_RCU][baseline->GetZ() - fRcuZ*N_ZROWS_RCU][baseline->GetGain()] << endl;
+ }
+ }
}
-
- fRcuZOffset = N_ZROWS_RCU*fRcuZ;
- fRcuXOffset = N_XCOLUMNS_RCU*fRcuX;
-
- cout <<"********InitInfo************"<< endl;
- cout <<"AliHLTPHOSRawAnalyzerComponent::SetCoordinate casted"<< endl;
- cout <<"Equpippment ID =\t"<< fkEquippmentID <<endl;
- cout <<"Module ID =\t"<< (int)fModuleID<<endl;
- cout <<"RCUX =\t\t" << (int)fRcuX << endl;
- cout <<"RCUZ =\t\t" << (int)fRcuZ << endl;
- cout <<"RcuZOffset = \t" << (int)fRcuZOffset << endl;
- cout <<"RcuXOffset = \t" << (int)fRcuXOffset << endl << endl;
+ baselineFile->Close();
+ delete baselineFile;
+ baselineFile = 0;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff