#include "TBranch.h"
#include "TClonesArray.h"
#include "TStopwatch.h"
+#include "TParameter.h"
// --- AliRoot header files ---
#include "AliRun.h"
#include "AliDAQ.h"
#include "AliRawReader.h"
#include "AliVZERORawStream.h"
+#include "AliVZEROCalibData.h"
ClassImp(AliVZERO)
//__________________________________________________________________
const char *fileName = AliDAQ::DdlFileName("VZERO",0);
AliVZEROBuffer* buffer = new AliVZEROBuffer(fileName);
- // Verbose level
- // 0: Silent
- // 1: cout messages
- // 2: txt files with digits
- // BE CAREFUL, verbose level 2 MUST be used only for debugging and
- // it is highly suggested to use this mode only for debugging digits files
- // reasonably small, because otherwise the size of the txt files can reach
- // quickly several MB wasting time and disk space.
-
- ofstream ftxt;
- buffer->SetVerbose(0);
- Int_t verbose = buffer->GetVerbose();
-
// Get Trigger information first
// Read trigger inputs from trigger-detector object
AliDataLoader * dataLoader = fLoader->GetDigitsDataLoader();
buffer->WriteTriggerScalers();
buffer->WriteBunchNumbers();
- // Now retrieve the channel information: charge+time and
- // dump it into ADC and Time arrays
- // We assume here an ordered (by PMNumber) array of
- // digits!!
+ Int_t aBBflagsV0A = 0;
+ Int_t aBBflagsV0C = 0;
+ Int_t aBGflagsV0A = 0;
+ Int_t aBGflagsV0C = 0;
+
+ if (digits->GetUserInfo()->FindObject("BBflagsV0A")) {
+ aBBflagsV0A = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BBflagsV0A"))->GetVal();
+ }
+ else
+ AliWarning("V0A beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+
+ if (digits->GetUserInfo()->FindObject("BBflagsV0C")) {
+ aBBflagsV0C = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BBflagsV0C"))->GetVal();
+ }
+ else
+ AliWarning("V0C beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+ if (digits->GetUserInfo()->FindObject("BGflagsV0A")) {
+ aBGflagsV0A = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BGflagsV0A"))->GetVal();
+ }
+ else
+ AliWarning("V0A beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+
+ if (digits->GetUserInfo()->FindObject("BGflagsV0C")) {
+ aBGflagsV0C = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BGflagsV0C"))->GetVal();
+ }
+ else
+ AliWarning("V0C beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+
+ // Now retrieve the channel information: charge smaples + time and
+ // dump it into ADC and Time arrays
Int_t nEntries = Int_t(digits->GetEntries());
- Float_t ADC[64];
- Int_t PMNumber[64];
- Float_t Time[64];
- Bool_t Integrator[64];
+ Short_t aADC[64][AliVZEROdigit::kNClocks];
+ Float_t aTime[64];
+ Float_t aWidth[64];
+ Bool_t aIntegrator[64];
+ Bool_t aBBflag[64];
+ Bool_t aBGflag[64];
for (Int_t i = 0; i < nEntries; i++) {
fVZERO->ResetDigits();
Int_t ndig = VZEROdigits->GetEntriesFast();
if(ndig == 0) continue;
- if(verbose == 2) {ftxt.open("VZEROdigits.txt",ios::app);}
for(Int_t k=0; k<ndig; k++){
AliVZEROdigit* fVZERODigit = (AliVZEROdigit*) VZEROdigits->At(k);
// Convert aliroot channel k into FEE channel iChannel before writing data
- Int_t iChannel = buffer->GetOnlineChannel(k);
- ADC[iChannel] = fVZERODigit->ADC();
- PMNumber[iChannel] = fVZERODigit->PMNumber();
- Time[iChannel] = fVZERODigit->Time();
- Integrator[iChannel]= fVZERODigit->Integrator();
- if(verbose == 1) { cout <<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tPM number: "
- <<PMNumber[k]<<"\tADC: "<< ADC[k] << "\tTime: "<< Time[k] << endl;}
- if(verbose == 2) {
- ftxt<<"DDL: "<<fileName<< "\tdigit number: "<< k<<"\tPM number: "
- <<PMNumber[k]<<"\tADC: "<< ADC[k] << "\tTime: "<< Time[k] << endl;}
-// printf("DDL: %s, channel: %d, PM: %d, ADC: %f, Time: %f \n",
-// fileName,k,PMNumber[k],ADC[k],Time[k]);
+ Int_t iChannel = AliVZEROCalibData::GetBoardNumber(fVZERODigit->PMNumber()) * 8 +
+ AliVZEROCalibData::GetFEEChannelNumber(fVZERODigit->PMNumber());
+ for(Int_t iClock = 0; iClock < AliVZEROdigit::kNClocks; ++iClock) aADC[iChannel][iClock] = fVZERODigit->ChargeADC(iClock);
+ aTime[iChannel] = fVZERODigit->Time();
+ aWidth[iChannel] = fVZERODigit->Width();
+ aIntegrator[iChannel]= fVZERODigit->Integrator();
+ if(fVZERODigit->PMNumber() < 32) {
+ aBBflag[iChannel] = (aBBflagsV0C >> fVZERODigit->PMNumber()) & 0x1;
+ aBGflag[iChannel] = (aBGflagsV0C >> fVZERODigit->PMNumber()) & 0x1;
+ }
+ else {
+ aBBflag[iChannel] = (aBBflagsV0A >> (fVZERODigit->PMNumber()-32)) & 0x1;
+ aBGflag[iChannel] = (aBGflagsV0A >> (fVZERODigit->PMNumber()-32)) & 0x1;
+ }
+ AliDebug(1,Form("DDL: %s\tdigit number: %d\tPM number: %d\tADC: %f\tTime: %f",
+ fileName,k,fVZERODigit->PMNumber(),aADC[k],aTime[k]));
}
- if(verbose==2) ftxt.close();
}
// Now fill raw data
for(Int_t iChannel_Offset = iCIU*8; iChannel_Offset < (iCIU*8)+8; iChannel_Offset=iChannel_Offset+4) {
for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
- buffer->WriteChannel(iChannel, (Int_t) ADC[iChannel], Time[iChannel], Integrator[iChannel]);
+ buffer->WriteChannel(iChannel, aADC[iChannel], aIntegrator[iChannel]);
}
- buffer->WriteBeamFlags();
+ buffer->WriteBeamFlags(&aBBflag[iChannel_Offset],&aBGflag[iChannel_Offset]);
buffer->WriteMBInfo();
buffer->WriteMBFlags();
buffer->WriteBeamScalers();
}
-// for(Int_t iChannel=0; iChannel < 8; iChannel++) {
- for(Int_t iChannel=7; iChannel >= 0; iChannel--) {
- buffer->WriteTiming(iChannel, (Int_t) ADC[iChannel], Time[iChannel]);
+
+ for(Int_t iChannel = iCIU*8 + 7; iChannel >= iCIU*8; iChannel--) {
+ buffer->WriteTiming(aTime[iChannel], aWidth[iChannel]);
}
// End of decoding of one CIU card
#include <Riostream.h>
#include <TObjArray.h>
+#include <TMath.h>
+
#include "AliLog.h"
#include "AliRawDataHeaderSim.h"
#include "AliVZEROBuffer.h"
-
-//#include "TFile.h"
-//#include "TTree.h"
+#include "AliVZEROdigit.h"
ClassImp(AliVZEROBuffer)
//_____________________________________________________________________________
AliVZEROBuffer::AliVZEROBuffer():TObject(),
- fVerbose(0),
+ fRemainingWord(0),
f()
{
//
}
//_____________________________________________________________________________
AliVZEROBuffer::AliVZEROBuffer(const char* fileName):TObject(),
- fVerbose(0),
+ fRemainingWord(0),
f()
{
// Constructor
//delete fout;
}
-//_____________________________________________________________________________
-AliVZEROBuffer::AliVZEROBuffer(const AliVZEROBuffer &source):TObject(source),
- fVerbose(0),
- f()
-
-{
- // Copy Constructor
- this->fVerbose=source.fVerbose;
- return;
-}
-
-//_____________________________________________________________________________
-AliVZEROBuffer& AliVZEROBuffer::operator=(const AliVZEROBuffer &source)
-
-{
- //Assigment operator
- this->fVerbose=source.fVerbose;
- return *this;
-}
-
//_____________________________________________________________________________
void AliVZEROBuffer::WriteTriggerInfo(UInt_t trigger) {
// The method writes VZERO trigger information
}
//_____________________________________________________________________________
-void AliVZEROBuffer::WriteChannel(Int_t cell, UInt_t ADC, Float_t /*Time*/, Bool_t integrator){
+void AliVZEROBuffer::WriteChannel(Int_t channel, Short_t *adc, Bool_t integrator){
// It writes VZERO charge information into a raw data file.
// Being called by Digits2Raw
UInt_t data = 0;
+ for(Int_t i = 0; i < AliVZEROdigit::kNClocks; ++i) {
+ if (adc[i] > 1023) {
+ AliWarning(Form("ADC (channel=%d) saturated: %d. Truncating to 1023",channel,adc[i]));
+ adc[i] = 1023;
+ }
+ }
- if (/*ADC < 0 || */ ADC > 1023) {
- AliInfo(Form("ADC saturated: %d. Truncating to 1023",ADC));
- ADC = 1023;
+ if(channel%2 == 0) {
+ for(Int_t i = 0; i < (AliVZEROdigit::kNClocks/2); ++i) {
+ data = (adc[2*i] & 0x3ff);
+ data |= ((integrator & 0x1) << 10);
+
+ data |= ((adc[2*i+1] & 0x3ff) << 16);
+ data |= ((!integrator & 0x1) << 26);
+
+ f->WriteBuffer((char*)&data,sizeof(data));
+ }
+ fRemainingWord = (adc[AliVZEROdigit::kNClocks-1] & 0x3ff);
+ fRemainingWord |= ((integrator & 0x1) << 10);
}
+ else {
+ data = fRemainingWord;
+ data |= ((adc[0] & 0x3ff) << 16);
+ data |= ((integrator & 0x1) << 26);
+ f->WriteBuffer((char*)&data,sizeof(data));
- if(cell%2 == 0)
- // Information about previous 10 interaction
- // Not available in the simulation...
- // Even cell number -- skip 5 words
- { for(Int_t i = 0; i < 5; i++)
- { data = 0;
- f->WriteBuffer((char*)&data,sizeof(data)); }
- data = ADC & 0x3ff;
- data |= (integrator & 0x1) << 10;
- f->WriteBuffer((char*)&data,sizeof(data)); }
- else
- // Information about previous 10 interaction
- // Odd cell number -- skip 4 words and shift ADC by 16 bits
- { for(Int_t i = 0; i < 4; i++)
- { data = 0;
- f->WriteBuffer((char*)&data,sizeof(data)); }
- data = (ADC & 0x3ff) << 16;
- data |= (integrator & 0x1) << 26;
- f->WriteBuffer((char*)&data,sizeof(data)); }
+ for(Int_t i = 1; i <= (AliVZEROdigit::kNClocks/2); ++i) {
+ data = (adc[2*i-1] & 0x3ff);
+ data |= ((!integrator & 0x1) << 10);
+
+ data |= ((adc[2*i] & 0x3ff) << 16);
+ data |= ((integrator & 0x1) << 26);
+
+ f->WriteBuffer((char*)&data,sizeof(data));
+ }
+ }
- data = 0;
- // Information about following 10 interaction
- // Not available in the simulation...
- for(Int_t i = 0; i < 5; i++)
- f->WriteBuffer((char*)&data,sizeof(data));
}
//_____________________________________________________________________________
-void AliVZEROBuffer::WriteBeamFlags() {
+void AliVZEROBuffer::WriteBeamFlags(Bool_t *bbFlag, Bool_t *bgFlag) {
// The method writes information about
// the Beam-Beam and Beam-Gas flags i.e.
// 6 words for the 4 channels
// of half a CIU card
-
- for(Int_t i = 0; i < 6; i++) {
+ // Beam-beam and beam-gas flags are available
+ // only for the triggered event-of-interest (sample index = 10)
+ // As soon as trigger simulation would become more complex
+ // and would allow to simulate neighbouring samples, this code
+ // should be extended in order to fill all (or fraction) of the
+ // flags
+ for(Int_t i = 0; i < 2; i++) {
UInt_t data = 0;
f->WriteBuffer((char*)&data,sizeof(data));
}
+ {
+ UInt_t data = 0;
+ for(Int_t iChannel = 0; iChannel < 4; ++iChannel) {
+ if (bbFlag[iChannel]) data |= (1 << (2*iChannel + 16));
+ if (bgFlag[iChannel]) data |= (1 << (2*iChannel + 17));
+ }
+ f->WriteBuffer((char*)&data,sizeof(data));
+ }
+ for(Int_t i = 0; i < 3; i++) {
+ UInt_t data = 0;
+ f->WriteBuffer((char*)&data,sizeof(data));
+ }
+
}
}
//_____________________________________________________________________________
-void AliVZEROBuffer::WriteTiming(Int_t /*cell*/, UInt_t /* ADC*/, Float_t Time){
+void AliVZEROBuffer::WriteTiming(Float_t time, Float_t width) {
// It writes the timing information into a raw data file.
// Being called by Digits2Raw
- UInt_t data = 0;
- Int_t coarse1, coarse2, fine;
-
// Writes the timing information
-// data = Time & 0xfff;
-
- coarse1 = int( Time/25.0 );
- coarse2 = int( (Time - 25*coarse1)/(25.0/8.0) );
- fine = int( (Time - 25*coarse1 -(25.0/8.0)*coarse2)/(25.0/256.0) );
-
- data = (coarse1 & 0xf) << 8;
- data |= (coarse2 & 0x7) << 5;
- data |= (fine & 0x1f);
-
- // The signal width is not available the digits!
- // To be added soon
- // data |= (width & 0x7f) << 12;
+ UInt_t data = TMath::Nint(time/(25.0/256.0)) & 0xfff;
+ data |= (TMath::Nint(width/(25./64.)) & 0x7f) << 12;
f->WriteBuffer((char*)&data,sizeof(data));
}
AliVZEROBuffer();
AliVZEROBuffer(const char* fileName); //constructor
virtual ~AliVZEROBuffer(); //destructor
- AliVZEROBuffer(const AliVZEROBuffer &source); // copy constructor
- AliVZEROBuffer& operator=(const AliVZEROBuffer &source); // ass. op.
void WriteTriggerInfo(UInt_t trigger);
void WriteTriggerScalers();
void WriteBunchNumbers();
- void WriteChannel(Int_t cell,UInt_t ADC, Float_t Time, Bool_t integrator);
- void WriteBeamFlags();
+ void WriteChannel(Int_t channel, Short_t *adc, Bool_t integrator);
+ void WriteBeamFlags(Bool_t *bbFlag, Bool_t *bgFlag);
void WriteMBInfo();
void WriteMBFlags();
void WriteBeamScalers();
- void WriteTiming(Int_t cell,UInt_t ADC, Float_t Time);
-
- void SetVerbose(Int_t val){fVerbose=val;}
- Int_t GetVerbose() const{return fVerbose;}
-
-// Getter of Online channel number (as defined in the FEE readout) from the
-// Offline channel (as defined by aliroot numbering convention):
- Int_t GetOnlineChannel(Int_t channel) const
- { Int_t fOnlineChannel[64] = {39, 38, 37, 36, 35, 34, 33, 32,
- 47, 46, 45, 44, 43, 42, 41, 40,
- 55, 54, 53, 52, 51, 50, 49, 48,
- 63, 62, 61, 60, 59, 58, 57, 56,
- 7, 6, 5, 4, 3, 2, 1, 0,
- 15, 14, 13, 12, 11, 10, 9, 8,
- 23, 22, 21, 20, 19, 18, 17, 16,
- 31, 30, 29, 28, 27, 26, 25, 24};
- return fOnlineChannel[channel]; }
-
+ void WriteTiming(Float_t time, Float_t width);
+
private:
- Int_t fVerbose; //Verbosity level: 0-silent, 1:cout msg, 2: txt files for checking
+ AliVZEROBuffer(const AliVZEROBuffer &source); // copy constructor
+ AliVZEROBuffer& operator=(const AliVZEROBuffer &source); // ass. op.
+
+ UInt_t fRemainingWord; // Remaining data word between even and odd channel's data
AliFstream* f; //The IO file name
- ClassDef(AliVZEROBuffer,1)
+ ClassDef(AliVZEROBuffer,2)
};
#endif
Float_t thr = fCalibData->GetDiscriThr(ipmt)*kChargePerADC*maximum*fBinSize[ipmt]/integral2;
Bool_t ltFound = kFALSE, ttFound = kFALSE;
for (Int_t iBin = 0; iBin < fNBins[ipmt]; ++iBin) {
- Float_t t = fBinSize[ipmt]*Float_t(iBin+0.5);
+ Float_t t = fBinSize[ipmt]*Float_t(iBin);
if (fTime[ipmt][iBin] > thr) {
if (!ltFound && (iBin < fNBinsLT[ipmt])) {
ltFound = kTRUE;
TClonesArray &ldigits = *fDigits;
- new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time,width,kFALSE,kFALSE,integrator,chargeADC,labels);
+ new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time,width,integrator,chargeADC,labels);
}
//____________________________________________________________________________
}
-// for(Int_t iChannel = iCIU*8; iChannel < (iCIU*8) + 8; iChannel++) {
-// In fact times are stored the other way around in raw data...
- for(Int_t iChannel = (iCIU*8) + 7; iChannel >= iCIU*8; iChannel--) {
- UInt_t time = GetNextWord();
- Float_t coarse1 = 25. * ((time >> 8) & 0xf );
- Float_t coarse2 = 25. / 8. * ((time >> 5) & 0x7 );
- Float_t fine = 25. / 256. * (time & 0x1f);
- // fTime[iChannel] = time & 0xfff;
- fTime[iChannel] = coarse1 + coarse2 + fine;
- fWidth[iChannel] = 0.4 * ( (time >> 12) & 0x7f); // HPTDC used in pairing mode
+ for(Int_t iChannel = (iCIU*8) + 7; iChannel >= iCIU*8; iChannel--) {
+ UInt_t time = GetNextWord();
+ Float_t coarse1 = 25. * ((time >> 8) & 0xf );
+ Float_t coarse2 = 25. / 8. * ((time >> 5) & 0x7 );
+ Float_t fine = 25. / 256. * (time & 0x1f);
+
+ fTime[iChannel] = coarse1 + coarse2 + fine;
+ fWidth[iChannel] = 0.4 * ( (time >> 12) & 0x7f); // HPTDC used in pairing mode
}
// End of decoding of one CIU card
#include <TH1F.h>
#include <TF1.h>
+#include <TParameter.h>
#include "AliRunLoader.h"
#include "AliRawReader.h"
Float_t adc[64];
Float_t time[64], width[64];
Bool_t BBFlag[64], BGFlag[64], integrator[64];
+ Short_t chargeADC[64][21];
for(Int_t i=0; i<64; i++) {
Int_t j = rawStream.GetOfflineChannel(i);
adc[j] = 0.0;
Int_t imax = -1;
Float_t adcPedSub[21];
for(Int_t iClock=0; iClock<21; iClock++){
+ chargeADC[j][iClock] = (Short_t)rawStream.GetPedestal(i,iClock);
Bool_t iIntegrator = rawStream.GetIntegratorFlag(i,iClock);
Int_t k = j+64*iIntegrator;
adcPedSub[iClock] = rawStream.GetPedestal(i,iClock) - fCalibData->GetPedestal(k);
fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch));
+ Int_t aBBflagsV0A = 0;
+ Int_t aBBflagsV0C = 0;
+ Int_t aBGflagsV0A = 0;
+ Int_t aBGflagsV0C = 0;
+
// Channels(aliroot numbering) will be ordered in the tree
for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
+ if(iChannel<32) {
+ if (BBFlag[iChannel]) aBBflagsV0C |= (1 << iChannel);
+ if (BGFlag[iChannel]) aBGflagsV0C |= (1 << iChannel);
+ } else {
+ if (BBFlag[iChannel]) aBBflagsV0A |= (1 << (iChannel-32));
+ if (BGFlag[iChannel]) aBGflagsV0A |= (1 << (iChannel-32));
+ }
if(fCalibData->IsChannelDead(iChannel)){
adc[iChannel] = (Float_t) kInvalidADC;
time[iChannel] = (Float_t) kInvalidTime;
if (adc[iChannel] > 0)
new ((*fDigitsArray)[fDigitsArray->GetEntriesFast()])
AliVZEROdigit(iChannel, adc[iChannel], time[iChannel],
- width[iChannel], BBFlag[iChannel], BGFlag[iChannel],integrator[iChannel]);
+ width[iChannel],integrator[iChannel],
+ chargeADC[iChannel]);
}
+
+ // Store the BB and BG flags in the digits tree (user info)
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsV0A",aBBflagsV0A));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BBflagsV0C",aBBflagsV0C));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsV0A",aBGflagsV0A));
+ digitsTree->GetUserInfo()->Add(new TParameter<int>("BGflagsV0C",aBGflagsV0C));
+
digitsTree->Fill();
}
Float_t adc[64];
Float_t time[64];
Float_t width[64];
- Bool_t BBFlag[64];
- Bool_t BGFlag[64];
+ Bool_t aBBflag[64];
+ Bool_t aBGflag[64];
for (Int_t i=0; i<64; i++){
adc[i] = 0.0;
mult[i] = 0.0;
time[i] = kInvalidTime;
width[i] = 0.0;
- BBFlag[i] = kFALSE;
- BGFlag[i] = kFALSE;
+ aBBflag[i] = kFALSE;
+ aBGflag[i] = kFALSE;
}
- // loop over VZERO entries to get multiplicity
+ Int_t aBBflagsV0A = 0;
+ Int_t aBBflagsV0C = 0;
+ Int_t aBGflagsV0A = 0;
+ Int_t aBGflagsV0C = 0;
+
+ if (digitsTree->GetUserInfo()->FindObject("BBflagsV0A")) {
+ aBBflagsV0A = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BBflagsV0A"))->GetVal();
+ }
+ else
+ AliWarning("V0A beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+
+ if (digitsTree->GetUserInfo()->FindObject("BBflagsV0C")) {
+ aBBflagsV0C = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BBflagsV0C"))->GetVal();
+ }
+ else
+ AliWarning("V0C beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+
+ if (digitsTree->GetUserInfo()->FindObject("BGflagsV0A")) {
+ aBGflagsV0A = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BGflagsV0A"))->GetVal();
+ }
+ else
+ AliWarning("V0A beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+
+ if (digitsTree->GetUserInfo()->FindObject("BGflagsV0C")) {
+ aBGflagsV0C = ((TParameter<int>*)digitsTree->GetUserInfo()->FindObject("BGflagsV0C"))->GetVal();
+ }
+ else
+ AliWarning("V0C beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
+
+
Int_t nEntries = (Int_t)digitsTree->GetEntries();
for (Int_t e=0; e<nEntries; e++) {
digitsTree->GetEvent(e);
adc[pmNumber] = digit->ADC() - pedestal;
time[pmNumber] = CorrectLeadingTime(pmNumber,digit->Time(),adc[pmNumber]);
width[pmNumber] = digit->Width();
- BBFlag[pmNumber]= digit->BBFlag();
- BGFlag[pmNumber]= digit->BGFlag();
-
- AliDebug(2,Form("PM = %d ADC = %f TDC %f",pmNumber, digit->ADC(),digit->Time()));
+ if(pmNumber < 32) {
+ aBBflag[pmNumber] = (aBBflagsV0C >> pmNumber) & 0x1;
+ aBGflag[pmNumber] = (aBGflagsV0C >> pmNumber) & 0x1;
+ }
+ else {
+ aBBflag[pmNumber] = (aBBflagsV0A >> (pmNumber-32)) & 0x1;
+ aBGflag[pmNumber] = (aBGflagsV0A >> (pmNumber-32)) & 0x1;
+ }
+
+ if (adc[pmNumber] > 0) AliDebug(1,Form("PM = %d ADC = %f TDC %f Int %d (%d %d %d %d %d) %f %f %f %f %d %d",pmNumber, adc[pmNumber],digit->Time(),
+ integrator,
+ digit->ChargeADC(8),digit->ChargeADC(9),digit->ChargeADC(10),
+ digit->ChargeADC(11),digit->ChargeADC(12),
+ fCalibData->GetPedestal(pmNumber),fCalibData->GetSigma(pmNumber),
+ fCalibData->GetPedestal(pmNumber+64),fCalibData->GetSigma(pmNumber+64),
+ aBBflag[pmNumber],aBGflag[pmNumber]));
if(adc[pmNumber] > (fCalibData->GetPedestal(k) + GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k))) {
mult[pmNumber] += adc[pmNumber]*fCalibData->GetMIPperADC(pmNumber);
fESDVZERO->SetADC(adc);
fESDVZERO->SetTime(time);
fESDVZERO->SetWidth(width);
- fESDVZERO->SetBBFlag(BBFlag);
- fESDVZERO->SetBGFlag(BGFlag);
+ fESDVZERO->SetBBFlag(aBBflag);
+ fESDVZERO->SetBGFlag(aBGflag);
// now fill the V0 decision and channel flags
{
fADC(0.),
fTime(0.),
fWidth(0.),
- fBBFlag(0),
- fBGFlag(0),
fIntegrator(0)
{
fADC(adc),
fTime(time),
fWidth(0.),
- fBBFlag(0),
- fBGFlag(0),
fIntegrator(0)
{
// Constructor
//__________________________________________________________________________
AliVZEROdigit::AliVZEROdigit(Int_t PMnumber, Float_t adc, Float_t time,
- Float_t width, Bool_t BeamBeamFlag, Bool_t BeamGasFlag,
+ Float_t width,
Bool_t integrator,
Short_t *chargeADC,
Int_t *labels)
fADC(adc),
fTime(time),
fWidth(width),
-fBBFlag(BeamBeamFlag),
-fBGFlag(BeamGasFlag),
fIntegrator(integrator)
{
// Constructor
AliVZEROdigit();
AliVZEROdigit(Int_t PMnumber, Float_t adc, Float_t time);
AliVZEROdigit(Int_t PMnumber, Float_t adc, Float_t time,
- Float_t TimeWidth, Bool_t BBFlag, Bool_t BGFlag,
+ Float_t TimeWidth,
Bool_t Integrator,
Short_t *chargeADC = 0,
Int_t *labels = 0);
Float_t ADC() const {return fADC;}
Float_t Time() const {return fTime;}
Float_t Width() const {return fWidth;}
- Bool_t BBFlag() const {return fBBFlag;}
- Bool_t BGFlag() const {return fBGFlag;}
Bool_t Integrator() const {return fIntegrator;}
Short_t ChargeADC(Int_t clock) const {return (clock >= 0 && clock < kNClocks) ? fChargeADC[clock] : 0;}
Float_t fADC; // ADC response
Float_t fTime; // Time of Flight
Float_t fWidth; // Width of the time distribution
- Bool_t fBBFlag; // Beam-Beam Flag given by Yannick in Raw Data only
- Bool_t fBGFlag; // Beam-Gas Flag given by Yannick in Raw Data only
Bool_t fIntegrator; // Integrator used
Short_t fChargeADC[kNClocks]; // ADC samples as present in raw data
- ClassDef(AliVZEROdigit,4) // VZERO Digit class
+ ClassDef(AliVZEROdigit,5) // VZERO Digit class
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff