#include "AliHLTPHOSDigitContainerDataStruct.h"
#include "TClonesArray.h"
#include "AliPHOSDigit.h"
-#ifndef HAVE_NOT_PHOSRECOPARAMEMC // set from configure if EMC functionality not available in AliPHOSRecoParam
+#ifndef HAVENOT__PHOSRECOPARAMEMC // set from configure if EMC functionality not available in AliPHOSRecoParam
#include "AliPHOSRecoParam.h"
#else
#include "AliPHOSRecoParamEmc.h"
fEmcTimeGate(0),
fDigitsInCluster(0),
fDigitContainerPtr(0),
- fMaxDigitIndexDiff(2*N_ZROWS_MOD)
+ fMaxDigitIndexDiff(2*NZROWSMOD)
{
//See header file for documentation
fEmcClusteringThreshold = 0.2;
fEmcTimeGate(0),
fDigitsInCluster(0),
fDigitContainerPtr(0),
- fMaxDigitIndexDiff(2*N_ZROWS_MOD)
+ fMaxDigitIndexDiff(2*NZROWSMOD)
{
//Copy constructor not implemented
}
//#include "PhosConst.h"
-#define PHOS_CRYSTALS (PHOS_MODS*PHOS_ROWS*PHOS_COLS) // Total number of PHOS crystals
+#define PHOSCRYSTALS (PHOS_MODS*PHOS_ROWS*PHOS_COLS) // Total number of PHOS crystals
//#define unsigned long int PHOS_CHANNELS (PHOS_GAINS*PHOS_CRYSTALS) // Total number of PHOS channels
//#define unsigned long int MP_MAP_FILE_NAME "phosmp.map" // Shared memory map file name
//#define unsigned long int MP_MAP_FILE_SIZE (PHOS_CHANNELS*1024*8) // Shared memory map file size
//#define unsigned long int MP_RESULT_DIR "mp_result" // Directory to store result to
-#define PHOS_CHANNELS (PHOS_GAINS*PHOS_CRYSTALS) // Total number of PHOS channels
+#define PHOSCHANNELS (PHOS_GAINS*PHOS_CRYSTALS) // Total number of PHOS channels
#define MP_MAP_FILE_NAME "phosmp.map" // Shared memory map file name
#define MP_MAP_FILE_SIZE (PHOS_CHANNELS*1024*8) // Shared memory map file size
#define MP_RESULT_DIR "mp_result" // Directory to store result to
namespace PhosHLTConst
{
- const int MAX_HOSTS = 20;
- const int DEFAULT_EVENT_PORT = 42001;
- const int MAX_BIN_VALUE = 1023;
- const int HIGH_GAIN = 1;
- const int LOW_GAIN = 0;
-
- const int ALTRO_MAX_SAMPLES = 1008; /**<The maximum number of samples of the ALTRO*/
- const int ALTRO_MAX_PRESAMPLES = 15;
- // const int ALTRO_MAX_TRALER_SIZE = 7;
- // const int DDL_BLOCK_SIZE = 5;
-
- const int N_ZROWS_RCU = 28; /**<Number of rows per module*/
- const int N_XCOLUMNS_RCU = 32;
- const int N_ZROWS_MOD = 56; /**<Number of rows per module*/
- const int N_XCOLUMNS_MOD = 64; /**<Number of columns per module*/
- const int N_GAINS = 2; /**<Number of gains per ALTRO channel*/
- const int N_DATATYPES = 10;
-
- const int PF_MAX_PATH_LENGTH = 256;
+ const int MAXHOSTS = 20;
+ const int DEFAULTEVENTPORT = 42001;
+ const int MAXBINVALUE = 1023;
+ const int HIGHGAIN = 1;
+ const int LOWGAIN = 0;
+
+ const int ALTROMAXSAMPLES = 1008; /**<The maximum number of samples of the ALTRO*/
+ const int ALTROMAXPRESAMPLES = 15;
+ // const int ALTROMAXTRALERSIZE = 7;
+ // const int DDLBLOCKSIZE = 5;
+
+ const int NZROWSRCU = 28; /**<Number of rows per module*/
+ const int NXCOLUMNSRCU = 32;
+ const int NZROWSMOD = 56; /**<Number of rows per module*/
+ const int NXCOLUMNSMOD = 64; /**<Number of columns per module*/
+ const int NGAINS = 2; /**<Number of gains per ALTRO channel*/
+ const int NDATATYPES = 10;
+
+ const int PFMAXPATHLENGTH = 256;
#ifndef __CINT__
- const unsigned char PF_VECTOR_DIR[] = "/HLT/PHOS/PFVectors";
+ const unsigned char PFVECTORDIR[] = "/HLT/PHOS/PFVectors";
#endif
- const int PF_DEFAULT_N_SAMPLES = 70;
- const int PF_DEFAULT_STARTINDEX = 0;
+ const int PFDEFAULTNSAMPLES = 70;
+ const int PFDEFAULTSTARTINDEX = 0;
- const int DEFAULT
_TAU = 2; /**<Assume that the signal rise time of the altrp pulses is 2 us (nominal value of the electronics)*/
- const int DEFAULT
_FS = 10; /**<Assume that the signal is samples with 10 MHZ samle rate*/
+ const int DEFAULTTAU = 2; /**<Assume that the signal rise time of the altrp pulses is 2 us (nominal value of the electronics)*/
+ const int DEFAULTFS = 10; /**<Assume that the signal is samples with 10 MHZ samle rate*/
- const int MODULE_0 = 0;
- const int MODULE_1 = 1;
- const int MODULE_2 = 2;
- const int MODULE_3 = 3;
- const int MODULE_4 = 4;
+ const int MODULE0 = 0;
+ const int MODULE1 = 1;
+ const int MODULE2 = 2;
+ const int MODULE3 = 3;
+ const int MODULE4 = 4;
- const int CSPS_PER_FEE = 32;
- const int RCU_0 = 0;
- const int RCU_1 = 1;
- const int RCU_2 = 2;
- const int RCU_3 = 3;
+ const int CSPSPERFEE = 32;
+ const int RCU0 = 0;
+ const int RCU1 = 1;
+ const int RCU2 = 2;
+ const int RCU3 = 3;
- const int Z_0 = 0;
- const int Z_1 = 1;
- const int X_0 = 0;
- const int X_1 = 1;
+ const int Z0 = 0;
+ const int Z1 = 1;
+ const int X0 = 0;
+ const int X1 = 1;
- const int N_MODULES = 5; /**<Number of modules of the PHOS detector*/
- const int N_RCUS = 4; /**<Number of RCUs per Module*/
+ const int NMODULES = 5; /**<Number of modules of the PHOS detector*/
+ const int NRCUS = 4; /**<Number of RCUs per Module*/
- // N_RCUS_PER_MODULE
- const int N_RCUS_PER_MODULE = 4 ; /**<Number of RCUs per Module*/
- const int N_RCUS_PER_TOTAL = N_MODULES*N_RCUS_PER_MODULE; /**<Total number of RCUs for PHOS*/
- const int N_FEECS = 14; /**<Number of Frontend cards per branch*/
- const int N_ALTROS = 4; /**<Number of ALTROs per frontend card*/
- const int N_ALTROCHANNELS = 16;
- const int N_BRANCHES = 2;
+ // NRCUSPERMODULE
+ const int NRCUSPERMODULE = 4 ; /**<Number of RCUs per Module*/
+ const int NRCUSPERTOTAL = NMODULES*NRCUSPERMODULE; /**<Total number of RCUs for PHOS*/
+ const int NFEECS = 14; /**<Number of Frontend cards per branch*/
+ const int NALTROS = 4; /**<Number of ALTROs per frontend card*/
+ const int NALTROCHANNELS = 16;
+ const int NBRANCHES = 2;
}
UInt_t fPHOSModule; //COMMENT
/** Array of digits in container */
- AliHLTPHOSDigitDataStruct fDigitDataStruct[N_XCOLUMNS_RCU*N_ZROWS_RCU*N_GAINS]; //COMMENT
+ AliHLTPHOSDigitDataStruct fDigitDataStruct[NXCOLUMNSRCU*NZROWSRCU*NGAINS]; //COMMENT
};
fShmPtr = new AliHLTPHOSSharedMemoryInterfacev2();
- for(int x = 0; x < N_XCOLUMNS_MOD; x++)
+ for(int x = 0; x < NXCOLUMNSMOD; x++)
{
- for(int z = 0; z < N_ZROWS_MOD; z++)
+ for(int z = 0; z < NZROWSMOD; z++)
{
fHighGainFactors[x][z] = 0.005;
fLowGainFactors[x][z] = 0.08;
- fBadChannelMask[x][z][HIGH_GAIN] = 1;
- fBadChannelMask[x][z][LOW_GAIN] = 1;
+ fBadChannelMask[x][z][HIGHGAIN] = 1;
+ fBadChannelMask[x][z][LOWGAIN] = 1;
}
}
fMapperPtr = new AliHLTPHOSMapper();
{
tmpchannel = currentchannel;
- if(coord1[2] == HIGH_GAIN) // We got a completely new crystal
+ if(coord1[2] == HIGHGAIN) // We got a completely new crystal
{
- if(currentchannel->fEnergy < MAX_BIN_VALUE) // Make sure we don't have signal overflow
+ if(currentchannel->fEnergy < MAXBINVALUE) // Make sure we don't have signal overflow
{
AddDigit(currentchannel, coord1);
}
else //Reversed ordered (low gain before high gain)
{
- if(coord1[2] == LOW_GAIN) // We got a new channel!
+ if(coord1[2] == LOWGAIN) // We got a new channel!
{
currentchannelLG = currentchannel; // Ok, let's back up the low gain channel and look for the fancy high gain one
currentchannel = fShmPtr->NextChannel();
if(coord1[0] == coord2[0] && coord1[1] == coord2[1]) // Aha! Found the high gain channel
{
- if(currentchannel->fEnergy < MAX_BIN_VALUE) // To overflow or not to overflow?
+ if(currentchannel->fEnergy < MAXBINVALUE) // To overflow or not to overflow?
{
AddDigit(currentchannel, coord2);
AliHLTPHOSDigitMaker::SetGlobalHighGainFactor(Float_t factor)
{
//See header file for documentation
- for(int x = 0; x < N_XCOLUMNS_MOD; x++)
+ for(int x = 0; x < NXCOLUMNSMOD; x++)
{
- for(int z = 0; z < N_ZROWS_MOD; z++)
+ for(int z = 0; z < NZROWSMOD; z++)
{
fHighGainFactors[x][z] = factor;
}
AliHLTPHOSDigitMaker::SetGlobalLowGainFactor(Float_t factor)
{
//See header file for documentation
- for(int x = 0; x < N_XCOLUMNS_MOD; x++)
+ for(int x = 0; x < NXCOLUMNSMOD; x++)
{
- for(int z = 0; z < N_ZROWS_MOD; z++)
+ for(int z = 0; z < NZROWSMOD; z++)
{
fLowGainFactors[x][z] = factor;
}
void
AliHLTPHOSDigitMaker::SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut)
{
- for(int x = 0; x < N_XCOLUMNS_MOD; x++)
+ for(int x = 0; x < NXCOLUMNSMOD; x++)
{
- for(int z = 0; z < N_ZROWS_MOD; z++)
+ for(int z = 0; z < NZROWSMOD; z++)
{
if(badChannelHGHist->GetBinContent(x, z) < qCut && badChannelHGHist->GetBinContent(x, z) > 0)
{
- fBadChannelMask[x][z][HIGH_GAIN] = 1;
+ fBadChannelMask[x][z][HIGHGAIN] = 1;
}
else
{
- fBadChannelMask[x][z][HIGH_GAIN] = 0;
+ fBadChannelMask[x][z][HIGHGAIN] = 0;
}
if(badChannelLGHist->GetBinContent(x, z) < qCut && badChannelLGHist->GetBinContent(x, z) > 0)
{
- fBadChannelMask[x][z][LOW_GAIN] = 0;
+ fBadChannelMask[x][z][LOWGAIN] = 0;
}
else
{
- fBadChannelMask[x][z][LOW_GAIN] = 0;
+ fBadChannelMask[x][z][LOWGAIN] = 0;
}
}
}
{
fDigitStructPtr->fX = coordinates[0];
fDigitStructPtr->fZ = coordinates[1];
- if(coordinates[2] == HIGH_GAIN)
+ if(coordinates[2] == HIGHGAIN)
fDigitStructPtr->fAmplitude = channelData->fEnergy*fHighGainFactors[coordinates[0]][coordinates[1]];
else
fDigitStructPtr->fAmplitude = channelData->fEnergy*fLowGainFactors[coordinates[0]][coordinates[1]];
AliHLTPHOSMapper* fMapperPtr; //COMMENT
/** High gain energy conversion factors */
- Float_t fHighGainFactors[N_XCOLUMNS_MOD][N_ZROWS_MOD]; //COMMENT
+ Float_t fHighGainFactors[NXCOLUMNSMOD][NZROWSMOD]; //COMMENT
/** Low gain energy conversion factors */
- Float_t fLowGainFactors[N_XCOLUMNS_MOD][N_ZROWS_MOD]; //COMMENT
+ Float_t fLowGainFactors[NXCOLUMNSMOD][NZROWSMOD]; //COMMENT
/** Bad channel mask */
- Float_t fBadChannelMask[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS]; //COMMENT
+ Float_t fBadChannelMask[NXCOLUMNSMOD][NZROWSMOD][NGAINS]; //COMMENT
ClassDef(AliHLTPHOSDigitMaker, 1);
// for(Int_t gain = 0; gain < N_GAINS; gain ++){
- for(Int_t module=0; module<N_MODULES; module++) {
- for(Int_t column=0; column< N_XCOLUMNS_MOD; column++) {
- for(Int_t row=0; row<N_ZROWS_MOD; row++) {
- for(Int_t gain = 0; gain < N_GAINS; gain ++){
+ for(Int_t module=0; module<NMODULES; module++) {
+ for(Int_t column=0; column< NXCOLUMNSMOD; column++) {
+ for(Int_t row=0; row<NZROWSMOD; row++) {
+ for(Int_t gain = 0; gain < NGAINS; gain ++){
fADCchannelEnergy[module][column][row][gain] = calibda.fADCchannelEnergy[module][column][row][gain];
fADCpedestalEmcMeasured[module][column][row][gain] = calibda.fADCpedestalEmcMeasured[module][column][row][gain];
}
SetName(calibda.GetName());
SetTitle(calibda.GetName());
// for(Int_t gain = 0; gain < N_GAINS; gain ++){
- for(Int_t module=0; module<N_MODULES; module++) {
- for(Int_t column=0; column< N_XCOLUMNS_MOD; column++) {
- for(Int_t row=0; row<N_ZROWS_MOD; row++) {
- for(Int_t gain = 0; gain < N_GAINS; gain ++){
+ for(Int_t module=0; module<NMODULES; module++) {
+ for(Int_t column=0; column< NXCOLUMNSMOD; column++) {
+ for(Int_t row=0; row<NZROWSMOD; row++) {
+ for(Int_t gain = 0; gain < NGAINS; gain ++){
fADCchannelEnergy[module][column][row][gain] = calibda.fADCchannelEnergy[module][column][row][gain];
fADCpedestalEmcMeasured[module][column][row][gain] = calibda.fADCpedestalEmcMeasured[module][column][row][gain];
}
// Set all pedestals and all ADC channels to its ideal values = 1.
// for(Int_t gain = 0; gain < PHOS_GAINS; gain ++){
- for (Int_t module=0; module<N_MODULES; module++){
- for (Int_t column=0; column< N_XCOLUMNS_MOD; column++){
- for (Int_t row=0; row<N_ZROWS_MOD; row++){
- for(Int_t gain = 0; gain < N_GAINS; gain ++){
+ for (Int_t module=0; module<NMODULES; module++){
+ for (Int_t column=0; column< NXCOLUMNSMOD; column++){
+ for (Int_t row=0; row<NZROWSMOD; row++){
+ for(Int_t gain = 0; gain < NGAINS; gain ++){
fADCpedestalEmcMeasured[module][column][row][gain] = 0.;
fADCchannelEnergy[module][column][row][gain] = 1.;
}
if (strstr(option,"ped")) {
printf("\n ---- EMC Pedestal values ----\n\n");
// for(Int_t gain = 0; gain < N_GAINS; gain ++){
- for (Int_t module=0; module<N_MODULES; module++){
+ for (Int_t module=0; module<NMODULES; module++){
printf("============== Module %d\n",module+1);
- for (Int_t column=0; column< N_XCOLUMNS_MOD; column++){
- for (Int_t row=0; row<N_ZROWS_MOD; row++){
- for(Int_t gain = 0; gain < N_GAINS; gain ++){
+ for (Int_t column=0; column< NXCOLUMNSMOD; column++){
+ for (Int_t row=0; row<NZROWSMOD; row++){
+ for(Int_t gain = 0; gain < NGAINS; gain ++){
printf("%4.1f",fADCpedestalEmcMeasured[module][column][row][gain]);
}
printf("\n");
if (strstr(option,"gain")) {
printf("\n ---- EMC ADC channel values ----\n\n");
- // for(Int_t gain = 0; gain < N_GAINS; gain ++){
- for (Int_t module=0; module<N_MODULES; module++){
+ // for(Int_t gain = 0; gain < NGAINS; gain ++){
+ for (Int_t module=0; module<NMODULES; module++){
printf("============== Module %d\n",module+1);
- for (Int_t column=0; column< N_XCOLUMNS_MOD; column++){
- for (Int_t row=0; row<N_ZROWS_MOD; row++){
- for(Int_t gain = 0; gain < N_GAINS; gain ++){
+ for (Int_t column=0; column< NXCOLUMNSMOD; column++){
+ for (Int_t row=0; row<NZROWSMOD; row++){
+ for(Int_t gain = 0; gain < NGAINS; gain ++){
printf("%4.1f",fADCchannelEnergy[module][column][row][gain]);
}
printf("\n");
void
AliHLTPHOSEmcCalibData::MakeADCpedestalCorrectionTable()
{
- for (Int_t module=0; module<N_MODULES; module++){
+ for (Int_t module=0; module<NMODULES; module++){
printf("============== Module %d\n",module+1);
- for (Int_t column=0; column< N_XCOLUMNS_MOD; column++){
- for (Int_t row=0; row<N_ZROWS_MOD; row++){
- for(Int_t gain = 0; gain < N_GAINS; gain ++){
+ for (Int_t column=0; column< NXCOLUMNSMOD; column++){
+ for (Int_t row=0; row<NZROWSMOD; row++){
+ for(Int_t gain = 0; gain < NGAINS; gain ++){
fADCpedestalCorrectionTable[module][column][row][gain] = fADCpedestalEmcMeasured[module][column][row][gain] - fADCpedestalAltroReg[module][column][row][gain];
// printf("%4.1f",fADCchannelEnergy[module][column][row][gain]);
//
void SetADCpedestalEmcMeasured(Int_t module, Int_t column, Int_t row, Int_t gain, Float_t value);
void MakeADCpedestalCorrectionTable();
protected:
- Float_t fADCchannelEnergy[N_MODULES][N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS] ; /**<width of one EMC ADC channel in GeV*/
- Float_t fADCpedestalEmcMeasured[N_MODULES][N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS] ; /**<value of the EMC ADC pedestal measured from calibration run*/
- Int_t fADCpedestalAltroReg[N_MODULES][N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS] ; /**<value of the EMC ADC pedestal subtraction values stored in the ALTRO registers*/
- Float_t fADCpedestalCorrectionTable[N_MODULES][N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS] ; /**<value of the EMC ADC pedestal values to be subtracted form the decoed cahnnel data (= fADCpedestalEmcMeasured - fADCpedestalAltroReg)*/
+ Float_t fADCchannelEnergy[NMODULES][NXCOLUMNSMOD][NZROWSMOD][NGAINS] ; /**<width of one EMC ADC channel in GeV*/
+ Float_t fADCpedestalEmcMeasured[NMODULES][NXCOLUMNSMOD][NZROWSMOD][NGAINS] ; /**<value of the EMC ADC pedestal measured from calibration run*/
+ Int_t fADCpedestalAltroReg[NMODULES][NXCOLUMNSMOD][NZROWSMOD][NGAINS] ; /**<value of the EMC ADC pedestal subtraction values stored in the ALTRO registers*/
+ Float_t fADCpedestalCorrectionTable[NMODULES][NXCOLUMNSMOD][NZROWSMOD][NGAINS] ; /**<value of the EMC ADC pedestal values to be subtracted form the decoed cahnnel data (= fADCpedestalEmcMeasured - fADCpedestalAltroReg)*/
ClassDef(AliHLTPHOSEmcCalibData,1) // PHOS EMC calibration data
};
cout << "FourierAna::CheckSignal min = "<< tmpMin << " max = " << tmpMax << endl;
}
- if( (tmpMax >= MAX_BIN_VALUE) || tmpMin < 1 )
+ if( (tmpMax >= MAXBINVALUE) || tmpMin < 1 )
{
cout << "ERROR, FourierAna::CheckSignal failed, signal out of range, min= "<< tmpMin << "max = " << tmpMax << endl;
return false;
fFFTInputArray = new double[fFixedDataSize];
fFFTOutputArray = new double[fFixedDataSize];
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
fFFTOupuStruct.fDataLength = fFixedDataSize;
fFFTOutputArray[k] = 0;
}
- for(int i=0; i < ALTRO_MAX_SAMPLES ; i++)
+ for(int i=0; i < ALTROMAXSAMPLES ; i++)
{
fFFTOupuStruct.fGlobalAccumulatedPSD[gain][i] = 0;
fFFTOupuStruct.fGlobalLastPSD[gain][i] = 0;
void
AliHLTPHOSMapper::InitDDLSpecificationMapping()
{
- fSpecificationMapPtr = new fDDLSpecificationMap[PhosHLTConst::N_MODULES*PhosHLTConst::N_RCUS_PER_MODULE];
- for(Int_t ddl = 0; ddl < PhosHLTConst::N_MODULES*PhosHLTConst::N_RCUS_PER_MODULE; ddl++)
+ fSpecificationMapPtr = new fDDLSpecificationMap[PhosHLTConst::NMODULES*PhosHLTConst::NRCUSPERMODULE];
+ for(Int_t ddl = 0; ddl < PhosHLTConst::NMODULES*PhosHLTConst::NRCUSPERMODULE; ddl++)
{
- fSpecificationMapPtr[ddl].fModId = ddl/PhosHLTConst::N_RCUS_PER_MODULE;
+ fSpecificationMapPtr[ddl].fModId = ddl/PhosHLTConst::NRCUSPERMODULE;
if(ddl%4 == 0)
{
fSpecificationMapPtr[ddl].fRcuZ = 1;
}
- fSpecificationMapPtr[ddl].fRcuZOffset = N_ZROWS_RCU*(fSpecificationMapPtr[ddl].fRcuZ);
- fSpecificationMapPtr[ddl].fRcuXOffset = N_XCOLUMNS_RCU*(fSpecificationMapPtr[ddl].fRcuX);
+ fSpecificationMapPtr[ddl].fRcuZOffset = NZROWSRCU*(fSpecificationMapPtr[ddl].fRcuZ);
+ fSpecificationMapPtr[ddl].fRcuXOffset = NXCOLUMNSRCU*(fSpecificationMapPtr[ddl].fRcuX);
}
}
Int_t zOffset = 0;
Int_t module = -1;
- Float_t energyArray[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS];
- Float_t timeArray[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS];
+ Float_t energyArray[NXCOLUMNSMOD][NZROWSMOD][NGAINS];
+ Float_t timeArray[NXCOLUMNSMOD][NZROWSMOD][NGAINS];
while(iter != 0)
{
fPHOSDAPtr = new AliPHOSRcuDA1(module,0);
}
- xOffset = cellDataPtr->fRcuX*N_XCOLUMNS_RCU;
- zOffset = cellDataPtr->fRcuZ*N_ZROWS_RCU;
+ xOffset = cellDataPtr->fRcuX*NXCOLUMNSRCU;
+ zOffset = cellDataPtr->fRcuZ*NZROWSRCU;
fShmPtr->SetMemory(cellDataPtr);
currentChannel = fShmPtr->NextChannel();
energyArray[tmpX+xOffset][tmpZ+zOffset][tmpGain] = currentChannel->fEnergy;
timeArray[tmpX+xOffset][tmpZ+zOffset][tmpGain] = currentChannel->fTime;
}
-// for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+// for(Int_t x = 0; x < NXCOLUMNSRCU; x++)
// {
-// for(Int_t z = 0; z < N_ZROWS_RCU; z++)
+// for(Int_t z = 0; z < NZROWSRCU; z++)
// {
-// for(Int_t gain = 0; gain < N_GAINS; gain++)
+// for(Int_t gain = 0; gain < NGAINS; gain++)
// {
// energyArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fEnergy;
// timeArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fTime;
cout << "AliHLTPHOSModuleCalibrationProcessorComponent::ShipDataToFXS TP0.3" << endl;
cout << "AliHLTPHOSModuleCalibrationProcessorComponent::ShipDataToFXS TP1" << endl;
- for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+ for(Int_t x = 0; x < NXCOLUMNSRCU; x++)
{
- for(Int_t z = 0; z < N_ZROWS_RCU; z++)
+ for(Int_t z = 0; z < NZROWSRCU; z++)
{
cout << "AliHLTPHOSModuleCalibrationProcessorComponent::ShipDataToFXS TP2" << endl;
PushToFXS( (TObject*) fPHOSDAPtr->GetHgLgRatioHistogram(x, z), "PHOS", filename);
- for(Int_t gain = 0; gain < N_GAINS; gain++)
+ for(Int_t gain = 0; gain < NGAINS; gain++)
{
cout << "AliHLTPHOSModuleCalibrationProcessorComponent::ShipDataToFXS TP3" << endl;
PushToFXS( (TObject*) fPHOSDAPtr->GetTimeEnergyHistogram(x, z, gain), "PHOS", filename);
}
void
-AliHLTPHOSModuleCalibrationProcessorComponent::ResetArrays(Float_t e[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS], Float_t t[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS])
+AliHLTPHOSModuleCalibrationProcessorComponent::ResetArrays(Float_t e[NXCOLUMNSMOD][NZROWSMOD][NGAINS], Float_t t[NXCOLUMNSMOD][NZROWSMOD][NGAINS])
{
- for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+ for(Int_t x = 0; x < NXCOLUMNSRCU; x++)
{
- for(Int_t z = 0; z < N_ZROWS_RCU; z++)
+ for(Int_t z = 0; z < NZROWSRCU; z++)
{
- for(Int_t gain = 0; gain < N_GAINS; gain++)
+ for(Int_t gain = 0; gain < NGAINS; gain++)
{
e[x][z][gain] = 0;
t[x][z][gain] = 0;
Int_t ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
/** Reset the energy and timing arrays */
- void ResetArrays(Float_t e[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS], Float_t t[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS]);
+ void ResetArrays(Float_t e[NXCOLUMNSMOD][NZROWSMOD][NGAINS], Float_t t[NXCOLUMNSMOD][NZROWSMOD][NGAINS]);
int fCnt; ///TODO, remove this
private:
{
bool iRet = true;
- if( nSamples > ALTRO_MAX_SAMPLES)
+ if( nSamples > ALTROMAXSAMPLES)
{
cout << "Warning: attemp to set pattern array of length " << nSamples << " wich is out of range" <<endl;
- cout <<"Max length of pattern array is " << ALTRO_MAX_SAMPLES <<endl;
+ cout <<"Max length of pattern array is " << ALTROMAXSAMPLES <<endl;
iRet = false;
}
- else if(nPresamples > ALTRO_MAX_PRESAMPLES)
+ else if(nPresamples > ALTROMAXPRESAMPLES)
{
cout << "ERROR: attemp to set teh number of " << nPresamples << " wich is out of range" <<endl;
- cout <<"Max length of pattern array is " << ALTRO_MAX_PRESAMPLES <<endl;
+ cout <<"Max length of pattern array is " << ALTROMAXPRESAMPLES <<endl;
iRet = false;
}
void
AliHLTPHOSPattern::SetPattern(const int *pattern, const int length)
{
- for(int i=0; i< ALTRO_MAX_SAMPLES; i++)
+ for(int i=0; i< ALTROMAXSAMPLES; i++)
{
fVal[i] = 0;
}
fVal[i] = pattern[i];
}
- if(length > ALTRO_MAX_SAMPLES)
+ if(length > ALTROMAXSAMPLES)
{
- fPatternLength = ALTRO_MAX_SAMPLES;
+ fPatternLength = ALTROMAXSAMPLES;
}
else
{
// const int GetPattern(int *pattern, const int maxlengths = ALTRO_MAX_SAMPLES) const;
// const int GetPatternLength() const {return fPatternLength;};
// const int ValidatePattern(const int *readbackpattern, const int nsamples = ALTRO_MAX_SAMPLES, const int nPresamples = 0) const;
- int AddPattern(const int *readbackpattern, const int nsamples = ALTRO_MAX_SAMPLES, const int nPresamples = 0);
- bool CheckDoExistPattern(const int *readbackpattern, const int nsamples = ALTRO_MAX_SAMPLES, const int nPresamples = 0);
+ int AddPattern(const int *readbackpattern, const int nsamples = ALTROMAXSAMPLES, const int nPresamples = 0);
+ bool CheckDoExistPattern(const int *readbackpattern, const int nsamples = ALTROMAXSAMPLES, const int nPresamples = 0);
AliHLTPHOSPattern *GetNextPtr() const {return fPattern;};
- int GetPattern(int *pattern, const int maxlengths = ALTRO_MAX_SAMPLES) const;
+ int GetPattern(int *pattern, const int maxlengths = ALTROMAXSAMPLES) const;
int GetPatternLength() const {return fPatternLength;};
- int ValidatePattern(const int *readbackpattern, const int nsamples = ALTRO_MAX_SAMPLES, const int nPresamples = 0) const;
- void PrintPattern(const int nPerLine = ALTRO_MAX_SAMPLES);
+ int ValidatePattern(const int *readbackpattern, const int nsamples = ALTROMAXSAMPLES, const int nPresamples = 0) const;
+ void PrintPattern(const int nPerLine = ALTROMAXSAMPLES);
private:
int DoComparePattern(const int *inputPattern1, const int *inputPattern2, const int nsamples) const;
bool CheckPatternLength(const int nsamples, const int nPresamples) const;
void SetPattern(const int *pattern, const int length);
- int fVal[ALTRO_MAX_SAMPLES];
+ int fVal[ALTROMAXSAMPLES];
int fPatternLength;
int fN; /**<The number of detected patterns equal to fPattern*/
int fCnt;
// fPHOSRadius = geom->GetIPtoCrystalSurface();
fPHOSRadius = geom->GetIPtoCrystalSurface();
- for(int i = 0; i < N_MODULES; i++)
+ for(int i = 0; i < NMODULES; i++)
{
// fRotParametersCos[i] = cos((geom->GetPHOSAngle(i+1))*2*TMath::Pi()/360);
// fRotParametersSin[i] = sin((geom->GetPHOSAngle(i+1))*2*TMath::Pi()/360);
Int_t module = recPointPtr->fModule;
- tempPosX = kCRYSTAL_SIZE*(recPointPtr->fX-N_XCOLUMNS_MOD/2) + kCRYSTAL_SIZE/2;
+ tempPosX = kCRYSTALSIZE*(recPointPtr->fX-NXCOLUMNSMOD/2) + kCRYSTALSIZE/2;
positionPtr[0] = tempPosX*fRotParametersSin[module] + fPHOSRadius*fRotParametersCos[module];
positionPtr[1] = tempPosX*fRotParametersCos[module] - fPHOSRadius*fRotParametersSin[module];
- positionPtr[2] = kCRYSTAL_SIZE*(recPointPtr->fZ-N_ZROWS_MOD/2) + kCRYSTAL_SIZE/2;
+ positionPtr[2] = kCRYSTALSIZE*(recPointPtr->fZ-NZROWSMOD/2) + kCRYSTALSIZE/2;
}
{
//Get global position from local postion and module number
//See header file for documentation
- positionPtr[0] = kCRYSTAL_SIZE*(locPositionPtr[0]-N_XCOLUMNS_MOD/2)*fRotParametersCos[module] + fPHOSRadius*fRotParametersSin[module];
+ positionPtr[0] = kCRYSTALSIZE*(locPositionPtr[0]-NXCOLUMNSMOD/2)*fRotParametersCos[module] + fPHOSRadius*fRotParametersSin[module];
- positionPtr[1] = kCRYSTAL_SIZE*(locPositionPtr[0]-N_XCOLUMNS_MOD/2)*fRotParametersSin[module] - fPHOSRadius*fRotParametersCos[module];
+ positionPtr[1] = kCRYSTALSIZE*(locPositionPtr[0]-NXCOLUMNSMOD/2)*fRotParametersSin[module] - fPHOSRadius*fRotParametersCos[module];
- positionPtr[2] = kCRYSTAL_SIZE*(locPositionPtr[1]-N_ZROWS_MOD);
+ positionPtr[2] = kCRYSTALSIZE*(locPositionPtr[1]-NZROWSMOD);
}
class AliHLTPHOSRecPointDataStruct;
class AliHLTPHOSRecPointContainerStruct;
-const Float_t kCRYSTAL_SIZE = 2.25;
+const Float_t kCRYSTALSIZE = 2.25;
/**
* @class AliHLTPHOSPhysicsAnalyzer
fAltroBunchPtr = new AliAltroBunch();
fDecoderPtr = new AliAltroDecoder();
fSanityInspectorPtr = new AliHLTPHOSSanityInspector();
- fSelectedChannelsList = new AliHLTUInt16_t[N_XCOLUMNS_RCU*N_ZROWS_RCU*N_GAINS];
+ fSelectedChannelsList = new AliHLTUInt16_t[NXCOLUMNSRCU*NZROWSRCU*NGAINS];
}
void
AliHLTPHOSRawAnalyzerComponent::FillDataArray(UInt_t *data, const AliAltroData */*altrodataptr*/, const int /*channel*/)
{
- ResetDataPtr(0, ALTRO_MAX_SAMPLES);
+ ResetDataPtr(0, ALTROMAXSAMPLES);
bool islastbunch = true;
while( fAltroDataPtr->NextBunch(fAltroBunchPtr) == true)
void
AliHLTPHOSRawAnalyzerComponent::Reset(AliHLTPHOSRcuCellEnergyDataStruct* /*cellDataPtr*/)
{
- ResetDataPtr(0, ALTRO_MAX_SAMPLES);
+ ResetDataPtr(0, ALTROMAXSAMPLES);
} // end Reset
TH2F *lgHist = (TH2F*)histFile->Get("RMSLGMapHist");
TH2F *hgHist = (TH2F*)histFile->Get("RMSHGMapHist");
- for(int x = 0; x < N_XCOLUMNS_MOD; x++)
+ for(int x = 0; x < NXCOLUMNSMOD; x++)
{
- for(int z = 0; z < N_ZROWS_MOD; z++)
+ for(int z = 0; z < NZROWSMOD; z++)
{
- fSelectiveReadOutThresholds[x][z][LOW_GAIN] = lgHist->GetBinContent(x, z) * nSigmas;
- fSelectiveReadOutThresholds[x][z][HIGH_GAIN] = hgHist->GetBinContent(x, z) * nSigmas;
+ fSelectiveReadOutThresholds[x][z][LOWGAIN] = lgHist->GetBinContent(x, z) * nSigmas;
+ fSelectiveReadOutThresholds[x][z][HIGHGAIN] = hgHist->GetBinContent(x, z) * nSigmas;
}
}
}
Bool_t fSendChannelData; /**<wether or not to send raw data from the component into shared memory*/
- // Double_t fTmpChannelData[ALTRO_MAX_SAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
- UInt_t fTmpChannelData[ALTRO_MAX_SAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
+ // Double_t fTmpChannelData[ALTROMAXSAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
+ UInt_t fTmpChannelData[ALTROMAXSAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
- Double_t fMaxValues[N
_MODULES][N_ZROWS_MOD][N_XCOLUMNS_MOD][N_GAINS]; /**<array to store cell energies*/
+ Double_t fMaxValues[N
MODULES][NZROWSMOD][NXCOLUMNSMOD][NGAINS]; /**<array to store cell energies*/
AliHLTPHOSRcuCellEnergyDataStruct* fOutPtr; //comment
AliHLTPHOSMapper *fMapperPtr; //Mapping from harware address to geometrical address
AliHLTPHOSSanityInspector *fSanityInspectorPtr; //comment
Bool_t fUseBaselineSubtraction; //comment
- Float_t fBaselines[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; //comment
+ Float_t fBaselines[NXCOLUMNSRCU][NZROWSRCU][NGAINS]; //comment
AliAltroDecoder *fDecoderPtr; // decoder for altro payload
AliAltroData *fAltroDataPtr; // container for altro payload
Bool_t fDoSelectiveReadOut; //Added by OD
/** Threshold for selective readout ( zero suppression threshold) */
- Float_t fSelectiveReadOutThresholds[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS]; //Added by OD
+ Float_t fSelectiveReadOutThresholds[NXCOLUMNSMOD][NZROWSMOD][NGAINS]; //Added by OD
/** The selected HW addresses */
AliHLTUInt16_t *fSelectedChannelsList; //! transient Added by OD
Bool_t
AliHLTPHOSRawAnalyzerPeakFinderComponent::LoadPFVector()
{
- return LoadPFVector(PF_DEFAULT_STARTINDEX, PF_DEFAULT_N_SAMPLES, DEFAULT_TAU, DEFAULT_FS );
+ return LoadPFVector(PFDEFAULTSTARTINDEX, PFDEFAULTNSAMPLES, DEFAULTTAU, DEFAULTFS );
}
Bool_t
AliHLTPHOSRawAnalyzerPeakFinderComponent::LoadPFVector(int startIndex, int nSamples, int tau, int fs)
{
- char tmpPFPath[PF_MAX_PATH_LENGTH];
+ char tmpPFPath[PFMAXPATHLENGTH];
Double_t * tmpAVector = new Double_t[nSamples];
Double_t * tmpTVector = new Double_t[nSamples];
- sprintf(tmpPFPath,"%s%s/start%dN%dtau%dfs%d.txt", getenv("ALICE_ROOT"), PF_VECTOR_DIR, startIndex, nSamples, tau, fs);
+ sprintf(tmpPFPath,"%s%s/start%dN%dtau%dfs%d.txt", getenv("ALICE_ROOT"), PFVECTORDIR, startIndex, nSamples, tau, fs);
FILE *fp;
fp = fopen(tmpPFPath, "r");
{
fReferenceAltroPattern = new AliHLTPHOSPattern(pattern, length);
- for(int z=0; z < N_ZROWS_RCU; z++)
+ for(int z=0; z < NZROWSRCU; z++)
{
- for(int x=0; x < N_XCOLUMNS_RCU; x++)
+ for(int x=0; x < NXCOLUMNSRCU; x++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
fNEqual[z][x][gain] = 0;
fNNotEqual[z][x][gain] = 0;
}
-// const int GetPattern(int *pattern, const int maxlengths = ALTRO_MAX_SAMPLES) const;
+// const int GetPattern(int *pattern, const int maxlengths = ALTROMAXSAMPLES) const;
// const int GetPatternLength() const {return fPatternLength;};
/* Counts the total number of differen patterns dtetected across all channels
* @return the number of different patterns detected across all channels
*/
-// const int GetPattern(int *pattern, const int maxlengths = ALTRO_MAX_SAMPLES) const;
+// const int GetPattern(int *pattern, const int maxlengths = ALTROMAXSAMPLES) const;
// const int GetPatternLength() const {return fPatternLength;};
int
AliHLTPHOSRcuAltroPatternTest::countAllPatterns(const int length, const bool /*doprintpattern*/)
{
fCnt ++;
- int tmpPatternArray[ALTRO_MAX_SAMPLES];
+ int tmpPatternArray[ALTROMAXSAMPLES];
int tmplength = fReferenceAltroPattern->GetPattern(tmpPatternArray, length);
AliHLTPHOSPattern *tmpPattern = new AliHLTPHOSPattern(tmpPatternArray, tmplength);
- for(int z=0; z < N_ZROWS_RCU; z++)
+ for(int z=0; z < NZROWSRCU; z++)
{
- for(int x=0; x < N_XCOLUMNS_RCU; x++)
+ for(int x=0; x < NXCOLUMNSRCU; x++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
if(fPerChannelPatterns[z][x][gain] != 0)
{
void
AliHLTPHOSRcuAltroPatternTest::PrintStatistics() const
{
- for(int z=0; z < N_ZROWS_RCU; z++)
+ for(int z=0; z < NZROWSRCU; z++)
{
- for(int x=0; x < N_XCOLUMNS_RCU; x++)
+ for(int x=0; x < NXCOLUMNSRCU; x++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
int tmp = countPatterns(fPerChannelPatterns[z][x][gain]);
if(tmp > 2)
// const int AddPattern(const int *inputPattern, const int z, const int x, const int gain, const int length = ALTRO_MAX_SAMPLES, const int presamples = 0);
// const int countPatterns(const AliHLTPHOSPattern *pattern) const;
// const int countAllPatterns(const int length, const bool printpatterns = true);
- int ValidateAltroPattern(const int *inputPattern, const int length = ALTRO_MAX_SAMPLES, const int presamples = 0) const;
- int AddPattern(const int *inputPattern, const int z, const int x, const int gain, const int length = ALTRO_MAX_SAMPLES, const int presamples = 0);
+ int ValidateAltroPattern(const int *inputPattern, const int length = ALTROMAXSAMPLES, const int presamples = 0) const;
+ int AddPattern(const int *inputPattern, const int z, const int x, const int gain, const int length = ALTROMAXSAMPLES, const int presamples = 0);
int countPatterns(const AliHLTPHOSPattern *pattern) const;
int countAllPatterns(const int length, const bool printpatterns = true);
void PrintStatistics() const;
// void PrintPattern() const;
// bool Compare(const AliHLTPHOSPattern);
- unsigned long fNEqual[N_ZROWS_RCU][N_XCOLUMNS_RCU][N_GAINS];
- unsigned long fNNotEqual[N_ZROWS_RCU][N_XCOLUMNS_RCU][N_GAINS];
+ unsigned long fNEqual[NZROWSRCU][NXCOLUMNSRCU][NGAINS];
+ unsigned long fNNotEqual[NZROWSRCU][NXCOLUMNSRCU][NGAINS];
const AliHLTUInt8_t fModuleID; /**<ID of the module this component read data from (0-4)*/
const AliHLTUInt8_t fRcuX; /**<X position of RCU the data from this Equippment comes from (0 or 1)*/
const AliHLTUInt8_t fRcuZ; /**<Z position of RCU the data from this Equippment comes from (0 or 1)*/
AliHLTPHOSPattern *fReferenceAltroPattern; /**<The pattern stored in the altro*/
- AliHLTPHOSPattern *fPerChannelPatterns[N
_ZROWS_RCU][N_XCOLUMNS_RCU][N_GAINS]; /**<Pattern actually read back from the electronics*/
+ AliHLTPHOSPattern *fPerChannelPatterns[N
ZROWSRCU][NXCOLUMNSRCU][NGAINS]; /**<Pattern actually read back from the electronics*/
unsigned long fCnt; //REMOVE !!
tmpRawPtr = fShmPtr->GetRawData(tmpSamples);
- if( (tmpZ > N_ZROWS_RCU) || (tmpX > N_XCOLUMNS_RCU) || (tmpGain > N_GAINS))
+ if( (tmpZ > NZROWSRCU) || (tmpX > NXCOLUMNSRCU) || (tmpGain > NGAINS))
{
cout <<" ERROR parameters out of range z = "<< tmpZ <<" x = "<< tmpX<< " gain = " << tmpGain<<" nSamples = " << tmpSamples <<endl;
}
}
else
{
- int tmpPattern[ALTRO_MAX_SAMPLES];
- ScanPatternFromFile(patternFilename, tmpPattern, ALTRO_MAX_SAMPLES) ;
- fPatternTestPtr = new AliHLTPHOSRcuAltroPatternTest(fModuleID, fRcuX, fRcuZ, tmpPattern, ALTRO_MAX_SAMPLES);
+ int tmpPattern[ALTROMAXSAMPLES];
+ ScanPatternFromFile(patternFilename, tmpPattern, ALTROMAXSAMPLES) ;
+ fPatternTestPtr = new AliHLTPHOSRcuAltroPatternTest(fModuleID, fRcuX, fRcuZ, tmpPattern, ALTROMAXSAMPLES);
}
// return iResult;
// int tmpPattern[ALTRO_MAX_SAMPLES];
int dummy = 0;
int res = 0;
- for(int i=0; i<ALTRO_MAX_SAMPLES; i++)
+ for(int i=0; i<ALTROMAXSAMPLES; i++)
{
res = fscanf(fp,"w 0x%X 0x%X\n", &dummy, &pattern[i]);
// cout << tmpPattern[i] << endl;
AliHLTPHOSRcuAltroPatternTestComponent(const AliHLTPHOSRcuAltroPatternTestComponent &);
AliHLTPHOSRcuAltroPatternTestComponent & operator = (const AliHLTPHOSRcuAltroPatternTestComponent &);
AliHLTPHOSRcuAltroPatternTest *fPatternTestPtr;
- void ScanPatternFromFile(const char *filename, int *pattern, const int lengt = ALTRO_MAX_SAMPLES) const;
+ void ScanPatternFromFile(const char *filename, int *pattern, const int lengt = ALTROMAXSAMPLES) const;
AliHLTPHOSSharedMemoryInterface *fShmPtr; // Interface to read altro channel data from shared memory
unsigned long fNTotalPatterns; /**<The total number of patterns analyzed*/
unsigned long fNWrongPatterns; /**<The total number of incorrect patterns found*/
int geomx;
int geomz;
- for(int gain=0; gain< N_GAINS; gain++)
+ for(int gain=0; gain< NGAINS; gain++)
{
sprintf(tmpHistoName, "DeadChanneMap_Module%d_rcuz%d_rcux%d_gain%d",(int)fModuleID, fRcuZ, fRcuX, gain);
fDeadChannelMapHistogramPtrs[gain] = new TH2D(tmpHistoName, tmpHistoName,
- N_XCOLUMNS_RCU , 0, N_XCOLUMNS_RCU ,
- N_ZROWS_RCU, 0, N_ZROWS_RCU);
+ NXCOLUMNSRCU , 0, NXCOLUMNSRCU ,
+ NZROWSRCU, 0, NZROWSRCU);
fDeadChannelMapHistogramPtrs[gain]->Reset();
}
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
- geomx = x + N_XCOLUMNS_RCU*fRcuX;
- geomz = z + N_ZROWS_RCU*fRcuZ;
+ geomx = x + NXCOLUMNSRCU*fRcuX;
+ geomz = z + NZROWSRCU*fRcuZ;
fEnergyAverageValues[x][z][gain] = 0;
fAccumulatedValues[x][z][gain] = 0;
fHits[x][z][gain] = 0;
fDeadChannelMap[x][z][gain] = 0;
sprintf(tmpHistoName, "Edistribution_%d_%d_%d_%d",(int)fModuleID, geomx, geomz, gain);
- fEnergyHistogramPtrs[x][z][gain] = new TH1F( tmpHistoName, tmpHistoName, N_BINS, XBIN_LOW, XBIN_UP);
+ fEnergyHistogramPtrs[x][z][gain] = new TH1F( tmpHistoName, tmpHistoName, NBINS, XBINLOW, XBINUP);
sprintf(tmpHistoName, "TOFdistribution_module%d_x%d_z%d_gain%d", (int)fModuleID, geomx, geomz, gain);
- fTimingHistogramPtrs[x][z][gain] = new TH1F(tmpHistoName , tmpHistoName, N_BINS, XBIN_LOW, XBIN_UP);
+ fTimingHistogramPtrs[x][z][gain] = new TH1F(tmpHistoName , tmpHistoName, NBINS, XBINLOW, XBINUP);
fCellAccEnergy.fAccumulatedEnergies[x][z][gain] = 0;
fCellAccEnergy.fHits[x][z][gain] = 0;
fCellAccEnergy.fDeadChannelMap[x][z][gain] = 0;
AliHLTPHOSRcuCalibrationProcessor::FillLiveChannelHistograms()
{
//comment
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
fDeadChannelMapHistogramPtrs[gain]->SetBinContent(x ,z , fCellAccEnergy.fDeadChannelMap[x][z][gain]);
}
AliHLTPHOSRcuCalibrationProcessor::Reset()
{
//See header file for documentation
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
fEnergyAverageValues[x][z][gain] = 0;
fAccumulatedValues[x][z][gain] = 0;
}
}
- for(int i = 0; i <ALTRO_MAX_SAMPLES; i++)
+ for(int i = 0; i <ALTROMAXSAMPLES; i++)
{
fTmpChannelData[i] = 0;
}
// cout <<"printing histograms"<< endl;
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
fEnergyHistogramPtrs[x][z][gain]->Write();
}
class AliHLTPHOSRcuCellAccumulatedEnergyDataStruct;
//class AliHLTPHOSUtilities;
-#define XBIN_LOW 0
-#define XBIN_UP 1023
-#define N_BINS 1023
+#define XBINLOW 0
+#define XBINUP 1023
+#define NBINS 1023
class AliHLTPHOSRcuCalibrationProcessor : public AliHLTPHOSBase
//class AliHLTPHOSRcuCalibrationProcessor : public AliHLTPHOSRcuProcessor
void ScanTimeString(char *timeString);
char fHistoOutDir[512];
- TH1F *fEnergyHistogramPtrs[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Array to store energy distribution per channel for one rcu*/
- TH1F *fTimingHistogramPtrs[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Array to store timing distribution per channel for one rcu*/
- // TH1D *fDeadChannelMapHistogramPtrs[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- TH2D *fDeadChannelMapHistogramPtrs[N_GAINS];
+ TH1F *fEnergyHistogramPtrs[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Array to store energy distribution per channel for one rcu*/
+ TH1F *fTimingHistogramPtrs[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Array to store timing distribution per channel for one rcu*/
+ // TH1D *fDeadChannelMapHistogramPtrs[NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ TH2D *fDeadChannelMapHistogramPtrs[NGAINS];
- Float_t fEnergyAverageValues[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Accumulated energy divided by hits*/
- Double_t fAccumulatedValues[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Array to store accumulated energy per channel for one rcu during run*/
- Float_t fTimingAverageValues[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Avereage TOF*/
- AliHLTUInt32_t fHits[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; //comment
- AliHLTUInt32_t fDeadChannelMap[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; //comment
- Double_t fTmpChannelData[ALTRO_MAX_SAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
+ Float_t fEnergyAverageValues[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Accumulated energy divided by hits*/
+ Double_t fAccumulatedValues[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Array to store accumulated energy per channel for one rcu during run*/
+ Float_t fTimingAverageValues[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Avereage TOF*/
+ AliHLTUInt32_t fHits[NXCOLUMNSRCU][NZROWSRCU][NGAINS]; //comment
+ AliHLTUInt32_t fDeadChannelMap[NXCOLUMNSRCU][NZROWSRCU][NGAINS]; //comment
+ Double_t fTmpChannelData[ALTROMAXSAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
AliHLTPHOSRcuCellAccumulatedEnergyDataStruct fCellAccEnergy; //comment
AliHLTUInt8_t fModuleID; /**<ID of the module this component read data from (0-4)*/
AliHLTUInt8_t fRcuX; /**<X position of RCU the data from this Equippment comes from (0 or 1)*/
AliHLTUInt8_t fModuleID;
AliHLTUInt8_t fRcuX;
AliHLTUInt8_t fRcuZ;
- float fAccumulatedEnergies[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- AliHLTUInt32_t fHits[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- AliHLTUInt32_t fDeadChannelMap[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
+ float fAccumulatedEnergies[NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ AliHLTUInt32_t fHits[NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ AliHLTUInt32_t fDeadChannelMap[NXCOLUMNSRCU][NZROWSRCU][NGAINS];
};
Int_t fAlgorithm;
Int_t fInfo;
Bool_t fHasRawData;
- AliHLTPHOSValidCellDataStruct fValidData[N_XCOLUMNS_RCU*N_ZROWS_RCU*N_GAINS];
+ AliHLTPHOSValidCellDataStruct fValidData[NXCOLUMNSRCU*NZROWSRCU*NGAINS];
};
#endif
Int_t zOffset = 0;
Int_t module = -1;
- Float_t energyArray[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS];
- Float_t timeArray[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS];
+ Float_t energyArray[NXCOLUMNSMOD][NZROWSMOD][NGAINS];
+ Float_t timeArray[NXCOLUMNSMOD][NZROWSMOD][NGAINS];
ResetArrays(energyArray, timeArray);
while(iter != 0)
specification = specification|iter->fSpecification;
cellDataPtr = (AliHLTPHOSRcuCellEnergyDataStruct*)( iter->fPtr);
module = cellDataPtr->fModuleID;
- xOffset = cellDataPtr->fRcuX*N_XCOLUMNS_RCU;
- zOffset = cellDataPtr->fRcuZ*N_ZROWS_RCU;
+ xOffset = cellDataPtr->fRcuX*NXCOLUMNSRCU;
+ zOffset = cellDataPtr->fRcuZ*NZROWSRCU;
while(currentChannel != 0)
{
timeArray[tmpX+xOffset][tmpZ+zOffset][tmpGain] = currentChannel->fTime;
}
-// for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+// for(Int_t x = 0; x < NXCOLUMNSRCU; x++)
// {
-// for(Int_t z = 0; z < N_ZROWS_RCU; z++)
+// for(Int_t z = 0; z < NZROWSRCU; z++)
// {
-// for(Int_t gain = 0; gain < N_GAINS; gain++)
+// for(Int_t gain = 0; gain < NGAINS; gain++)
// {
// energyArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fEnergy;
// timeArray[x+xOffset][z+zOffset][gain] = cellDataPtr->fValidData[x][z][gain].fTime;
void
-AliHLTPHOSRcuDAComponent::ResetArrays(Float_t e[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS], Float_t t[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS])
+AliHLTPHOSRcuDAComponent::ResetArrays(Float_t e[NXCOLUMNSMOD][NZROWSMOD][NGAINS], Float_t t[NXCOLUMNSMOD][NZROWSMOD][NGAINS])
{
- for(Int_t x = 0; x < N_XCOLUMNS_RCU; x++)
+ for(Int_t x = 0; x < NXCOLUMNSRCU; x++)
{
- for(Int_t z = 0; z < N_ZROWS_RCU; z++)
+ for(Int_t z = 0; z < NZROWSRCU; z++)
{
- for(Int_t gain = 0; gain < N_GAINS; gain++)
+ for(Int_t gain = 0; gain < NGAINS; gain++)
{
e[x][z][gain] = 0;
t[x][z][gain] = 0;
Int_t ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
/** Reset the energy and timing arrays */
- void ResetArrays(Float_t e[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS], Float_t t[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS]);
+ void ResetArrays(Float_t e[NXCOLUMNSMOD][NZROWSMOD][NGAINS], Float_t t[NXCOLUMNSMOD][NZROWSMOD][NGAINS]);
// int fCnt; ///TODO, remove this
struct AliHLTPHOSRcuFFTDataStruct
{
int fDataLength;
- Double_t fGlobalAccumulatedPSD[N_GAINS][ALTRO_MAX_SAMPLES];
- Double_t fGlobalLastPSD[N_GAINS][ALTRO_MAX_SAMPLES];
- // Double_t fDummy[64][64][N_GAINS];
+ Double_t fGlobalAccumulatedPSD[NGAINS][ALTROMAXSAMPLES];
+ Double_t fGlobalLastPSD[NGAINS][ALTROMAXSAMPLES];
+ // Double_t fDummy[64][64][NGAINS];
};
int geomx;
int geomz;
- for(int gain=0; gain< N_GAINS; gain++)
+ for(int gain=0; gain< NGAINS; gain++)
{
sprintf(tmpHistoName, "DeadChanneMap_Module%d_rcuz%d_rcux%d_gain%d",(int)fModuleID, fRcuZ, fRcuX, gain);
- // fDeadChannelMapHistogramPtrs[gain] = new TH2D( tmpHistoName, tmpHistoName, N_BINS, XBIN_LOW, XBIN_UP);
+ // fDeadChannelMapHistogramPtrs[gain] = new TH2D( tmpHistoName, tmpHistoName, NBINS, XBINLOW, XBINUP);
fDeadChannelMapHistogramPtrs[gain] = new TH2D(tmpHistoName, tmpHistoName,
- N_XCOLUMNS_RCU , 0, N_XCOLUMNS_RCU ,
- N_ZROWS_RCU, 0, N_ZROWS_RCU);
+ NXCOLUMNSRCU , 0, NXCOLUMNSRCU ,
+ NZROWSRCU, 0, NZROWSRCU);
fDeadChannelMapHistogramPtrs[gain]->Reset();
// fgCalibHistPtr[gain]->GetXaxis()->SetRange(128, 128 + 64);
}
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
- geomx = x + N_XCOLUMNS_RCU*fRcuX;
- geomz = z + N_ZROWS_RCU*fRcuZ;
+ geomx = x + NXCOLUMNSRCU*fRcuX;
+ geomz = z + NZROWSRCU*fRcuZ;
fEnergyAverageValues[x][z][gain] = 0;
fAccumulatedValues[x][z][gain] = 0;
fTimingAverageValues[x][z][gain] = 0;
fDeadChannelMap[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);
+ fEnergyHistogramPtrs[x][z][gain] = new TH1F( tmpHistoName, tmpHistoName, NBINS, XBINLOW, XBINUP);
sprintf(tmpHistoName, "TOFdistribution_module%d_x%d_z%d_gain%d", (int)fModuleID, geomx, geomz, gain);
// fTimingHistogramPtrs[x][z][gain] = 0;
// fDeadChannelMapHistogramPtrs[x][z][gain] = new TH1D( tmpHistoName, tmpHistoName, N_BINS, XBIN_LOW, XBIN_UP);
- fTimingHistogramPtrs[x][z][gain] = new TH1F(tmpHistoName , tmpHistoName, N_BINS, XBIN_LOW, XBIN_UP);
+ fTimingHistogramPtrs[x][z][gain] = new TH1F(tmpHistoName , tmpHistoName, NBINS, XBINLOW, XBINUP);
fCellAccEnergy.fAccumulatedEnergies[x][z][gain] = 0;
fCellAccEnergy.fHits[x][z][gain] = 0;
fCellAccEnergy.fDeadChannelMap[x][z][gain] = 0;
AliHLTPHOSRcuHistogramProducer::FillLiveChannelHistograms()
{
//comment
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
fDeadChannelMapHistogramPtrs[gain]->SetBinContent(x ,z , fCellAccEnergy.fDeadChannelMap[x][z][gain]);
}
AliHLTPHOSRcuHistogramProducer::Reset()
{
//See header file for documentation
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
fEnergyAverageValues[x][z][gain] = 0;
fAccumulatedValues[x][z][gain] = 0;
}
}
- for(int i = 0; i <ALTRO_MAX_SAMPLES; i++)
+ for(int i = 0; i <ALTROMAXSAMPLES; i++)
{
fTmpChannelData[i] = 0;
}
// cout <<"printing histograms"<< endl;
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
// cout << "the number of entries is " <<fEnergyHistogramPtrs[x][z][gain]->GetEntries()<< endl;
fEnergyHistogramPtrs[x][z][gain]->Write();
class AliHLTPHOSRcuCellAccumulatedEnergyDataStruct;
class AliHLTPHOSUtilities;
-#define XBIN_LOW 0
-#define XBIN_UP 1023
-#define N_BINS 1023
+#define XBINLOW 0
+#define XBINUP 1023
+#define NBINS 1023
//class AliHLTPHOSRcuHistogramProducer : public AliHLTPHOSBase
//class AliHLTPHOSRcuHistogramProducer : public AliHLTPHOSRcuProcessor
void ScanTimeString(char *timeString);
AliHLTPHOSRcuHistogramProducer();
char fHistoOutDir[512];
- TH1F *fEnergyHistogramPtrs[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Array to store energy distribution per channel for one rcu*/
- TH1F *fTimingHistogramPtrs[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Array to store timing distribution per channel for one rcu*/
- // TH1D *fDeadChannelMapHistogramPtrs[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- TH2D *fDeadChannelMapHistogramPtrs[N_GAINS];
- Float_t fEnergyAverageValues[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Accumulated energy divided by hits*/
- Double_t fAccumulatedValues[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Array to store accumulated energy per channel for one rcu during run*/
+ TH1F *fEnergyHistogramPtrs[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Array to store energy distribution per channel for one rcu*/
+ TH1F *fTimingHistogramPtrs[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Array to store timing distribution per channel for one rcu*/
+ // TH1D *fDeadChannelMapHistogramPtrs[NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ TH2D *fDeadChannelMapHistogramPtrs[NGAINS];
+ Float_t fEnergyAverageValues[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Accumulated energy divided by hits*/
+ Double_t fAccumulatedValues[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Array to store accumulated energy per channel for one rcu during run*/
- Float_t fTimingAverageValues[N
_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; /**<Avereage TOF*/
- AliHLTUInt32_t fHits[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; //comment
- AliHLTUInt32_t fDeadChannelMap[N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS]; //comment
- Double_t fTmpChannelData[ALTRO_MAX_SAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
+ Float_t fTimingAverageValues[N
XCOLUMNSRCU][NZROWSRCU][NGAINS]; /**<Avereage TOF*/
+ AliHLTUInt32_t fHits[NXCOLUMNSRCU][NZROWSRCU][NGAINS]; //comment
+ AliHLTUInt32_t fDeadChannelMap[NXCOLUMNSRCU][NZROWSRCU][NGAINS]; //comment
+ Double_t fTmpChannelData[ALTROMAXSAMPLES]; /**<temporary variable to store raw samples from a single altro channel*/
AliHLTPHOSRcuCellAccumulatedEnergyDataStruct fCellAccEnergy; //comment
AliHLTUInt8_t fModuleID; /**<ID of the module this component read data from (0-4)*/
AliHLTUInt8_t fRcuX; /**<X position of RCU the data from this Equippment comes from (0 or 1)*/
fOutPtr->fRcuX = fRcuX;
fOutPtr->fRcuZ = fRcuZ;
- for(int x=0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x=0; x < NXCOLUMNSRCU; x ++)
{
- for(int z=0; z < N_ZROWS_RCU; z ++)
+ for(int z=0; z < NZROWSRCU; z ++)
{
- for(int gain =0; gain < N_GAINS; gain ++)
+ for(int gain =0; gain < NGAINS; gain ++)
{
fOutPtr->fAccumulatedEnergies[x][z][gain] = innPtr.fAccumulatedEnergies[x][z][gain];
fOutPtr->fHits[x][z][gain] = innPtr.fHits[x][z][gain];
void
AliHLTPHOSRcuProperties::InitializeCoordinates(AliHLTUInt16_t /*equippmentID*/)
{
- fRcuID = (fkEquippmentID - 1792)%N_RCUS_PER_MODULE;
- fModID = (fkEquippmentID -1792 - fRcuID)/N_RCUS_PER_MODULE;
+ fRcuID = (fkEquippmentID - 1792)%NRCUSPERMODULE;
+ fModID = (fkEquippmentID -1792 - fRcuID)/NRCUSPERMODULE;
if( fRcuID == 0)
{
fRcuZ = 1;
}
- fRcuZOffset = N_ZROWS_RCU*fRcuZ;
- fRcuXOffset = N_XCOLUMNS_RCU*fRcuX;
+ fRcuZOffset = NZROWSRCU*fRcuZ;
+ fRcuXOffset = NXCOLUMNSRCU*fRcuX;
fIsInitialized = true;
}
AliHLTPHOSOnlineDisplayCalibTab* AliHLTPHOSOnlineDisplay::fgCalibTabPtr = 0;
AliHLTPHOSOnlineDisplay* AliHLTPHOSOnlineDisplay::fgInstancePtr = 0; /**<The one an only instance of PhosOnlineDisplay*/
HOMERReader* AliHLTPHOSOnlineDisplay::fgHomerReaderPtr = 0; /**<Homer reader that fetches events from the HLT online stream*/
-HOMERReader* AliHLTPHOSOnlineDisplay::fgHomerReadersPtr[MAX_HOSTS]; /**<Homer reader that fetches events from the HLT online stream*/
+HOMERReader* AliHLTPHOSOnlineDisplay::fgHomerReadersPtr[MAXHOSTS]; /**<Homer reader that fetches events from the HLT online stream*/
Bool_t AliHLTPHOSOnlineDisplay::fgAccumulate = kFALSE ; /**<If set to kFALSE reset fgLegoplot between event, kTRUE adds current energies to previous plot*/
Bool_t AliHLTPHOSOnlineDisplay::fgSyncronize = kFALSE ;
unsigned int AliHLTPHOSOnlineDisplay::fgNHosts = 0;
unsigned int AliHLTPHOSOnlineDisplay::fgNPorts = 0;
-char* AliHLTPHOSOnlineDisplay::fgHosts[MAX_HOSTS];
+char* AliHLTPHOSOnlineDisplay::fgHosts[MAXHOSTS];
short unsigned int* AliHLTPHOSOnlineDisplay::fgPorts = 0;
TGTab* AliHLTPHOSOnlineDisplay::fTab = 0;
int
AliHLTPHOSOnlineDisplay::ScanArguments(int argc, char** argv)
{
- for(int i=0; i< MAX_HOSTS; i++)
+ for(int i=0; i< MAXHOSTS; i++)
{
fgHosts[i] = new char[256];
}
}
else
{
- fgPorts[fgNPorts] = DEFAULT_EVENT_PORT;
+ fgPorts[fgNPorts] = DEFAULTEVENTPORT;
cout << "B setting port to " << fgPorts[fgNPorts] <<endl;
fgNPorts ++;
portIsSet = kTRUE;
AliHLTPHOSOnlineDisplay::Gain2Text(const int gain, char *txt) const
{
- if(gain == LOW_GAIN)
+ if(gain == LOWGAIN)
{
sprintf(txt,"Low Gain");
}
- else if(gain == HIGH_GAIN)
+ else if(gain == HIGHGAIN)
{
sprintf(txt,"High Gain");
}
//#define N_SAMPLES 70
//#define N_SAMPLES 140
//#define MAX_HISTOGRAMS 25
-#define MAX_HISTOGRAMS 320
+#define MAXHISTOGRAMS 320
class TCanvas;
static unsigned int fgNHosts;
static unsigned int fgNPorts;
static AliHLTHOMERReader* fgHomerReaderPtr;
- static AliHLTHOMERReader* fgHomerReadersPtr[MAX_HOSTS];
- static char *fgHosts[MAX_HOSTS];
+ static AliHLTHOMERReader* fgHomerReadersPtr[MAXHOSTS];
+ static char *fgHosts[MAXHOSTS];
static short unsigned *fgPorts;
static Bool_t fgAccumulate;
static Bool_t fgSyncronize;
TCanvas *fgRawDataCanvas;
- TH1D *fgRawDataPlotsPtr[MAX_HISTOGRAMS];
+ TH1D *fgRawDataPlotsPtr[MAXHISTOGRAMS];
// int fRunNumber;
// bool fIsSetRunNumber;
cout << "AliHLTPHOSOnlineDisplayCalibTab:ERROR: You cannot create a onlinedisplay Tab without arguments" << endl;
}
-AliHLTPHOSOnlineDisplayCalibTab::AliHLTPHOSOnlineDisplayCalibTab(TGTab *tabPtr, HOMERReader *homerSyncPtr, HOMERReader *homerPtrs[MAX_HOSTS], int nHosts)
+AliHLTPHOSOnlineDisplayCalibTab::AliHLTPHOSOnlineDisplayCalibTab(TGTab *tabPtr, HOMERReader *homerSyncPtr, HOMERReader *homerPtrs[MAXHOSTS], int nHosts)
{
- for(int i=0; i<MAX_HOSTS; i++)
+ for(int i=0; i<MAXHOSTS; i++)
{
fgHomerReadersPtr[i] = 0;
}
int tmpdcsx;
int tmpdcsz;
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
- for(int z = 0; z <N_ZROWS_RCU; z ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
+ for(int z = 0; z <NZROWSRCU; z ++)
{
{
- for(int gain = 0; gain < N_GAINS; gain ++)
+ for(int gain = 0; gain < NGAINS; gain ++)
{
- tmpx = moduleID*N_XCOLUMNS_MOD + (accCellEnergiesPtr->fRcuX)*N_XCOLUMNS_RCU + x;
- tmpz = (accCellEnergiesPtr->fRcuZ)*N_ZROWS_RCU +z;
+ tmpx = moduleID*NXCOLUMNSMOD + (accCellEnergiesPtr->fRcuX)*NXCOLUMNSRCU + x;
+ tmpz = (accCellEnergiesPtr->fRcuZ)*NZROWSRCU +z;
- tmpdcsx = (accCellEnergiesPtr->fRcuX)*N_XCOLUMNS_RCU + x ;
- tmpdcsz = (accCellEnergiesPtr->fRcuZ)*N_ZROWS_RCU +z;
+ tmpdcsx = (accCellEnergiesPtr->fRcuX)*NXCOLUMNSRCU + x ;
+ tmpdcsz = (accCellEnergiesPtr->fRcuZ)*NZROWSRCU +z;
// if(tmpx < 140 && (tmpz < 6 || tmpz > 50) )
// if(tmpx < 132 && (tmpz > 52) )
// fgLegoPlotHGPtr = new TH2D("a Homer","HLT: #pi^{0} 5 - 30Gev HG, High gain",
fgLegoPlotHGPtr = new TH2D("a Homer","HLT: #pi^{0} 5 - 30Gev HG, High gain",
- N_XCOLUMNS_MOD*N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
- fgLegoPlotHGPtr->SetMaximum( MAX_BIN_VALUE);
+ NXCOLUMNSMOD*NMODULES , 0, NXCOLUMNSMOD*NMODULES,
+ NZROWSMOD, 0, NZROWSMOD);
+ fgLegoPlotHGPtr->SetMaximum( MAXBINVALUE);
fgLegoPlotHGPtr->Reset();
// fgLegoPlotHGPtr->GetXaxis()->SetRange(128, 128 + 64);
fgLegoPlotLGPtr = new TH2D("b Homer","HLT: #pi^{0} 5 - 30Gev LG, Low gain",
- N_XCOLUMNS_MOD* N_MODULES , 0, N_XCOLUMNS_MOD* N_MODULES,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
- fgLegoPlotLGPtr->SetMaximum( MAX_BIN_VALUE);
+ NXCOLUMNSMOD* NMODULES , 0, NXCOLUMNSMOD* NMODULES,
+ NZROWSMOD, 0, NZROWSMOD);
+ fgLegoPlotLGPtr->SetMaximum( MAXBINVALUE);
fgLegoPlotLGPtr->Reset();
// fgLegoPlotLGPtr->GetXaxis()->SetRange(128, 128 + 64);
kLHintsExpandY, 2, 2, 15, 1);
- for(int gain = 0; gain< N_GAINS; gain ++)
+ for(int gain = 0; gain< NGAINS; gain ++)
{
sprintf(tmpHistoName, "TAB a HLT gain %d", gain);
fgCalibHistPtr[gain] = new TH2D(tmpHistoName, tmpHistoName,
- N_XCOLUMNS_MOD*N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES ,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
+ NXCOLUMNSMOD*NMODULES , 0, NXCOLUMNSMOD*NMODULES ,
+ NZROWSMOD, 0, NZROWSMOD);
fgCalibHistPtr[gain]->Reset();
- fgCalibHistPtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
+ fgCalibHistPtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
sprintf(tmpHistoName, "TAB b Calibration Data HLT: #pi^{0} 5 - 30GeV gain %d", gain);
fgHitsHistPtr[gain] = new TH2I(tmpHistoName, tmpHistoName,
- N_XCOLUMNS_MOD* N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
- // fgHitsHistPtr[gain]->SetMaximum( MAX_BIN_VALUE);
+ NXCOLUMNSMOD* NMODULES , 0, NXCOLUMNSMOD*NMODULES,
+ NZROWSMOD, 0, NZROWSMOD);
+ // fgHitsHistPtr[gain]->SetMaximum( MAXBINVALUE);
fgHitsHistPtr[gain]->Reset();
- fgHitsHistPtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
+ fgHitsHistPtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
sprintf(tmpHistoName, "Average Energy gain %d", gain);
fgAveragePtr[gain] = new TH2D(tmpHistoName,tmpHistoName,
- N_XCOLUMNS_MOD* N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
- // fgAveragePtr[gain]->SetMaximum( MAX_BIN_VALUE);
+ NXCOLUMNSMOD* NMODULES , 0, NXCOLUMNSMOD*NMODULES,
+ NZROWSMOD, 0, NZROWSMOD);
+ // fgAveragePtr[gain]->SetMaximum( MAXBINVALUE);
fgAveragePtr[gain]->Reset();
- fgAveragePtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
+ fgAveragePtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
//sprintf(tmpHistoName, "Dead Channel Map gain%d", gain);
sprintf(tmpHistoName, "Dead Channel Map gain%d", gain);
fDeadCannelMapPtr[gain] = new TH2D(tmpHistoName,tmpHistoName,
- N_XCOLUMNS_MOD* N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
- // fDeadCannelMapPtr[gain]->SetMaximum( MAX_BIN_VALUE);
+ NXCOLUMNSMOD* NMODULES , 0, NXCOLUMNSMOD*NMODULES,
+ NZROWSMOD, 0, NZROWSMOD);
+ // fDeadCannelMapPtr[gain]->SetMaximum( MAXBINVALUE);
fDeadCannelMapPtr[gain]->Reset();
- fDeadCannelMapPtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
+ fDeadCannelMapPtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
sprintf(tmpHistoName, "DCS view gain %d", gain);
fgDCSViewPtr[gain] = new TH2D(tmpHistoName, tmpHistoName,
- N_ZROWS_MOD, 0, N_ZROWS_MOD,
- N_XCOLUMNS_MOD, 0, N_XCOLUMNS_MOD);
+ NZROWSMOD, 0, NZROWSMOD,
+ NXCOLUMNSMOD, 0, NXCOLUMNSMOD);
}
fgCanvasHGPtr = fEc7->GetCanvas();
fgCanvasHGPtr->cd();
- fgCalibHistPtr[HIGH_GAIN]->Draw("LEGO2Z");
+ fgCalibHistPtr[HIGHGAIN]->Draw("LEGO2Z");
fgCanvasHGPtr->Update();
fgCanvasLGPtr = fEc8->GetCanvas();
fgCanvasLGPtr->cd();
- fgCalibHistPtr[LOW_GAIN]->Draw("LEGO2Z");
+ fgCalibHistPtr[LOWGAIN]->Draw("LEGO2Z");
fgCanvasLGPtr->Update();
fgCanvasHGPtr = fEc9->GetCanvas();
fgCanvasHGPtr->cd();
- fgHitsHistPtr[HIGH_GAIN]->Draw("SCAT");
+ fgHitsHistPtr[HIGHGAIN]->Draw("SCAT");
fgCanvasHGPtr->Update();
fgCanvasLGPtr = fEc10->GetCanvas();
fgCanvasLGPtr->cd();
- fgHitsHistPtr[LOW_GAIN]->Draw("SCAT");
+ fgHitsHistPtr[LOWGAIN]->Draw("SCAT");
fgCanvasLGPtr->Update();
fgCanvasHGPtr = fEc11->GetCanvas();
fgCanvasHGPtr->cd();
- fgCalibHistPtr[HIGH_GAIN]->Draw("COLZ");
+ fgCalibHistPtr[HIGHGAIN]->Draw("COLZ");
fgCanvasHGPtr->Update();
fgCanvasLGPtr = fEc12->GetCanvas();
fgCanvasLGPtr->cd();
- fgCalibHistPtr[LOW_GAIN]->Draw("COLZ");
+ fgCalibHistPtr[LOWGAIN]->Draw("COLZ");
fgCanvasLGPtr->Update();
fgCanvasLGPtr = fEc13->GetCanvas();
fgCanvasLGPtr->cd();
- fgAveragePtr[HIGH_GAIN]->Draw("COLZ");
+ fgAveragePtr[HIGHGAIN]->Draw("COLZ");
fgCanvasLGPtr->Update();
fgCanvasHGPtr = fEc14->GetCanvas();
fgCanvasHGPtr->cd();
- fgAveragePtr[LOW_GAIN]->Draw("COLZ");
+ fgAveragePtr[LOWGAIN]->Draw("COLZ");
fgCanvasHGPtr->Update();
fgCanvasLGPtr = fEc15->GetCanvas();
fgCanvasLGPtr->cd();
- fDeadCannelMapPtr[HIGH_GAIN]->Draw("COL");
+ fDeadCannelMapPtr[HIGHGAIN]->Draw("COL");
fgCanvasLGPtr->Update();
fgCanvasHGPtr = fEc16->GetCanvas();
fgCanvasHGPtr->cd();
- fDeadCannelMapPtr[LOW_GAIN]->Draw("COL");
+ fDeadCannelMapPtr[LOWGAIN]->Draw("COL");
fgCanvasHGPtr->Update();
fgCanvasLGPtr = fEc17->GetCanvas();
fgCanvasLGPtr->cd();
- fgDCSViewPtr[HIGH_GAIN]->Draw("COLZ");
+ fgDCSViewPtr[HIGHGAIN]->Draw("COLZ");
fgCanvasLGPtr->Update();
fgCanvasHGPtr = fEc18->GetCanvas();
fgCanvasHGPtr->cd();
- fgDCSViewPtr[LOW_GAIN]->Draw("COLZ");
+ fgDCSViewPtr[LOWGAIN]->Draw("COLZ");
fgCanvasHGPtr->Update();
{
public:
AliHLTPHOSOnlineDisplayCalibTab();
- AliHLTPHOSOnlineDisplayCalibTab(TGTab *tabPtr, HOMERReader *homerSyncPtr, HOMERReader *homerPtrs[MAX_HOSTS], int nHosts);
+ AliHLTPHOSOnlineDisplayCalibTab(TGTab *tabPtr, HOMERReader *homerSyncPtr, HOMERReader *homerPtrs[MAXHOSTS], int nHosts);
virtual ~AliHLTPHOSOnlineDisplayCalibTab();
void InitDisplay(TGTab *tabPtr);
virtual void ReadBlockData(HOMERReader *homeReaderPtr);
void ResetDisplay();
- TH2D *fgCalibHistPtr[N_GAINS];
- TH2I *fgHitsHistPtr[N_GAINS];
- TH2D *fgAveragePtr[N_GAINS];
- TH2D *fgDCSViewPtr[N_GAINS];
+ TH2D *fgCalibHistPtr[NGAINS];
+ TH2I *fgHitsHistPtr[NGAINS];
+ TH2D *fgAveragePtr[NGAINS];
+ TH2D *fgDCSViewPtr[NGAINS];
- TH2D *fDeadCannelMapPtr[N_GAINS];
+ TH2D *fDeadCannelMapPtr[NGAINS];
TGTab *fTab;
TRootEmbeddedCanvas *fEc7, *fEc8, *fEc9, *fEc10, *fEc11, *fEc12, *fEc13, *fEc14, *fEc15, *fEc16, *fEc17, *fEc18;
TGTab *fSubTab2;
// $Id$
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Authors: 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 "AliHLTPHOSOnlineDisplayEventTab.h"
#include <iostream>
#include "TGFrame.h"
}
-AliHLTPHOSOnlineDisplayEventTab::AliHLTPHOSOnlineDisplayEventTab(AliHLTPHOSOnlineDisplay *onlineDisplayPtr, TGTab *tabPtr,
- AliHLTHOMERReader *homerSyncPtr, AliHLTHOMERReader *homerPtrs[MAX_HOSTS],
+AliHLTPHOSOnlineDisplayEventTab::AliHLTPHOSOnlineDisplayEventTab(AliHLTPHOSOnlineDisplay * const onlineDisplayPtr, TGTab *tabPtr,
+ const AliHLTHOMERReader * const homerSyncPtr, AliHLTHOMERReader * const homerPtrs[MAXHOSTS],
int nHosts, const int runnumber) : AliHLTPHOSOnlineDisplayTab()
{
-
+ //comment
/*
if(fIsSetRunNumber == true)
{
- for(int i=0; i < N_GAINS; i++)
+ for(int i=0; i < NGAINS; i++)
{
fgLegoPlotPtr[gain]
}
fOnlineDisplayPtr = onlineDisplayPtr;
- for(int gain = 0; gain < N_GAINS; gain ++ )
+ for(int gain = 0; gain < NGAINS; gain ++ )
{
fgCanvasPtr[gain] = 0;
fgLegoPlotPtr[gain] = 0;
- for(int mod =0; mod <N_MODULES; mod ++)
+ for(int mod =0; mod <NMODULES; mod ++)
{
- for(int rcu_x_coord = 0; rcu_x_coord < N_ZRCU_COORD; rcu_x_coord ++)
+ for(int rcuxcoord = 0; rcuxcoord < NZRCUCOORD; rcuxcoord ++)
{
- for(int rcu_z_coord = 0; rcu_z_coord < N_XRCU_COORD; rcu_z_coord ++)
+ for(int rcuzcoord = 0; rcuzcoord < NXRCUCOORD; rcuzcoord ++)
{
- for(int z = 0; z < N_ZROWS_RCU; z ++)
+ for(int z = 0; z < NZROWSRCU; z ++)
{
- for(int x = 0; x < N_XCOLUMNS_RCU; x ++)
+ for(int x = 0; x < NXCOLUMNSRCU; x ++)
{
- fChannelData[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = new int[ALTRO_MAX_SAMPLES];
- fNChannelSamples[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = 0;
- fChannelEnergy[mod][rcu_z_coord][rcu_x_coord][x][z][gain] = 0;
+ fChannelData[mod][rcuzcoord][rcuxcoord][x][z][gain] = new int[ALTROMAXSAMPLES];
+ fNChannelSamples[mod][rcuzcoord][rcuxcoord][x][z][gain] = 0;
+ fChannelEnergy[mod][rcuzcoord][rcuxcoord][x][z][gain] = 0;
}
}
}
}
}
- for(int i=0; i<MAX_HOSTS; i++)
+ for(int i=0; i<MAXHOSTS; i++)
{
fgHomerReadersPtr[i] = 0;
}
AliHLTPHOSOnlineDisplayEventTab::~AliHLTPHOSOnlineDisplayEventTab()
{
-
+ //comment
}
int
AliHLTPHOSOnlineDisplayEventTab::GetNextEvent()
{
+ //comment
ResetDisplay();
// MT crap
Bool_t is_first = false;
void
-AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks(AliHLTHOMERReader *homerReaderPtr)
+AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks(AliHLTHOMERReader * const homerReaderPtr) const
{
+ //comment
cout << "AliHLTPHOSOnlineDisplayEventTab::FindFourierBlocks" << endl;
// unsigned long blk = homeReaderPtr->FindBlockNdx("RENELLEC","SOHP", 0xFFFFFFFF );
unsigned long blk = homerReaderPtr->FindBlockNdx(" TREIRUOF","SOHP", 0xFFFFFFFF );
void
AliHLTPHOSOnlineDisplayEventTab::ReadBlockData(AliHLTHOMERReader *homeReaderPtr)
{
+ //comment
AliHLTPHOSValidCellDataStruct *currentChannel =0;
cout << "AliHLTPHOSOnlineDisplayEventTab::ReadBlockDat, Reading block data, therere are " << homeReaderPtr->GetBlockCnt() << " blocks " <<endl;
tmpZ = currentChannel->fZ;
tmpX = currentChannel->fX;
tmpGain = currentChannel->fGain;
- fgLegoPlotPtr[tmpGain]->Fill(moduleID*N_XCOLUMNS_MOD + tmpX + N_XCOLUMNS_RCU*cellEnergiesPtr->fRcuX,
- tmpZ + N_ZROWS_RCU*cellEnergiesPtr->fRcuZ, currentChannel->fEnergy);
+ fgLegoPlotPtr[tmpGain]->Fill(moduleID*NXCOLUMNSMOD + tmpX + NXCOLUMNSRCU*cellEnergiesPtr->fRcuX,
+ tmpZ + NZROWSRCU*cellEnergiesPtr->fRcuZ, currentChannel->fEnergy);
// CRAP PTH
- if(tmpGain == HIGH_GAIN)
+ if(tmpGain == HIGHGAIN)
{
// gAliEveBoxSet->AddBox(2.2*(tmpX + N_XCOLUMNS_RCU*cellEnergiesPtr->fRcuX) - 1.1,
// 0,
-// 2.2*(tmpZ + N_ZROWS_RCU*cellEnergiesPtr->fRcuZ) - 1.1,
+// 2.2*(tmpZ + N_ZROWSRCU*cellEnergiesPtr->fRcuZ) - 1.1,
// 2.2,
// 0.4*140*currentChannel->fEnergy/1024,
// 2.2);
// cout << __FILE__ << ":" << __LINE__ << " the address of raw ptr = " << rawPtr << endl;
- if(nSamples > ALTRO_MAX_SAMPLES || nSamples < 0 )
+ if(nSamples > ALTROMAXSAMPLES || nSamples < 0 )
{
- cout << __FILE__<< ":" <<__LINE__ <<"ERROR, nsamples = "<< nSamples <<" exeeds allowd range, max number of samples is "<< ALTRO_MAX_SAMPLES << endl;
+ cout << __FILE__<< ":" <<__LINE__ <<"ERROR, nsamples = "<< nSamples <<" exeeds allowd range, max number of samples is "<< ALTROMAXSAMPLES << endl;
}
else
{
void
AliHLTPHOSOnlineDisplayEventTab::ResetDisplay()
{
+ //comment
if(fgAccumulate == kFALSE)
{
- for(int gain=0; gain < N_GAINS; gain++)
+ for(int gain=0; gain < NGAINS; gain++)
{
if(fgLegoPlotPtr[gain] !=0)
{
void
-AliHLTPHOSOnlineDisplayEventTab::InitDisplay(TGTab *tabPtr, const int runnumber)
+AliHLTPHOSOnlineDisplayEventTab::InitDisplay(const TGTab * const tabPtr, const int runnumber)
{
// gStyle->SetOptLogy();
/// gStyle->SetOptStat(true);
- for(int gain=0; gain < N_GAINS; gain++)
+ for(int gain=0; gain < NGAINS; gain++)
{
char gainLabel[100];
char label[256];
fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
sprintf(label, "PHOS HLT Online Display %s", gainLabel);
fgLegoPlotPtr[gain] = new AliHLTPHOSOnlineDisplayTH2D(fOnlineDisplayPtr, label, label,
- N_XCOLUMNS_MOD*N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
+ NXCOLUMNSMOD*NMODULES , 0, NXCOLUMNSMOD*NMODULES,
+ NZROWSMOD, 0, NZROWSMOD);
// cout << __FILE__ << ":" << __LINE__ << " Runnumber = " << runnumber <<endl;
fgLegoPlotPtr[gain]->SetRunNumber(runnumber);
fgLegoPlotPtr[gain]->SetMaximum(1023);
fgLegoPlotPtr[gain]->Reset();
- fgLegoPlotPtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
+ fgLegoPlotPtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
}
// gStyle->SetOptLogy();
// gStyle->SetOptStat(true);
- fgCanvasPtr[HIGH_GAIN] = fEc1->GetCanvas();
- fgCanvasPtr[HIGH_GAIN]->cd();
- fgLegoPlotPtr[HIGH_GAIN]->Draw("LEGO2Z");
- fgCanvasPtr[HIGH_GAIN]->Update();
- fgCanvasPtr[LOW_GAIN] = fEc2->GetCanvas();
- fgCanvasPtr[LOW_GAIN]->cd();
- fgLegoPlotPtr[LOW_GAIN]->Draw("LEGO2Z");
- fgCanvasPtr[LOW_GAIN]->Update();
-
- fgCanvasPtr[HIGH_GAIN] = fEc3->GetCanvas();
- fgCanvasPtr[HIGH_GAIN]->cd();
- fgLegoPlotPtr[HIGH_GAIN]->Draw("SCAT");
- fgCanvasPtr[HIGH_GAIN]->Update();
- fgCanvasPtr[LOW_GAIN] = fEc4->GetCanvas();
- fgCanvasPtr[LOW_GAIN]->cd();
- fgLegoPlotPtr[LOW_GAIN]->Draw("SCAT");
- fgCanvasPtr[LOW_GAIN]->Update();
+ fgCanvasPtr[HIGHGAIN] = fEc1->GetCanvas();
+ fgCanvasPtr[HIGHGAIN]->cd();
+ fgLegoPlotPtr[HIGHGAIN]->Draw("LEGO2Z");
+ fgCanvasPtr[HIGHGAIN]->Update();
+ fgCanvasPtr[LOWGAIN] = fEc2->GetCanvas();
+ fgCanvasPtr[LOWGAIN]->cd();
+ fgLegoPlotPtr[LOWGAIN]->Draw("LEGO2Z");
+ fgCanvasPtr[LOWGAIN]->Update();
+
+ fgCanvasPtr[HIGHGAIN] = fEc3->GetCanvas();
+ fgCanvasPtr[HIGHGAIN]->cd();
+ fgLegoPlotPtr[HIGHGAIN]->Draw("SCAT");
+ fgCanvasPtr[HIGHGAIN]->Update();
+ fgCanvasPtr[LOWGAIN] = fEc4->GetCanvas();
+ fgCanvasPtr[LOWGAIN]->cd();
+ fgLegoPlotPtr[LOWGAIN]->Draw("SCAT");
+ fgCanvasPtr[LOWGAIN]->Update();
/*
- fgCanvasPtr[HIGH_GAIN] = fEc5->GetCanvas();
- fgCanvasPtr[HIGH_GAIN]->cd();
- fgLegoPlotPtr[HIGH_GAIN]->Draw("CONTZ");
- fgCanvasPtr[HIGH_GAIN]->Update();
- fgCanvasPtr[LOW_GAIN] = fEc6->GetCanvas();
- fgCanvasPtr[LOW_GAIN]->cd();
- fgLegoPlotPtr[LOW_GAIN]->Draw("CONTZ");
- fgCanvasPtr[LOW_GAIN]->Update();
+ fgCanvasPtr[HIGHGAIN] = fEc5->GetCanvas();
+ fgCanvasPtr[HIGHGAIN]->cd();
+ fgLegoPlotPtr[HIGHGAIN]->Draw("CONTZ");
+ fgCanvasPtr[HIGHGAIN]->Update();
+ fgCanvasPtr[LOWGAIN] = fEc6->GetCanvas();
+ fgCanvasPtr[LOWGAIN]->cd();
+ fgLegoPlotPtr[LOWGAIN]->Draw("CONTZ");
+ fgCanvasPtr[LOWGAIN]->Update();
*/
- fgCanvasPtr[HIGH_GAIN] = fEc5->GetCanvas();
- fgCanvasPtr[HIGH_GAIN]->cd();
- fgLegoPlotPtr[HIGH_GAIN]->Draw("COLZ");
- fgCanvasPtr[HIGH_GAIN]->Update();
- fgCanvasPtr[LOW_GAIN] = fEc6->GetCanvas();
- fgCanvasPtr[LOW_GAIN]->cd();
- fgLegoPlotPtr[LOW_GAIN]->Draw("COLZ");
- fgCanvasPtr[LOW_GAIN]->Update();
+ fgCanvasPtr[HIGHGAIN] = fEc5->GetCanvas();
+ fgCanvasPtr[HIGHGAIN]->cd();
+ fgLegoPlotPtr[HIGHGAIN]->Draw("COLZ");
+ fgCanvasPtr[HIGHGAIN]->Update();
+ fgCanvasPtr[LOWGAIN] = fEc6->GetCanvas();
+ fgCanvasPtr[LOWGAIN]->cd();
+ fgLegoPlotPtr[LOWGAIN]->Draw("COLZ");
+ fgCanvasPtr[LOWGAIN]->Update();
}
//-*- Mode: C++ -*-
// $Id$
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Authors: 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. *
+ **************************************************************************/
+
#ifndef ALIHLTPHOSONLINEDISPLAYEVENTTAB_H
#define ALIHLTPHOSONLINEDISPLAYEVENTTAB_H
-#include <TGTab.h>
-#include <TRootEmbeddedCanvas.h>
-#include "AliHLTPHOSOnlineDisplayTab.h"
-#include <TCanvas.h>
-#include <TH2D.h>
-#include <TH1D.h>
-#include "AliHLTPHOSOnlineDisplayTH2D.h"
-#include "AliHLTPHOSConstants.h"
+//#include <TGTab.h>
+// #include <TRootEmbeddedCanvas.h>
+// #include "AliHLTPHOSOnlineDisplayTab.h"
+// #include <TCanvas.h>
+// #include <TH2D.h>
+// #include <TH1D.h>
+// #include "AliHLTPHOSOnlineDisplayTH2D.h"
+// #include "AliHLTPHOSConstants.h"
-#define N_ZRCU_COORD 2
-#define N_XRCU_COORD 2
+#define NZRCUCOORD 2
+#define NXRCUCOORD 2
using namespace PhosHLTConst;
+class TGTab;
+class TRootEmbeddedCanvas;p
+class AliHLTPHOSOnlineDisplayTab;
+class TCanvas;
+class TH2D;
+class TH1D;
+class AliHLTPHOSOnlineDisplayTH2D;
+class AliHLTPHOSConstants;
class AliHLTPHOSGetEventButton;
class AliHLTHOMERReader;
class AliHLTPHOSRcuCellEnergyDataStruct;
AliHLTPHOSOnlineDisplayEventTab(AliHLTPHOSOnlineDisplay *onlineDisplayPtr, TGTab *tabPtr,
AliHLTHOMERReader *fgHomerReaderPtr,
- AliHLTHOMERReader *fgHomerReadersPtr[MAX_HOSTS],
+ AliHLTHOMERReader *fgHomerReadersPtr[MAXHOSTS],
int nHosts, const int runnumber = -1);
// {
TGTab *fSubTab1;
TRootEmbeddedCanvas *fEc1, *fEc2, *fEc3, *fEc4, *fEc5, *fEc6;
TGCompositeFrame *fSubF1, *fSubF2, *fSubF3;
- TCanvas *fgCanvasPtr[N_GAINS];
- AliHLTPHOSOnlineDisplayTH2D *fgLegoPlotPtr[N_GAINS];
- int *fChannelData[N_MODULES][N_XRCU_COORD][N_ZRCU_COORD][N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- Int_t fNChannelSamples[N_MODULES][N_XRCU_COORD][N_ZRCU_COORD][N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- Int_t fChannelEnergy[N_MODULES][N_XRCU_COORD][N_ZRCU_COORD][N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
+ TCanvas *fgCanvasPtr[NGAINS];
+ AliHLTPHOSOnlineDisplayTH2D *fgLegoPlotPtr[NGAINS];
+ int *fChannelData[NMODULES][NXRCUCOORD][NZRCUCOORD][NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ Int_t fNChannelSamples[NMODULES][NXRCUCOORD][NZRCUCOORD][NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ Int_t fChannelEnergy[NMODULES][NXRCUCOORD][NZRCUCOORD][NXCOLUMNSRCU][NZROWSRCU][NGAINS];
protected:
- Bool_t fgAccumulate;
+ // Bool_t fgAccumulate;
private:
AliHLTPHOSOnlineDisplayEventTab();
AliHLTPHOSGetEventButton* fgEventButtPtr;
- void InitDisplay(TGTab *tabPtr) {};
- void InitDisplay(TGTab *tabPtr, const int runnumber);
+ void InitDisplay(TGTab *tabPtr) const {};
+ void InitDisplay(const TGTab * const tabPtr, const int runnumber);
AliHLTPHOSOnlineDisplay *fOnlineDisplayPtr;
AliHLTPHOSSharedMemoryInterface *fShmPtr;
+ AliHLTPHOSOnlineDisplayEventTab(const AliHLTPHOSOnlineDisplayEventTab&);
+ AliHLTPHOSOnlineDisplayEventTab & operator=(const AliHLTPHOSOnlineDisplayEventTab);
+
+
///int fEvent
};
#include "AliHLTPHOSRcuFFTDataStruct.h"
#include "TStyle.h"
-#define SAMPLING_FREQUENCY 10
+#define SAMPLINGFREQUENCY 10
using namespace std;
AliHLTPHOSOnlineDisplayFourierTab::AliHLTPHOSOnlineDisplayFourierTab(AliHLTPHOSOnlineDisplay *onlineDisplayPtr, TGTab *tabPtr,
- AliHLTHOMERReader *homerSyncPtr, AliHLTHOMERReader *homerPtrs[MAX_HOSTS], int nHosts) : AliHLTPHOSOnlineDisplayTab(), fEvtCnt(0)
+ AliHLTHOMERReader *homerSyncPtr, AliHLTHOMERReader *homerPtrs[MAXHOSTS], int nHosts) : AliHLTPHOSOnlineDisplayTab(), fEvtCnt(0)
{
// gStyle->SetOptLogy();
fOnlineDisplayPtr = onlineDisplayPtr;
fFourierPtr = new AliHLTPHOSFourier();
- for(int gain = 0; gain < N_GAINS; gain ++ )
+ for(int gain = 0; gain < NGAINS; gain ++ )
{
fFourierHistoNew[gain] = 0;
fFourierHistoOld[gain] = 0;
fFourierHistoAccumulated[gain] = 0;
}
- for(int i=0; i<MAX_HOSTS; i++)
+ for(int i=0; i<MAXHOSTS; i++)
{
fgHomerReadersPtr[i] = 0;
}
int linewidth = 0;
// double linewidth = 1.2;
- for(int gain = 0; gain < N_GAINS; gain ++ )
+ for(int gain = 0; gain < NGAINS; gain ++ )
{
if( fFourierHistoNew[gain] == 0)
{
sprintf(tmptitle, "PSD averaged over all %s channels: Most recent event", Gain2Text(gain, ' '));
sprintf(tmpname, "PSD_averaged_over_all_%s_channels__most_recent_event", Gain2Text(gain, '_'));
- fFourierHistoNew[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLING_FREQUENCY/2);
+ fFourierHistoNew[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLINGFREQUENCY/2);
fFourierHistoNew[gain]->GetXaxis()->SetTitle("f/MHz");
fFourierHistoNew[gain]->GetYaxis()->SetTitle("Power (arbitrary units)");
fFourierHistoNew[gain]->SetLineWidth(linewidth);
{
sprintf(tmptitle, "PSD averaged over all %s channels: Previous event", Gain2Text(gain, ' '));
sprintf(tmpname, "PSD_averaged_over_all_%s_channels__previous_event", Gain2Text(gain, '_'));
- fFourierHistoOld[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLING_FREQUENCY/2);
+ fFourierHistoOld[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLINGFREQUENCY/2);
fFourierHistoOld[gain]->GetXaxis()->SetTitle("f/MHz");
fFourierHistoOld[gain]->GetYaxis()->SetTitle("Power (arbitrary units)");
fFourierHistoOld[gain]->SetLineWidth(linewidth);
{
sprintf(tmptitle, "PSD averaged over all %s channels: All events", Gain2Text(gain, ' '));
sprintf(tmpname, "PSD_averaged_over_all_%s_channels__All_events", Gain2Text(gain, '_'));
- fFourierHistoAccumulated[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLING_FREQUENCY/2);
+ fFourierHistoAccumulated[gain] = new TH1D(tmpname, tmptitle, (size/2) +1, 0, SAMPLINGFREQUENCY/2);
fFourierHistoAccumulated[gain]->GetXaxis()->SetTitle("f/MHz");
fFourierHistoAccumulated[gain]->GetYaxis()->SetTitle("Power (arbitrary units)");
fFourierHistoAccumulated[gain]->SetLineWidth(linewidth);
void
AliHLTPHOSOnlineDisplayFourierTab::InitDisplay(TGTab *tabPtr)
{
- for(int gain=0; gain < N_GAINS; gain++)
+ for(int gain=0; gain < NGAINS; gain++)
{
char gainLabel[100];
char label[256];
fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
sprintf(label, "PHOS Fourier transform %s", gainLabel);
fgLegoPlotPtr[gain] = new AliHLTPHOSOnlineDisplayTH2D(fOnlineDisplayPtr, label, label,
- N_XCOLUMNS_MOD*N_MODULES , 0, N_XCOLUMNS_MOD*N_MODULES,
- N_ZROWS_MOD, 0, N_ZROWS_MOD);
- // fgLegoPlotPtr[gain]->SetGain(HIGH_GAIN);
+ NXCOLUMNSMOD*NMODULES , 0, NXCOLUMNSMOD*NMODULES,
+ NZROWSMOD, 0, NZROWSMOD);
+ // fgLegoPlotPtr[gain]->SetGain(HIGHGAIN);
fgLegoPlotPtr[gain]->SetMaximum(1023);
fgLegoPlotPtr[gain]->Reset();
- fgLegoPlotPtr[gain]->GetXaxis()->SetRange(X_RANGE_START, X_RANGE_END);
+ fgLegoPlotPtr[gain]->GetXaxis()->SetRange(XRANGESTART, XRANGEEND);
}
void
AliHLTPHOSOnlineDisplayFourierTab::UpdateDisplay()
{
- if( fFourierHistoNew[HIGH_GAIN])
+ if( fFourierHistoNew[HIGHGAIN])
{
- fgCanvasPtr[HIGH_GAIN] = fEc1->GetCanvas();
- fgCanvasPtr[HIGH_GAIN]->cd();
+ fgCanvasPtr[HIGHGAIN] = fEc1->GetCanvas();
+ fgCanvasPtr[HIGHGAIN]->cd();
gPad->SetLogy();
- // fgLegoPlotPtr[HIGH_GAIN]->Draw("LGZ");
- fFourierHistoNew[HIGH_GAIN]->Draw();
- fgCanvasPtr[HIGH_GAIN]->Update();
+ // fgLegoPlotPtr[HIGHGAIN]->Draw("LGZ");
+ fFourierHistoNew[HIGHGAIN]->Draw();
+ fgCanvasPtr[HIGHGAIN]->Update();
}
- if( fFourierHistoNew[LOW_GAIN])
+ if( fFourierHistoNew[LOWGAIN])
{
- fgCanvasPtr[LOW_GAIN] = fEc2->GetCanvas();
- fgCanvasPtr[LOW_GAIN]->cd();
+ fgCanvasPtr[LOWGAIN] = fEc2->GetCanvas();
+ fgCanvasPtr[LOWGAIN]->cd();
gPad->SetLogy();
- // fgLegoPlotPtr[LOW_GAIN]->Draw("HGZ");
- fFourierHistoNew[LOW_GAIN]->Draw();
- fgCanvasPtr[LOW_GAIN]->Update();
+ // fgLegoPlotPtr[LOWGAIN]->Draw("HGZ");
+ fFourierHistoNew[LOWGAIN]->Draw();
+ fgCanvasPtr[LOWGAIN]->Update();
}
- if( fFourierHistoOld[HIGH_GAIN])
+ if( fFourierHistoOld[HIGHGAIN])
{
- fgCanvasPtr[HIGH_GAIN] = fEc3->GetCanvas();
- fgCanvasPtr[HIGH_GAIN]->cd();
+ fgCanvasPtr[HIGHGAIN] = fEc3->GetCanvas();
+ fgCanvasPtr[HIGHGAIN]->cd();
gPad->SetLogy();
- // fgLegoPlotPtr[HIGH_GAIN]->Draw("Low gain");
- fFourierHistoOld[HIGH_GAIN]->Draw();
- fgCanvasPtr[HIGH_GAIN]->Update();
+ // fgLegoPlotPtr[HIGHGAIN]->Draw("Low gain");
+ fFourierHistoOld[HIGHGAIN]->Draw();
+ fgCanvasPtr[HIGHGAIN]->Update();
}
- if( fFourierHistoOld[LOW_GAIN])
+ if( fFourierHistoOld[LOWGAIN])
{
- fgCanvasPtr[LOW_GAIN] = fEc4->GetCanvas();
- fgCanvasPtr[LOW_GAIN]->cd();
- //fgLegoPlotPtr[LOW_GAIN]->Draw("High gain");
+ fgCanvasPtr[LOWGAIN] = fEc4->GetCanvas();
+ fgCanvasPtr[LOWGAIN]->cd();
+ //fgLegoPlotPtr[LOWGAIN]->Draw("High gain");
gPad->SetLogy();
- fFourierHistoOld[LOW_GAIN]->Draw();
- fgCanvasPtr[LOW_GAIN]->Update();
+ fFourierHistoOld[LOWGAIN]->Draw();
+ fgCanvasPtr[LOWGAIN]->Update();
}
- if( fFourierHistoAccumulated[HIGH_GAIN])
+ if( fFourierHistoAccumulated[HIGHGAIN])
{
- fgCanvasPtr[HIGH_GAIN] = fEc5->GetCanvas();
- fgCanvasPtr[HIGH_GAIN]->cd();
+ fgCanvasPtr[HIGHGAIN] = fEc5->GetCanvas();
+ fgCanvasPtr[HIGHGAIN]->cd();
gPad->SetLogy();
- fFourierHistoAccumulated[HIGH_GAIN]->Draw();
- // fgLegoPlotPtr[HIGH_GAIN]->Draw("CONTZ");
- fgCanvasPtr[HIGH_GAIN]->Update();
+ fFourierHistoAccumulated[HIGHGAIN]->Draw();
+ // fgLegoPlotPtr[HIGHGAIN]->Draw("CONTZ");
+ fgCanvasPtr[HIGHGAIN]->Update();
}
- if( fFourierHistoAccumulated[LOW_GAIN])
+ if( fFourierHistoAccumulated[LOWGAIN])
{
- fgCanvasPtr[LOW_GAIN] = fEc6->GetCanvas();
- fgCanvasPtr[LOW_GAIN]->cd();
+ fgCanvasPtr[LOWGAIN] = fEc6->GetCanvas();
+ fgCanvasPtr[LOWGAIN]->cd();
gPad->SetLogy();
- // fgLegoPlotPtr[LOW_GAIN]->Draw("CONTZ");
- fFourierHistoAccumulated[LOW_GAIN]->Draw();
- fgCanvasPtr[LOW_GAIN]->Update();
+ // fgLegoPlotPtr[LOWGAIN]->Draw("CONTZ");
+ fFourierHistoAccumulated[LOWGAIN]->Draw();
+ fgCanvasPtr[LOWGAIN]->Update();
}
}
const char*
AliHLTPHOSOnlineDisplayFourierTab::Gain2Text(const int gain, const char delimeter)
{
- if(gain == LOW_GAIN)
+ if(gain == LOWGAIN)
{
sprintf(fGainText, "low%cgain", delimeter);
}
- else if(gain == HIGH_GAIN)
+ else if(gain == HIGHGAIN)
{
sprintf(fGainText, "high%cgain", delimeter);
}
{
public:
virtual ~AliHLTPHOSOnlineDisplayFourierTab();
- AliHLTPHOSOnlineDisplayFourierTab(AliHLTPHOSOnlineDisplay *onlineDisplayPtr, TGTab *tabPtr, AliHLTHOMERReader *fgHomerReaderPtr, AliHLTHOMERReader *fgHomerReadersPtr[MAX_HOSTS], int nHosts);
+ AliHLTPHOSOnlineDisplayFourierTab(AliHLTPHOSOnlineDisplay *onlineDisplayPtr, TGTab *tabPtr, AliHLTHOMERReader *fgHomerReaderPtr, AliHLTHOMERReader *fgHomerReadersPtr[MAXHOSTS], int nHosts);
Int_t GetRawData(TH1D *histPtr, int x, int z, int gain);
void UpdateDisplay();
int GetNextEvent();
// TRootEmbeddedCanvas *fEc1, *fEc2, *fEc3, *fEc4;
// TGCompositeFrame *fSubF1, *fSubF2;
TGCompositeFrame *fSubF1, *fSubF2, *fSubF3;
- TCanvas *fgCanvasPtr[N_GAINS];
- AliHLTPHOSOnlineDisplayTH2D *fgLegoPlotPtr[N_GAINS];
+ TCanvas *fgCanvasPtr[NGAINS];
+ AliHLTPHOSOnlineDisplayTH2D *fgLegoPlotPtr[NGAINS];
- TH1D *fFourierHistoNew[N_GAINS];
- TH1D *fFourierHistoOld[N_GAINS];
- TH1D *fFourierHistoAccumulated[N_GAINS];
+ TH1D *fFourierHistoNew[NGAINS];
+ TH1D *fFourierHistoOld[NGAINS];
+ TH1D *fFourierHistoAccumulated[NGAINS];
- // TRootEmbeddedCanvas *fFourierHistoAccumulatedEC[N_GAINS];
- // TRootEmbeddedCanvas *fFourierHistoOldEC[N_GAINS];
- // TRootEmbeddedCanvas *fFourierHistoAccumulatedEC[N_GAINS];
+ // TRootEmbeddedCanvas *fFourierHistoAccumulatedEC[NGAINS];
+ // TRootEmbeddedCanvas *fFourierHistoOldEC[NGAINS];
+ // TRootEmbeddedCanvas *fFourierHistoAccumulatedEC[NGAINS];
- // int *fChannelData[N_MODULES][N_XRCU_COORD][N_ZRCU_COORD][N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- // Int_t fNChannelSamples[N_MODULES][N_XRCU_COORD][N_ZRCU_COORD][N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
- // Int_t fChannelEnergy[N_MODULES][N_XRCU_COORD][N_ZRCU_COORD][N_XCOLUMNS_RCU][N_ZROWS_RCU][N_GAINS];
+ // int *fChannelData[NMODULES][NXRCUCOORD][NZRCUCOORD][NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ // Int_t fNChannelSamples[NMODULES][NXRCUCOORD][NZRCUCOORD][NXCOLUMNSRCU][NZROWSRCU][NGAINS];
+ // Int_t fChannelEnergy[NMODULES][NXRCUCOORD][NZRCUCOORD][NXCOLUMNSRCU][NZROWSRCU][NGAINS];
const char* Gain2Text(const int gain, const char delimeter);
protected:
// #define PZ_MIN 60
// #define PZ_MAX 380
-#define PX_MIN 55
-#define PX_MAX 420
-#define PZ_MIN 34
-#define PZ_MAX 251
+#define PXMIN 55
+#define PXMAX 420
+#define PZMIN 34
+#define PZMAX 251
AliHLTPHOSOnlineDisplayTH2D::AliHLTPHOSOnlineDisplayTH2D()
int tmpZBin = 0;
int tmpXBin = 0;
- for(int gain = 0; gain < N_GAINS; gain++)
+ for(int gain = 0; gain < NGAINS; gain++)
{
if(event == 61)
{
cout << "px = " << px << "pz =" << pz << endl;
cout << __FILE__ << ":" <<__LINE__ << " ObjectInfo IS !!" << GetObjectInfo(px, pz) << endl;
- fgRawDataCanvasPtr[gain]->Divide(Z_ROWS, X_COLS);
+ fgRawDataCanvasPtr[gain]->Divide(ZROWS, XCOLS);
int cnt = 0;
for(int z= 1; z > -2; z--)
{
- for(int x=-1; x < X_COLS -1; x ++)
+ for(int x=-1; x < XCOLS -1; x ++)
{
fOnlineDisplayPtr->Gain2Text(gain,gainLabel);
cnt ++;
- fgRawDataPlotsPtr[cnt][gain] = new TH1D(label, label, ALTRO_MAX_SAMPLES, 0, ALTRO_MAX_SAMPLES -1);
+ fgRawDataPlotsPtr[cnt][gain] = new TH1D(label, label, ALTROMAXSAMPLES, 0, ALTROMAXSAMPLES -1);
fgRawDataCanvasPtr[gain]->cd(cnt);
fgRawDataPlotsPtr[cnt][gain]->SetFillColor(1);
fgRawDataPlotsPtr[cnt][gain]->Reset();
- fgRawDataPlotsSinglePtr[gain] = new TH1D(label, label, ALTRO_MAX_SAMPLES, 0, ALTRO_MAX_SAMPLES -1);
+ fgRawDataPlotsSinglePtr[gain] = new TH1D(label, label, ALTROMAXSAMPLES, 0, ALTROMAXSAMPLES -1);
fgRawDataPlotsSinglePtr[gain]->SetFillColor(1);
fgRawDataPlotsSinglePtr[gain]->Reset();
Int_t nSamples = fOnlineDisplayPtr->fgEventTabPtr->GetRawData(fgRawDataPlotsSinglePtr[gain], tmpXBin, tmpZBin, gain);
AliHLTPHOSOnlineDisplayTH2D::GetXBin(Int_t px)
{
float tmpBinRange = GetXaxis()->GetLast() - GetXaxis()->GetFirst();
- float tmpPixelRange = PX_MAX - PX_MIN;
- float tmpPixRelative = (px - PX_MIN)/tmpPixelRange ;
+ float tmpPixelRange = PXMAX - PXMIN;
+ float tmpPixRelative = (px - PXMIN)/tmpPixelRange ;
int xBin = ((int)((tmpPixRelative)*tmpBinRange) + (float)GetXaxis()->GetFirst());
return xBin;
}
AliHLTPHOSOnlineDisplayTH2D::GetZBin(Int_t pz)
{
float tmpBinRange = GetYaxis()->GetLast() - GetYaxis()->GetFirst();
- float tmpPixelRange = PZ_MAX - PZ_MIN;
- float tmpPixRelative = (pz - PZ_MIN)/tmpPixelRange;
+ float tmpPixelRange = PZMAX - PZMIN;
+ float tmpPixRelative = (pz - PZMIN)/tmpPixelRange;
int zBin = (int)((1-tmpPixRelative)*tmpBinRange);
return zBin;
}
* provided "as is" without express or implied warranty. *
**************************************************************************/
-#define Z_ROWS 3
-#define X_COLS 3
-#define N_HISTOGRAMS Z_ROWS*X_COLS +4
+#define ZROWS 3
+#define XCOLS 3
+#define NHISTOGRAMS ZROWS*XCOLS +4
#include <TH2D.h>
#include <TCanvas.h>
private:
AliHLTPHOSOnlineDisplayTH2D();
AliHLTPHOSOnlineDisplay *fOnlineDisplayPtr;
- TCanvas *fgRawDataCanvasPtr[N_GAINS];
- TH1D *fgRawDataPlotsPtr[N_HISTOGRAMS][N_GAINS];
- TCanvas *fgRawDataCanvasSinglePtr[N_GAINS];
- TH1D *fgRawDataPlotsSinglePtr[N_GAINS];
+ TCanvas *fgRawDataCanvasPtr[NGAINS];
+ TH1D *fgRawDataPlotsPtr[NHISTOGRAMS][NGAINS];
+ TCanvas *fgRawDataCanvasSinglePtr[NGAINS];
+ TH1D *fgRawDataPlotsSinglePtr[NGAINS];
+
int fRunNumber;
// bool fIsSetRunNumber;
#include "AliHLTPHOSConstants.h"
#include "AliHLTPHOSBase.h"
-//#define X_RANGE_START 120
-//#define X_RANGE_LENGTH 80
+//#define XRANGESTART 120
+//#define XRANGELENGTH 80
-#define X_RANGE_START 128
-#define X_RANGE_LENGTH 64
+#define XRANGESTART 128
+#define XRANGELENGTH 64
-#define X_RANGE_END X_RANGE_START + X_RANGE_LENGTH
+#define XRANGEEND XRANGESTART + XRANGELENGTH
using namespace PhosHLTConst;
Bool_t fgAccumulate;
Bool_t fgSyncronize;
AliHLTHOMERReader* fgHomerReaderPtr;
- AliHLTHOMERReader* fgHomerReadersPtr[MAX_HOSTS];
+ AliHLTHOMERReader* fgHomerReadersPtr[MAXHOSTS];
int DoGetNextEvent();
int fgEvntCnt;
int fgNHosts;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff