fBBtriggerV0A(0),
fBGtriggerV0A(0),
fBBtriggerV0C(0),
- fBGtriggerV0C(0)
+ fBGtriggerV0C(0),
+ fV0ATime(-1024),
+ fV0CTime(-1024),
+ fV0ATimeError(0),
+ fV0CTimeError(0),
+ fV0ADecision(kV0Invalid),
+ fV0CDecision(kV0Invalid)
{
// Default constructor
for(Int_t j=0; j<64; j++){
fBBtriggerV0A(o.fBBtriggerV0A),
fBGtriggerV0A(o.fBGtriggerV0A),
fBBtriggerV0C(o.fBBtriggerV0C),
- fBGtriggerV0C(o.fBGtriggerV0C)
+ fBGtriggerV0C(o.fBGtriggerV0C),
+ fV0ATime(o.fV0ATime),
+ fV0CTime(o.fV0CTime),
+ fV0ATimeError(o.fV0ATimeError),
+ fV0CTimeError(o.fV0CTimeError),
+ fV0ADecision(o.fV0ADecision),
+ fV0CDecision(o.fV0CDecision)
{
// Default constructor
for(Int_t j=0; j<64; j++) {
fBBtriggerV0A(BBtriggerV0A),
fBGtriggerV0A(BGtriggerV0A),
fBBtriggerV0C(BBtriggerV0C),
- fBGtriggerV0C(BGtriggerV0C)
-
+ fBGtriggerV0C(BGtriggerV0C),
+ fV0ATime(-1024),
+ fV0CTime(-1024),
+ fV0ATimeError(0),
+ fV0CTimeError(0),
+ fV0ADecision(kV0Invalid),
+ fV0CDecision(kV0Invalid)
{
// Constructor
for(Int_t j=0; j<64; j++) {
fBGtriggerV0A=o.fBGtriggerV0A;
fBBtriggerV0C=o.fBBtriggerV0C;
fBGtriggerV0C=o.fBGtriggerV0C;
+
+ fV0ATime = o.fV0ATime;
+ fV0CTime = o.fV0CTime;
+ fV0ATimeError = o.fV0ATimeError;
+ fV0CTimeError = o.fV0CTimeError;
+ fV0ADecision = o.fV0ADecision;
+ fV0CDecision = o.fV0CDecision;
+
for(Int_t j=0; j<64; j++) {
fMultiplicity[j] = o.fMultiplicity[j];
fAdc[j] = o.fAdc[j];
Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag);
virtual ~AliESDVZERO() {};
+
+ enum {
+ kCorrectedLeadingTime = BIT(14),
+ kTriggerBitsFilled = BIT(15),
+ kDecisionFilled = BIT(16)
+ };
+ enum Decision { kV0Invalid = -1, kV0Empty = 0, kV0BB, kV0BG, kV0Fake };
// Setters
virtual void SetBBtriggerV0A(UInt_t BBtrigger) {fBBtriggerV0A=BBtrigger;}
{for(Int_t i=0;i<64;i++) fBBFlag[i]=BBFlag[i];}
virtual void SetBGFlag(Bool_t BGFlag[64])
{for(Int_t i=0;i<64;i++) fBGFlag[i]=BGFlag[i];}
+
+ void SetV0ATime(Float_t time) {fV0ATime = time;}
+ void SetV0CTime(Float_t time) {fV0CTime = time;}
+ void SetV0ATimeError(Float_t err) {fV0ATimeError = err;}
+ void SetV0CTimeError(Float_t err) {fV0CTimeError = err;}
+
+ void SetV0ADecision(Decision des) {fV0ADecision = des;}
+ void SetV0CDecision(Decision des) {fV0CDecision = des;}
// Getters
Short_t GetNbPMV0A();
Bool_t BGTriggerV0C(Int_t i);
Bool_t GetBBFlag(Int_t i);
Bool_t GetBGFlag(Int_t i);
+
+ Float_t GetV0ATime() const { return fV0ATime; }
+ Float_t GetV0CTime() const { return fV0CTime; }
+ Float_t GetV0ATimeError() const { return fV0ATimeError; }
+ Float_t GetV0CTimeError() const { return fV0CTimeError; }
+
+ Decision GetV0ADecision() const { return fV0ADecision; }
+ Decision GetV0CDecision() const { return fV0CDecision; }
Bool_t OutOfRange(Int_t i, const char *s, Int_t upper) const;
AliESDVZERO &operator=(const AliESDVZERO& source);
Float_t fWidth[64]; // time width for each channel
Bool_t fBBFlag[64]; // BB Flags from Online V0 Electronics
Bool_t fBGFlag[64]; // BG Flags from Online V0 Electronics
-
- ClassDef(AliESDVZERO,7)
+
+ Float_t fV0ATime; // Average time in V0A
+ Float_t fV0CTime; // Average time in V0C
+ Float_t fV0ATimeError; // Error in the average time in V0A
+ Float_t fV0CTimeError; // Error in the average time in V0C
+
+ Decision fV0ADecision; // V0A final decision based on average time of channels
+ Decision fV0CDecision; // V0C final decision based on average time of channels
+
+ ClassDef(AliESDVZERO,8)
};
#endif
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. */
-const Float_t kIntTimeRes = 0.5; // intrinsic time resolution of the scintillator
+const Float_t kIntTimeRes = 0.39; // intrinsic time resolution of the scintillator
const Float_t kV0CDelayCables = 8.1; // delay cables on the C side (in ns)
const Float_t kV0Offset = 1461.4; // general V0 offset between the TDCs and the trigger
const Float_t kADCTimeOffset = -189.0; // ADC sampling clock offset (in ns)
/// //
///////////////////////////////////////////////////////////////////////////////
+#include <TH1F.h>
+#include <TF1.h>
+
#include "AliRunLoader.h"
#include "AliRawReader.h"
#include "AliGRPObject.h"
#include "AliCDBEntry.h"
#include "AliVZEROReconstructor.h"
#include "AliVZERORawStream.h"
+#include "AliVZEROConst.h"
#include "AliESDEvent.h"
#include "AliVZEROTriggerMask.h"
#include "AliESDfriend.h"
#include "AliVZEROdigit.h"
#include "AliVZEROCalibData.h"
#include "AliRunInfo.h"
+#include "AliCTPTimeParams.h"
ClassImp(AliVZEROReconstructor)
fESDVZERO(0x0),
fESD(0x0),
fESDVZEROfriend(0x0),
- fCalibData(GetCalibData()),
+ fCalibData(NULL),
+ fTimeSlewing(NULL),
fCollisionMode(0),
fBeamEnergy(0.),
fDigitsArray(0)
// Default constructor
// Get calibration data
- // fCalibData = GetCalibData();
-
+ fCalibData = GetCalibData();
+
+ AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
+ if (!entry) AliFatal("CTP timing parameters are not found in OCDB !");
+ AliCTPTimeParams *ctpParams = (AliCTPTimeParams*)entry->GetObject();
+ Float_t l1Delay = (Float_t)ctpParams->GetDelayL1L0()*25.0;
+
+ AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeDelays");
+ if (!entry2) AliFatal("VZERO time delays are not found in OCDB !");
+ TH1F *delays = (TH1F*)entry2->GetObject();
+
+ AliCDBEntry *entry3 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeSlewing");
+ if (!entry3) AliFatal("VZERO time slewing function is not found in OCDB !");
+ fTimeSlewing = (TF1*)entry3->GetObject();
+
+ for(Int_t i = 0 ; i < 64; ++i) {
+ Int_t board = AliVZEROCalibData::GetBoardNumber(i);
+ fTimeOffset[i] = (((Float_t)fCalibData->GetTriggerCountOffset(board)-
+ (Float_t)fCalibData->GetRollOver(board))*25.0+
+ fCalibData->GetTimeOffset(i)+
+ l1Delay+
+ delays->GetBinContent(i+1)+
+ kV0Offset);
+ }
}
for (Int_t i=0; i<64; i++){
adc[i] = 0.0;
mult[i] = 0.0;
- time[i] = 0.0;
+ time[i] = kInvalidTime;
width[i] = 0.0;
BBFlag[i] = kFALSE;
BGFlag[i] = kFALSE;
Int_t k = pmNumber+64*integrator;
Float_t pedestal = fCalibData->GetPedestal(k);
adc[pmNumber] = digit->ADC() - pedestal;
- time[pmNumber] = digit->Time();
+ time[pmNumber] = CorrectLeadingTime(pmNumber,digit->Time(),adc[pmNumber]);
width[pmNumber] = digit->Width();
BBFlag[pmNumber]= digit->BBFlag();
BGFlag[pmNumber]= digit->BGFlag();
} // end of loop over digits
} // end of loop over events in digits tree
+ fESDVZERO->SetBit(AliESDVZERO::kCorrectedLeadingTime,kTRUE);
fESDVZERO->SetMultiplicity(mult);
fESDVZERO->SetADC(adc);
fESDVZERO->SetTime(time);
fESDVZERO->SetBBFlag(BBFlag);
fESDVZERO->SetBGFlag(BGFlag);
- // now get the trigger mask
-
- AliVZEROTriggerMask *TriggerMask = new AliVZEROTriggerMask();
- TriggerMask->SetAdcThreshold(10.0/2.0);
- TriggerMask->SetTimeWindowWidthBBA(50);
- TriggerMask->SetTimeWindowWidthBGA(20);
- TriggerMask->SetTimeWindowWidthBBC(50);
- TriggerMask->SetTimeWindowWidthBGC(20);
- TriggerMask->FillMasks(digitsTree, fDigitsArray);
+ // now fill the V0 decision and channel flags
+ {
+ AliVZEROTriggerMask triggerMask;
+ triggerMask.FillMasks(fESDVZERO, fCalibData, fTimeSlewing);
+ }
- fESDVZERO->SetBBtriggerV0A(TriggerMask->GetBBtriggerV0A());
- fESDVZERO->SetBGtriggerV0A(TriggerMask->GetBGtriggerV0A());
- fESDVZERO->SetBBtriggerV0C(TriggerMask->GetBBtriggerV0C());
- fESDVZERO->SetBGtriggerV0C(TriggerMask->GetBGtriggerV0C());
-
if (esd) {
AliDebug(1, Form("Writing VZERO data to ESD tree"));
esd->SetVZEROData(fESDVZERO);
entry = man->Get("VZERO/Calib/Data");
-// if(!entry){
-// AliWarning("Load of calibration data from default storage failed!");
-// AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
-// Int_t runNumber = man->GetRun();
-// entry = man->GetStorage("local://$ALICE_ROOT/OCDB")
-// ->Get("VZERO/Calib/Data",runNumber);
-//
-// }
-
- // Retrieval of data in directory VZERO/Calib/Data:
-
AliVZEROCalibData *calibdata = 0;
if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
return calibdata;
}
+Float_t AliVZEROReconstructor::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
+{
+ // Correct the leading time
+ // for slewing effect and
+ // misalignment of the channels
+ if (time < 1e-6) return kInvalidTime;
+
+ // Channel alignment and general offset subtraction
+ if (i < 32) time -= kV0CDelayCables;
+ time -= fTimeOffset[i];
+
+ // In case of pathological signals
+ if (adc < 1e-6) return time;
+
+ // Slewing correction
+ Float_t thr = fCalibData->GetDiscriThr(i);
+ time -= fTimeSlewing->Eval(adc/thr);
+
+ return time;
+}
#include "AliESDVZERO.h"
#include "AliVZERORecoParam.h"
+class TF1;
class AliVZEROCalibData;
class AliESDEvent;
class AliESDVZEROfriend;
void GetCollisionMode();
AliVZEROCalibData *GetCalibData() const;
+ Float_t CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const;
enum {kInvalidADC = -1024,
- kInvalidTime = -1};
+ kInvalidTime = -1024};
protected:
AliESDVZERO* fESDVZERO; // ESD output object
AliVZEROReconstructor& operator = (const AliVZEROReconstructor& reconstructor);
AliVZEROCalibData* fCalibData; //! calibration data
+ Float_t fTimeOffset[64]; //! HPTDC time offsets channel by channel
+ TF1* fTimeSlewing; //! Function for time slewing correction
Int_t fCollisionMode; // =0->p-p, =1->A-A
Float_t fBeamEnergy; // beam energy
mutable TClonesArray *fDigitsArray; // clones-array for ConvertDigits() and FillESD()
- ClassDef(AliVZEROReconstructor, 1) // class for the VZERO reconstruction
+ ClassDef(AliVZEROReconstructor, 2) // class for the VZERO reconstruction
};
#endif
#include <TGeoManager.h>
#include <TGeoMatrix.h>
#include <TGeoPhysicalNode.h>
-#include <TTree.h>
-#include <TClonesArray.h>
+#include <TF1.h>
+#include <TMath.h>
#include <AliGeomManager.h>
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliCDBEntry.h"
#include "AliLog.h"
#include "AliVZEROTriggerMask.h"
-#include "AliVZEROdigit.h"
+#include "AliVZEROConst.h"
+#include "AliVZEROCalibData.h"
+#include "AliESDVZERO.h"
+#include "AliVZEROReconstructor.h"
//______________________________________________________________________
ClassImp(AliVZEROTriggerMask)
AliVZEROTriggerMask::AliVZEROTriggerMask()
:TObject(),
fAdcThresHold(0.0),
- fTimeWindowWidthBBA(50.0),
- fTimeWindowWidthBGA(20.0),
- fTimeWindowWidthBBC(50.0),
- fTimeWindowWidthBGC(20.0),
- fBBtriggerV0A(0),
- fBGtriggerV0A(0),
- fBBtriggerV0C(0),
- fBGtriggerV0C(0)
-
+ fTimeWindowBBALow(-9.5),
+ fTimeWindowBBAUp(22.5),
+ fTimeWindowBGALow(-2.5),
+ fTimeWindowBGAUp(5.0),
+ fTimeWindowFakeALow(-17.5),
+ fTimeWindowFakeAUp(-9.5),
+ fTimeWindowBBCLow(-2.5),
+ fTimeWindowBBCUp(22.5),
+ fTimeWindowBGCLow(-2.5),
+ fTimeWindowBGCUp(2.5),
+ fTimeWindowFakeCLow(-22.5),
+ fTimeWindowFakeCUp(-8.5),
+ fV0ADist(0),
+ fV0CDist(0)
{
- SetAdcThreshold();
+ // Default constructor
+ //
+ Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A"));
+ Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C"));
+
+ // distance in time units from nominal vertex to V0
+ fV0ADist = zV0A/TMath::Ccgs()*1e9;
+ fV0CDist = zV0C/TMath::Ccgs()*1e9;
}
//________________________________________________________________________________
//
Double_t *tr;
TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
- if (!pne) return 0;
-
+ if (!pne) {
+ AliFatalClass(Form("TGeoPNEntry with symbolic name %s does not exist!",symname));
+ return 0;
+ }
TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
if(pnode){
}else{
const char* path = pne->GetTitle();
if(!gGeoManager->cd(path)){
- AliErrorClass(Form("Volume path %s not valid!",path));
+ AliFatalClass(Form("Volume path %s not valid!",path));
return 0;
}
tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
//________________________________________________________________________________
-void AliVZEROTriggerMask::FillMasks(TTree* vzeroDigitsTree,
- TClonesArray* const vzeroDigits)
+void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
+ AliVZEROCalibData *cal,
+ TF1 *slewing)
{
-// Fill up the trigger mask word using the TDC
-
- const Double_t lightSpeed = 2.9979245800; // cm/100 ps
- Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A"));
- Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C"));
-
- // distance in time units from nominal vertex to V0
- Float_t v0aDist = zV0A/lightSpeed; // 100 of picoseconds
- Float_t v0cDist = zV0C/lightSpeed; // 100 of picoseconds
- Float_t bunchSeparation = 1000.0; // 100 of picoseconds
-
- // mask
- UInt_t one=1;
-
- // loop over vzero entries
- Int_t nEntries = (Int_t)vzeroDigitsTree->GetEntries();
- for (Int_t e=0; e<nEntries; e++) {
- vzeroDigitsTree->GetEvent(e);
-
- Int_t nDigits = vzeroDigits->GetEntriesFast();
-
- for (Int_t d=0; d<nDigits; d++) {
- // vzeroDigitsTree->GetEvent(d);
- AliVZEROdigit* digit = (AliVZEROdigit*)vzeroDigits->At(d);
-
- Int_t pmNumber = digit->PMNumber();
- Float_t adc = digit->ADC();
- Float_t tdc = digit->Time()*10.0; // in 100 of picoseconds
-
- if (adc>fAdcThresHold) {
- if (pmNumber<32) { // in V0C
- if (tdc>(v0cDist-fTimeWindowWidthBBC/2.0) &&
- tdc<(v0cDist+fTimeWindowWidthBBC/2.0))
- fBBtriggerV0C+=(one<<pmNumber);
- if (tdc>(bunchSeparation-v0cDist-fTimeWindowWidthBGC/2.0) &&
- tdc<(bunchSeparation-v0cDist+fTimeWindowWidthBGC/2.0))
- fBGtriggerV0C+=(one<<pmNumber);
+ // Fill up the trigger mask word
+ // using the TDC data (already corrected for
+ // slewing and misalignment between channels)
+
+ esdV0->SetBit(AliESDVZERO::kTriggerBitsFilled,kTRUE);
+ esdV0->SetBit(AliESDVZERO::kDecisionFilled,kTRUE);
+
+ UInt_t aBBtriggerV0A = 0; // bit mask for Beam-Beam trigger in V0A
+ UInt_t aBGtriggerV0A = 0; // bit mask for Beam-Gas trigger in V0A
+ UInt_t aBBtriggerV0C = 0; // bit mask for Beam-Beam trigger in V0C
+ UInt_t aBGtriggerV0C = 0; // bit mask for Beam-Gas trigger in V0C
+
+ const Float_t p1 = 2.19; // photostatistics term in the time resolution
+ const Float_t p2 = 1.31; // slewing related term in the time resolution
+
+ // loop over vzero channels
+ Float_t timeAW = 0,timeCW = 0;
+ Float_t weightA = 0,weightC = 0;
+ Int_t ntimeA = 0, ntimeC = 0;
+ for (Int_t i = 0; i < 64; ++i) {
+ Float_t adc = esdV0->GetAdc(i);
+ if (adc > fAdcThresHold) {
+ Float_t tdc = esdV0->GetTime(i);
+ if (tdc > (AliVZEROReconstructor::kInvalidTime + 1e-6)) {
+ Float_t nphe = adc*kChargePerADC/(cal->GetGain(i)*TMath::Qe());
+ Float_t timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
+ p1*p1/nphe+
+ p2*p2*(slewing->GetParameter(0)*slewing->GetParameter(1))*(slewing->GetParameter(0)*slewing->GetParameter(1))*
+ TMath::Power(adc/cal->GetDiscriThr(i),2.*(slewing->GetParameter(1)-1.)));
+
+ if (i < 32) { // in V0C
+ ntimeC++;
+ timeCW += tdc/(timeErr*timeErr);
+ weightC += 1.0/(timeErr*timeErr);
+
+ if (tdc > (fV0CDist + fTimeWindowBBCLow) &&
+ tdc < (fV0CDist + fTimeWindowBBCUp))
+ aBBtriggerV0C |= (1 << i);
+ if (tdc > (-fV0CDist + fTimeWindowBGCLow) &&
+ tdc < (-fV0CDist + fTimeWindowBGCUp))
+ aBGtriggerV0C |= (1 << i);
}
- if (pmNumber>31) { // in V0A
- Int_t shift = pmNumber-32;
- if (tdc>(v0aDist-fTimeWindowWidthBBA/2.0) &&
- tdc<(v0aDist+fTimeWindowWidthBBA/2.0))
- fBBtriggerV0A+=(one<<shift);
- if (tdc>(bunchSeparation-v0aDist-fTimeWindowWidthBGA/2.0) &&
- tdc<(bunchSeparation-v0aDist+fTimeWindowWidthBGA/2.0))
- fBGtriggerV0A+=(one<<shift);
+ else { // in V0A
+ ntimeA++;
+ timeAW += tdc/(timeErr*timeErr);
+ weightA += 1.0/(timeErr*timeErr);
+
+ Int_t shift = i - 32;
+ if (tdc > (fV0ADist + fTimeWindowBBALow) &&
+ tdc < (fV0ADist + fTimeWindowBBAUp))
+ aBBtriggerV0A |= (1 << shift);
+ if (tdc > (-fV0ADist + fTimeWindowBGALow) &&
+ tdc < (-fV0ADist + fTimeWindowBGAUp))
+ aBGtriggerV0A |= (1 << shift);
}
}
- } // end of loop over digits
- } // end of loop over events in digits tree
+ }
+ } // end of loop over channels
+
+ esdV0->SetBBtriggerV0A(aBBtriggerV0A);
+ esdV0->SetBGtriggerV0A(aBGtriggerV0A);
+ esdV0->SetBBtriggerV0C(aBBtriggerV0C);
+ esdV0->SetBGtriggerV0C(aBGtriggerV0C);
+
+ if (weightA > 0) timeAW = timeAW/weightA;
+ else timeAW = AliVZEROReconstructor::kInvalidTime;
+
+ if (weightC > 0) timeCW = timeCW/weightC;
+ else timeCW = AliVZEROReconstructor::kInvalidTime;
+
+ esdV0->SetV0ATime(timeAW);
+ esdV0->SetV0CTime(timeCW);
+ esdV0->SetV0ATimeError((weightA > 0) ? (1./TMath::Sqrt(weightA)) : 0);
+ esdV0->SetV0ATimeError((weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0);
+
+ esdV0->SetV0ADecision(AliESDVZERO::kV0Empty);
+ esdV0->SetV0CDecision(AliESDVZERO::kV0Empty);
+
+ if (timeAW > (fV0ADist + fTimeWindowBBALow) &&
+ timeAW < (fV0ADist + fTimeWindowBBAUp))
+ esdV0->SetV0ADecision(AliESDVZERO::kV0BB);
+ else if (timeAW > (-fV0ADist + fTimeWindowBGALow) &&
+ timeAW < (-fV0ADist + fTimeWindowBGAUp))
+ esdV0->SetV0ADecision(AliESDVZERO::kV0BG);
+ else if (timeAW > (fV0ADist + fTimeWindowFakeALow) &&
+ timeAW < (fV0ADist + fTimeWindowFakeAUp))
+ esdV0->SetV0ADecision(AliESDVZERO::kV0Fake);
+
+ if (timeCW > (fV0CDist + fTimeWindowBBCLow) &&
+ timeCW < (fV0CDist + fTimeWindowBBCUp))
+ esdV0->SetV0CDecision(AliESDVZERO::kV0BB);
+ else if (timeCW > (-fV0CDist + fTimeWindowBGCLow) &&
+ timeCW < (-fV0CDist + fTimeWindowBGCUp))
+ esdV0->SetV0CDecision(AliESDVZERO::kV0BG);
+ else if (timeCW > (fV0CDist + fTimeWindowFakeCLow) &&
+ timeCW < (fV0CDist + fTimeWindowFakeCUp))
+ esdV0->SetV0CDecision(AliESDVZERO::kV0Fake);
+
}
#include <TObject.h>
class TTree;
class TClonesArray;
+class AliESDVZERO;
+class AliVZEROCalibData;
class AliVZEROTriggerMask : public TObject
{
AliVZEROTriggerMask(); // constructor
virtual ~AliVZEROTriggerMask(){} // destructor
- void FillMasks(TTree* vzeroDigitsTree,
- TClonesArray* const vzeroDigits);
+ void FillMasks(AliESDVZERO *esdV0,
+ AliVZEROCalibData *cal,
+ TF1 *slewing);
Double_t GetZPosition(const char* symname);
- void SetAdcThreshold(Float_t t=55.0)
- {fAdcThresHold=t;}
- void SetTimeWindowWidthBBA(Float_t w=50.0)
- {fTimeWindowWidthBBA=w;}
- void SetTimeWindowWidthBBC(Float_t w=50.0)
- {fTimeWindowWidthBBC=w;}
- void SetTimeWindowWidthBGA(Float_t w=20.0)
- {fTimeWindowWidthBGA=w;}
- void SetTimeWindowWidthBGC(Float_t w=20.0)
- {fTimeWindowWidthBGC=w;}
-
- UInt_t GetBBtriggerV0A() const { return fBBtriggerV0A;}
- UInt_t GetBGtriggerV0A() const { return fBGtriggerV0A;}
- UInt_t GetBBtriggerV0C() const { return fBBtriggerV0C;}
- UInt_t GetBGtriggerV0C() const { return fBGtriggerV0C;}
+ void SetAdcThreshold(Float_t thr)
+ {fAdcThresHold=thr;}
+ void SetTimeWindowBBA(Float_t wlow,Float_t wup)
+ {fTimeWindowBBALow=wlow; fTimeWindowBBAUp=wup;}
+ void SetTimeWindowBBC(Float_t wlow,Float_t wup)
+ {fTimeWindowBBCLow=wlow; fTimeWindowBBCUp=wup;}
+ void SetTimeWindowBGA(Float_t wlow,Float_t wup)
+ {fTimeWindowBGALow=wlow; fTimeWindowBGAUp=wup;}
+ void SetTimeWindowBGC(Float_t wlow,Float_t wup)
+ {fTimeWindowBGCLow=wlow; fTimeWindowBGCUp=wup;}
private:
Float_t fAdcThresHold; // Threshold on the ADC
- Float_t fTimeWindowWidthBBA; // size of the BBA window
- Float_t fTimeWindowWidthBGA; // size of the BGA window
- Float_t fTimeWindowWidthBBC; // size of the BBC window
- Float_t fTimeWindowWidthBGC; // size of the BGC window
- UInt_t fBBtriggerV0A; // bit mask for Beam-Beam trigger in V0A
- UInt_t fBGtriggerV0A; // bit mask for Beam-Gas trigger in V0A
- UInt_t fBBtriggerV0C; // bit mask for Beam-Beam trigger in V0C
- UInt_t fBGtriggerV0C; // bit mask for Beam-Gas trigger in V0C
-
-
- ClassDef( AliVZEROTriggerMask, 1 ) // VZERO Trigger Detector class
+ Float_t fTimeWindowBBALow; // BBA window (lower cut)
+ Float_t fTimeWindowBBAUp; // BBA window (upper cut)
+ Float_t fTimeWindowBGALow; // BGA window (lower cut)
+ Float_t fTimeWindowBGAUp; // BGA window (upper cut)
+ Float_t fTimeWindowFakeALow;// Fake V0A window (lower cut)
+ Float_t fTimeWindowFakeAUp; // Fake V0A window (upper cut)
+ Float_t fTimeWindowBBCLow; // BBC window (lower cut)
+ Float_t fTimeWindowBBCUp; // BBC window (upper cut)
+ Float_t fTimeWindowBGCLow; // BGC window (lower cut)
+ Float_t fTimeWindowBGCUp; // BGC window (upper cut)
+ Float_t fTimeWindowFakeCLow;// Fake V0C window (lower cut)
+ Float_t fTimeWindowFakeCUp; // Fake V0C window (upper cut)
+
+ Float_t fV0ADist; // Z position of V0A
+ Float_t fV0CDist; // Z position of V0C
+
+
+ ClassDef( AliVZEROTriggerMask, 2 ) // VZERO Trigger Detector class
};
#endif // ALIVZEROTRIGGERMASK_H
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff