#include <AliESDEvent.h>
#include <AliESDVertex.h>
#include <AliVertexerTracks.h>
+#include <AliMultiplicity.h>
#include <AliGenEventHeader.h>
#include <AliGenPythiaEventHeader.h>
#include <AliGenCocktailEventHeader.h>
#include <AliGenDPMjetEventHeader.h>
+#include <AliESDVZERO.h>
//____________________________________________________________________
ClassImp(AliPWG0Helper)
Int_t AliPWG0Helper::fgLastProcessType = -1;
//____________________________________________________________________
-Bool_t AliPWG0Helper::IsEventTriggered(const AliESD* aEsd, Trigger trigger)
+Bool_t AliPWG0Helper::IsEventTriggered(const AliESDEvent* aEsd, Trigger trigger)
{
- // see function with ULong64_t argument
+ // checks if an event has been triggered
+ // this function implements the "offline" methods that use the ESD, other trigger requests are passed to the function prototype with ULong_t
- ULong64_t triggerMask = aEsd->GetTriggerMask();
- return IsEventTriggered(triggerMask, trigger);
+ Int_t firedChips = 0;
+ Bool_t v0A = kFALSE;
+ Bool_t v0C = kFALSE;
+
+ // offline triggers have to be dealt with here, because we need the esd pointer
+ if (trigger == kOfflineFASTOR || trigger == kOfflineMB1 || trigger == kOfflineMB2 || trigger == kOfflineMB3)
+ {
+ const AliMultiplicity* mult = aEsd->GetMultiplicity();
+ if (!mult)
+ {
+ Printf("AliPWG0Helper::IsEventTriggered: ERROR: AliMultiplicity not available");
+ return kFALSE;
+ }
+ firedChips = mult->GetNumberOfFiredChips(0) + mult->GetNumberOfFiredChips(1);
+ }
+ if (trigger == kOfflineMB1 || trigger == kOfflineMB2 || trigger == kOfflineMB3)
+ {
+ AliESDVZERO* v0Data = aEsd->GetVZEROData();
+ if (!v0Data)
+ {
+ Printf("AliPWG0Helper::IsEventTriggered: ERROR: AliESDVZERO not available");
+ return kFALSE;
+ }
+ for (Int_t i=0; i<32; i++)
+ {
+ if (v0Data->BBTriggerV0A(i))
+ v0A = kTRUE;
+ if (v0Data->BBTriggerV0C(i))
+ v0C = kTRUE;
+ }
+ }
+
+ switch (trigger)
+ {
+ case kOfflineFASTOR:
+ {
+ if (firedChips > 0)
+ return kTRUE;
+ break;
+ }
+ case kOfflineMB1:
+ {
+ if ((firedChips > 0) || v0A || v0C)
+ return kTRUE;
+ break;
+ }
+ case kOfflineMB2:
+ {
+ if ((firedChips > 0) && (v0A || v0C))
+ return kTRUE;
+ break;
+ }
+ case kOfflineMB3:
+ {
+ if ((firedChips > 0) && v0A && v0C)
+ return kTRUE;
+ break;
+ }
+ default:
+ {
+ return IsEventTriggered(aEsd->GetTriggerMask(), trigger);
+ break;
+ }
+ }
+
+ return kFALSE;
}
//____________________________________________________________________
// definitions from p-p.cfg
ULong64_t spdFO = (1 << 14);
- ULong64_t v0left = (1 << 11);
- ULong64_t v0right = (1 << 12);
+ ULong64_t v0left = (1 << 10);
+ ULong64_t v0right = (1 << 11);
switch (trigger)
{
return kTRUE;
break;
}
+ case kMB3:
+ {
+ if (triggerMask & spdFO && (triggerMask & v0left) && (triggerMask & v0right))
+ return kTRUE;
+ break;
+ }
case kSPDFASTOR:
{
if (triggerMask & spdFO)
return kTRUE;
break;
}
+ default:
+ Printf("IsEventTriggered: ERROR: Trigger type %d not implemented in this method", (Int_t) trigger);
+ break;
}
return kFALSE;
}
//____________________________________________________________________
-const AliESDVertex* AliPWG0Helper::GetVertex(AliESDEvent* aEsd, AnalysisMode analysisMode, Bool_t debug,Bool_t bRedoTPC)
+Bool_t AliPWG0Helper::TestVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug)
+{
+ // Checks if a vertex meets the needed quality criteria
+
+ Float_t requiredZResolution = -1;
+ if (analysisMode == kSPD || analysisMode == kTPCITS)
+ {
+ requiredZResolution = 0.1;
+ }
+ else if (analysisMode == kTPC)
+ requiredZResolution = 10.;
+
+ // check resolution
+ Double_t zRes = vertex->GetZRes();
+
+ if (zRes > requiredZResolution) {
+ if (debug)
+ Printf("AliPWG0Helper::TestVertex: Resolution too poor %f (required: %f", zRes, requiredZResolution);
+ return kFALSE;
+ }
+
+ return kTRUE;
+}
+
+//____________________________________________________________________
+const AliESDVertex* AliPWG0Helper::GetVertex(AliESDEvent* aEsd, AnalysisMode analysisMode, Bool_t debug, Bool_t bRedoTPC)
{
// Get the vertex from the ESD and returns it if the vertex is valid
//
// also the quality criteria that are applied)
const AliESDVertex* vertex = 0;
- Float_t requiredZResolution = -1;
if (analysisMode == kSPD || analysisMode == kTPCITS)
{
vertex = aEsd->GetPrimaryVertexSPD();
- requiredZResolution = 0.1;
if (debug)
Printf("AliPWG0Helper::GetVertex: Returning SPD vertex");
}
- else if (analysisMode == kTPC)
+ else if (analysisMode == kTPC)
{
if(bRedoTPC){
- Double_t kBz = aEsd->GetMagneticField();
+ if (debug)
+ Printf("AliPWG0Helper::GetVertex: Redoing vertex");
+ Double_t kBz = aEsd->GetMagneticField();
AliVertexerTracks vertexer(kBz);
- vertexer.SetTPCMode();
+ vertexer.SetTPCMode();
AliESDVertex *vTPC = vertexer.FindPrimaryVertex(aEsd);
aEsd->SetPrimaryVertexTPC(vTPC);
for (Int_t i=0; i<aEsd->GetNumberOfTracks(); i++) {
AliESDtrack *t = aEsd->GetTrack(i);
t->RelateToVertexTPC(vTPC, kBz, kVeryBig);
- }
+ }
delete vTPC;
}
vertex = aEsd->GetPrimaryVertexTPC();
- requiredZResolution = 10.;
if (debug)
Printf("AliPWG0Helper::GetVertex: Returning vertex from tracks");
}
if (debug){
Printf("AliPWG0Helper::GetVertex: NContributors() <= 0: %d",vertex->GetNContributors());
Printf("AliPWG0Helper::GetVertex: NIndices(): %d",vertex->GetNIndices());
-
+ vertex->Print();
}
return 0;
}
// check resolution
Double_t zRes = vertex->GetZRes();
-
- if (zRes == 0 || zRes > requiredZResolution) {
- if (debug)
- Printf("AliPWG0Helper::GetVertex: Resolution too poor %f (required: %f", zRes, requiredZResolution);
+ if (zRes == 0) {
+ Printf("AliPWG0Helper::GetVertex: UNEXPECTED: resolution is 0.");
return 0;
}
{
case kMB1 : str += "MB1"; break;
case kMB2 : str += "MB2"; break;
+ case kMB3 : str += "MB3"; break;
case kSPDFASTOR : str += "SPD FASTOR"; break;
+ case kOfflineMB1 : str += "Offline MB1"; break;
+ case kOfflineMB2 : str += "Offline MB2"; break;
+ case kOfflineMB3 : str += "Offline MB3"; break;
+ case kOfflineFASTOR : str += "Offline SPD FASTOR"; break;
}
str += " <<<<";
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff