#include <AliGenDPMjetEventHeader.h>
#include <AliESDVZERO.h>
-#include <AliOfflineTrigger.h>
-
//____________________________________________________________________
ClassImp(AliPWG0Helper)
Int_t AliPWG0Helper::fgLastProcessType = -1;
-AliOfflineTrigger* AliPWG0Helper::fgOfflineTrigger = 0;
-
-//____________________________________________________________________
-AliOfflineTrigger* AliPWG0Helper::GetOfflineTrigger()
-{
- // returns the current AliOfflineTrigger object
- // creates one if needed
-
- if (!fgOfflineTrigger)
- fgOfflineTrigger = new AliOfflineTrigger;
-
- return fgOfflineTrigger;
-}
-
-//____________________________________________________________________
-Bool_t AliPWG0Helper::IsEventTriggered(const AliESDEvent* aEsd, Trigger trigger)
-{
- // checks if an event has been triggered
-
- if (trigger & kOfflineFlag)
- return GetOfflineTrigger()->IsEventTriggered(aEsd, trigger);
-
- return IsEventTriggered(aEsd->GetTriggerMask(), trigger);
-}
-
-//____________________________________________________________________
-Bool_t AliPWG0Helper::IsEventTriggered(ULong64_t triggerMask, Trigger trigger)
-{
- // check if the event was triggered
- //
- // this function needs the branch fTriggerMask
-
- // definitions from p-p.cfg
- ULong64_t spdFO = (1 << 14);
- ULong64_t v0left = (1 << 10);
- ULong64_t v0right = (1 << 11);
-
- switch (trigger)
- {
- case kAcceptAll:
- {
- return kTRUE;
- break;
- }
- case kMB1:
- {
- if (triggerMask & spdFO || ((triggerMask & v0left) || (triggerMask & v0right)))
- return kTRUE;
- break;
- }
- case kMB2:
- {
- if (triggerMask & spdFO && ((triggerMask & v0left) || (triggerMask & v0right)))
- return kTRUE;
- break;
- }
- case kMB3:
- {
- if (triggerMask & spdFO && (triggerMask & v0left) && (triggerMask & v0right))
- return kTRUE;
- break;
- }
- case kSPDGFO:
- {
- if (triggerMask & spdFO)
- return kTRUE;
- break;
- }
- default:
- Printf("IsEventTriggered: ERROR: Trigger type %d not implemented in this method", (Int_t) trigger);
- break;
- }
-
- return kFALSE;
-}
//____________________________________________________________________
Bool_t AliPWG0Helper::TestVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug)
}
//____________________________________________________________________
-const char* AliPWG0Helper::GetTriggerName(Trigger trigger)
-{
- // returns the name of the requested trigger
- // the returned string will only be valid until the next call to this function [not thread-safe]
-
- static TString str;
-
- UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
-
- switch (triggerNoFlags)
- {
- case kAcceptAll : str = "ACCEPT ALL (bypass!)"; break;
- case kMB1 : str = "MB1"; break;
- case kMB2 : str = "MB2"; break;
- case kMB3 : str = "MB3"; break;
- case kSPDGFO : str = "SPD GFO"; break;
- case kV0A : str = "V0 A"; break;
- case kV0C : str = "V0 C"; break;
- case kZDC : str = "ZDC"; break;
- case kZDCA : str = "ZDC A"; break;
- case kZDCC : str = "ZDC C"; break;
- case kFMDA : str = "FMD A"; break;
- case kFMDC : str = "FMD C"; break;
- case kFPANY : str = "SPD GFO | V0 | ZDC | FMD"; break;
- default: str = ""; break;
- }
-
- if (trigger & kOfflineFlag)
- str += " OFFLINE";
-
- return str;
-}
-
-//____________________________________________________________________
-void AliPWG0Helper::PrintConf(AnalysisMode analysisMode, Trigger trigger)
+void AliPWG0Helper::PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger)
{
//
// Prints the given configuration
str += " (WITHOUT field)";
str += "< and trigger >";
- str += GetTriggerName(trigger);
+ str += AliTriggerAnalysis::GetTriggerName(trigger);
str += "< <<<<";
Printf("%s", str.Data());
#define ALIPWG0HELPER_H
#include <TObject.h>
+#include <AliTriggerAnalysis.h>
// static helper functions
class AliPWG0Helper : public TObject
{
public:
- enum Trigger { kAcceptAll = 1, kMB1 = 2, kMB2, kMB3, kSPDGFO, kV0A, kV0C, kZDC, kZDCA, kZDCC, kFMDA, kFMDC, kFPANY, kStartOfFlags = 0x0100, kOfflineFlag = 0x8000 }; // MB1, MB2, MB3 definition from ALICE-INT-2005-025
enum AnalysisMode { kInvalid = -1, kSPD = 0x1, kTPC = 0x2, kTPCITS = 0x4, kFieldOn = 0x8 };
// in case we want to use bitmaps...
enum MCProcessType { kInvalidProcess = -1, kND = 0x1, kDD = 0x2, kSD = 0x4 };
- static Bool_t IsEventTriggered(const AliESDEvent* aEsd, Trigger trigger);
- static Bool_t IsEventTriggered(ULong64_t triggerMask, Trigger trigger);
static const AliESDVertex* GetVertex(AliESDEvent* aEsd, AnalysisMode analysisMethod, Bool_t debug = kFALSE, Bool_t bRedoTPC = kFALSE);
static Bool_t TestVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug = kFALSE);
static void NormalizeToBinWidth(TH1* hist);
static void NormalizeToBinWidth(TH2* hist);
- static const char* GetTriggerName(Trigger trigger);
- static void PrintConf(AnalysisMode analysisMode, Trigger trigger);
+ static void PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger);
- static AliOfflineTrigger* GetOfflineTrigger();
-
protected:
static Int_t fgLastProcessType; // stores the raw value of the last process type extracnted
- static AliOfflineTrigger* fgOfflineTrigger; // class that implemenents the offline trigger logic
ClassDef(AliPWG0Helper, 0)
-/* $Id: AliOfflineTrigger.cxx 35782 2009-10-22 11:54:31Z jgrosseo $ */
+/* $Id: AliTriggerAnalysis.cxx 35782 2009-10-22 11:54:31Z jgrosseo $ */
/**************************************************************************
* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
**************************************************************************/
//-------------------------------------------------------------------------
-// Implementation of Class AliOfflineTrigger
-// This class provides offline triggers from data in the ESD
+// Implementation of Class AliTriggerAnalysis
+// This class provides function to check if events have been triggered based on the data in the ESD
+// The trigger bits, trigger class inputs and only the data (offline trigger) can be used
// Origin: Jan Fiete Grosse-Oetringhaus, CERN
//-------------------------------------------------------------------------
+#include <Riostream.h>
#include <TH1F.h>
#include <TList.h>
#include <TIterator.h>
-#include <AliOfflineTrigger.h>
+#include <AliTriggerAnalysis.h>
#include <AliLog.h>
#include <AliESDZDC.h>
#include <AliESDFMD.h>
-ClassImp(AliOfflineTrigger)
+ClassImp(AliTriggerAnalysis)
-AliOfflineTrigger::AliOfflineTrigger() :
+AliTriggerAnalysis::AliTriggerAnalysis() :
fSPDGFOThreshold(1),
fV0AThreshold(1),
fV0CThreshold(1),
{
}
-void AliOfflineTrigger::EnableHistograms()
+void AliTriggerAnalysis::EnableHistograms()
{
// creates the monitoring histograms
fHistFMDSum = new TH1F("fHistFMDSum", "FMD sum;multiplicity value;counts", 1000, 0, 10);
}
-Bool_t AliOfflineTrigger::IsEventTriggered(const AliESDEvent* aEsd, AliPWG0Helper::Trigger trigger) const
+//____________________________________________________________________
+const char* AliTriggerAnalysis::GetTriggerName(Trigger trigger)
+{
+ // returns the name of the requested trigger
+ // the returned string will only be valid until the next call to this function [not thread-safe]
+
+ static TString str;
+
+ UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
+
+ switch (triggerNoFlags)
+ {
+ case kAcceptAll : str = "ACCEPT ALL (bypass!)"; break;
+ case kMB1 : str = "MB1"; break;
+ case kMB2 : str = "MB2"; break;
+ case kMB3 : str = "MB3"; break;
+ case kSPDGFO : str = "SPD GFO"; break;
+ case kV0A : str = "V0 A"; break;
+ case kV0C : str = "V0 C"; break;
+ case kZDC : str = "ZDC"; break;
+ case kZDCA : str = "ZDC A"; break;
+ case kZDCC : str = "ZDC C"; break;
+ case kFMDA : str = "FMD A"; break;
+ case kFMDC : str = "FMD C"; break;
+ case kFPANY : str = "SPD GFO | V0 | ZDC | FMD"; break;
+ default: str = ""; break;
+ }
+
+ if (trigger & kOfflineFlag)
+ str += " OFFLINE";
+
+ return str;
+}
+
+Bool_t AliTriggerAnalysis::IsTriggerFired(const AliESDEvent* aEsd, Trigger trigger) const
+{
+ // checks if an event has been triggered
+
+ if (trigger & kOfflineFlag)
+ return IsOfflineTriggerFired(aEsd, trigger);
+
+ return IsTriggerBitFired(aEsd, trigger);
+}
+
+Bool_t AliTriggerAnalysis::IsTriggerBitFired(const AliESDEvent* aEsd, Trigger trigger) const
+{
+ // checks if an event is fired using the trigger bits
+
+ return IsTriggerBitFired(aEsd->GetTriggerMask(), trigger);
+}
+
+Bool_t AliTriggerAnalysis::IsTriggerBitFired(ULong64_t triggerMask, Trigger trigger) const
+{
+ // checks if an event is fired using the trigger bits
+ //
+ // this function needs the branch TriggerMask in the ESD
+
+ // definitions from p-p.cfg
+ ULong64_t spdFO = (1 << 14);
+ ULong64_t v0left = (1 << 10);
+ ULong64_t v0right = (1 << 11);
+
+ switch (trigger)
+ {
+ case kAcceptAll:
+ {
+ return kTRUE;
+ break;
+ }
+ case kMB1:
+ {
+ if (triggerMask & spdFO || ((triggerMask & v0left) || (triggerMask & v0right)))
+ return kTRUE;
+ break;
+ }
+ case kMB2:
+ {
+ if (triggerMask & spdFO && ((triggerMask & v0left) || (triggerMask & v0right)))
+ return kTRUE;
+ break;
+ }
+ case kMB3:
+ {
+ if (triggerMask & spdFO && (triggerMask & v0left) && (triggerMask & v0right))
+ return kTRUE;
+ break;
+ }
+ case kSPDGFO:
+ {
+ if (triggerMask & spdFO)
+ return kTRUE;
+ break;
+ }
+ default:
+ Printf("IsEventTriggered: ERROR: Trigger type %d not implemented in this method", (Int_t) trigger);
+ break;
+ }
+
+ return kFALSE;
+}
+
+Bool_t AliTriggerAnalysis::IsTriggerBitFired(const AliESDEvent* aEsd, ULong64_t tclass) const
+{
+ // Checks if corresponding bit in mask is on
+
+ ULong64_t trigmask = aEsd->GetTriggerMask();
+ return (trigmask & (1ull << (tclass-1)));
+}
+
+Bool_t AliTriggerAnalysis::IsOfflineTriggerFired(const AliESDEvent* aEsd, Trigger trigger) const
{
// checks if an event has been triggered "offline"
- UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliPWG0Helper::kStartOfFlags;
+ UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
switch (triggerNoFlags)
{
- case AliPWG0Helper::kAcceptAll:
+ case kAcceptAll:
{
return kTRUE;
break;
}
- case AliPWG0Helper::kMB1:
+ case kMB1:
{
if (SPDGFOTrigger(aEsd) || V0Trigger(aEsd, kASide) || V0Trigger(aEsd, kCSide))
return kTRUE;
break;
}
- case AliPWG0Helper::kMB2:
+ case kMB2:
{
if (SPDGFOTrigger(aEsd) && (V0Trigger(aEsd, kASide) || V0Trigger(aEsd, kCSide)))
return kTRUE;
break;
}
- case AliPWG0Helper::kMB3:
+ case kMB3:
{
if (SPDGFOTrigger(aEsd) && V0Trigger(aEsd, kASide) && V0Trigger(aEsd, kCSide))
return kTRUE;
break;
}
- case AliPWG0Helper::kSPDGFO:
+ case kSPDGFO:
{
if (SPDGFOTrigger(aEsd))
return kTRUE;
break;
}
- case AliPWG0Helper::kV0A:
+ case kV0A:
{
if (V0Trigger(aEsd, kASide))
return kTRUE;
break;
}
- case AliPWG0Helper::kV0C:
+ case kV0C:
{
if (V0Trigger(aEsd, kCSide))
return kTRUE;
break;
}
- case AliPWG0Helper::kZDC:
+ case kZDC:
{
if (ZDCTrigger(aEsd, kASide) || ZDCTrigger(aEsd, kCentralBarrel) || ZDCTrigger(aEsd, kCSide))
return kTRUE;
break;
}
- case AliPWG0Helper::kZDCA:
+ case kZDCA:
{
if (ZDCTrigger(aEsd, kASide))
return kTRUE;
break;
}
- case AliPWG0Helper::kZDCC:
+ case kZDCC:
{
if (ZDCTrigger(aEsd, kCSide))
return kTRUE;
break;
}
- case AliPWG0Helper::kFMDA:
+ case kFMDA:
{
if (FMDTrigger(aEsd, kASide))
return kTRUE;
break;
}
- case AliPWG0Helper::kFMDC:
+ case kFMDC:
{
if (FMDTrigger(aEsd, kCSide))
return kTRUE;
break;
}
- case AliPWG0Helper::kFPANY:
+ case kFPANY:
{
if (SPDGFOTrigger(aEsd) || V0Trigger(aEsd, kASide) || V0Trigger(aEsd, kCSide) || ZDCTrigger(aEsd, kASide) || ZDCTrigger(aEsd, kCentralBarrel) || ZDCTrigger(aEsd, kCSide) || FMDTrigger(aEsd, kASide) || FMDTrigger(aEsd, kCSide))
return kTRUE;
return kFALSE;
}
-void AliOfflineTrigger::FillHistograms(const AliESDEvent* aEsd)
+
+Bool_t AliTriggerAnalysis::IsTriggerClassFired(const AliESDEvent* aEsd, const Char_t* tclass) const
+{
+ // tclass is logical function of inputs, e.g. 01 && 02 || 03 && 11 && 21
+ // = L0 inp 1 && L0 inp 2 || L0 inp 3 && L1 inp 1 && L2 inp 1
+ // NO brackets in logical function !
+ // Spaces between operators and inputs.
+ // Not all logical functions are available in CTP=
+ // =any function of first 4 inputs; 'AND' of other inputs, check not done
+ // This method will be replaced/complemened by similar one
+ // which works withh class and inputs names as in CTP cfg file
+
+ TString TClass(tclass);
+ TObjArray* tcltokens = TClass.Tokenize(" ");
+ Char_t level=((TObjString*)tcltokens->At(0))->String()[0];
+ UInt_t input=atoi((((TObjString*)tcltokens->At(0))->String()).Remove(0));
+ Bool_t tcl = IsInputFired(aEsd,level,input);
+
+ for (Int_t i=1;i<tcltokens->GetEntriesFast();i=i+2) {
+ level=((TObjString*)tcltokens->At(i+1))->String()[0];
+ input=atoi((((TObjString*)tcltokens->At(i+1))->String()).Remove(0));
+ Bool_t inpnext = IsInputFired(aEsd,level,input);
+ Char_t op =((TObjString*)tcltokens->At(i))->String()[0];
+ if (op == '&') tcl=tcl && inpnext;
+ else if (op == '|') tcl =tcl || inpnext;
+ else {
+ AliError(Form("Syntax error in %s", tclass));
+ tcltokens->Delete();
+ return kFALSE;
+ }
+ }
+ tcltokens->Delete();
+ return tcl;
+}
+
+Bool_t AliTriggerAnalysis::IsInputFired(const AliESDEvent* aEsd, Char_t level, UInt_t input) const
+{
+ // Checks trigger input of any level
+
+ switch (level)
+ {
+ case '0': return IsL0InputFired(aEsd,input);
+ case '1': return IsL1InputFired(aEsd,input);
+ case '2': return IsL2InputFired(aEsd,input);
+ default:
+ AliError(Form("Wrong level %i",level));
+ return kFALSE;
+ }
+}
+
+Bool_t AliTriggerAnalysis::IsL0InputFired(const AliESDEvent* aEsd, UInt_t input) const
+{
+ // Checks if corresponding bit in mask is on
+
+ UInt_t inpmask = aEsd->GetHeader()->GetL0TriggerInputs();
+ return (inpmask & (1<<(input-1)));
+}
+
+Bool_t AliTriggerAnalysis::IsL1InputFired(const AliESDEvent* aEsd, UInt_t input) const
+{
+ // Checks if corresponding bit in mask is on
+
+ UInt_t inpmask = aEsd->GetHeader()->GetL1TriggerInputs();
+ return (inpmask & (1<<(input-1)));
+}
+
+Bool_t AliTriggerAnalysis::IsL2InputFired(const AliESDEvent* aEsd, UInt_t input) const
+{
+ // Checks if corresponding bit in mask is on
+
+ UInt_t inpmask = aEsd->GetHeader()->GetL2TriggerInputs();
+ return (inpmask & (1<<(input-1)));
+}
+
+void AliTriggerAnalysis::FillHistograms(const AliESDEvent* aEsd)
{
// fills the histograms with the info from the ESD
fHistFMDC->Fill(FMDHitCombinations(aEsd, kCSide, kTRUE));
}
-Int_t AliOfflineTrigger::SPDFiredChips(const AliESDEvent* aEsd) const
+Int_t AliTriggerAnalysis::SPDFiredChips(const AliESDEvent* aEsd) const
{
// returns the number of fired chips in the SPD
return mult->GetNumberOfFiredChips(0) + mult->GetNumberOfFiredChips(1);
}
-Bool_t AliOfflineTrigger::SPDGFOTrigger(const AliESDEvent* aEsd) const
+Bool_t AliTriggerAnalysis::SPDGFOTrigger(const AliESDEvent* aEsd) const
{
// Returns if the SPD gave a global Fast OR trigger
return kFALSE;
}
-Int_t AliOfflineTrigger::V0BBTriggers(const AliESDEvent* aEsd, AliceSide side) const
+Int_t AliTriggerAnalysis::V0BBTriggers(const AliESDEvent* aEsd, AliceSide side) const
{
// returns the number of BB triggers in V0A | V0C
return count;
}
-Bool_t AliOfflineTrigger::V0Trigger(const AliESDEvent* aEsd, AliceSide side) const
+Bool_t AliTriggerAnalysis::V0Trigger(const AliESDEvent* aEsd, AliceSide side) const
{
// Returns if the V0 triggered
return kFALSE;
}
-Bool_t AliOfflineTrigger::ZDCTrigger(const AliESDEvent* aEsd, AliceSide side) const
+Bool_t AliTriggerAnalysis::ZDCTrigger(const AliESDEvent* aEsd, AliceSide side) const
{
// Returns if ZDC triggered
return kFALSE;
}
-Int_t AliOfflineTrigger::FMDHitCombinations(const AliESDEvent* aEsd, AliceSide side, Bool_t fillHistograms) const
+Int_t AliTriggerAnalysis::FMDHitCombinations(const AliESDEvent* aEsd, AliceSide side, Bool_t fillHistograms) const
{
// returns number of hit combinations agove threshold
//
return triggers;
}
-Bool_t AliOfflineTrigger::FMDTrigger(const AliESDEvent* aEsd, AliceSide side) const
+Bool_t AliTriggerAnalysis::FMDTrigger(const AliESDEvent* aEsd, AliceSide side) const
{
// Returns if the FMD triggered
//
return kFALSE;
}
-Long64_t AliOfflineTrigger::Merge(TCollection* list)
+Long64_t AliTriggerAnalysis::Merge(TCollection* list)
{
// Merge a list of AliMultiplicityCorrection objects with this (needed for
// PROOF).
Int_t count = 0;
while ((obj = iter->Next())) {
- AliOfflineTrigger* entry = dynamic_cast<AliOfflineTrigger*> (obj);
+ AliTriggerAnalysis* entry = dynamic_cast<AliTriggerAnalysis*> (obj);
if (entry == 0)
continue;
return count+1;
}
-void AliOfflineTrigger::WriteHistograms() const
+void AliTriggerAnalysis::WriteHistograms() const
{
// write histograms to current directory
-/* $Id: AliOfflineTrigger.h 35782 2009-10-22 11:54:31Z jgrosseo $ */
+/* $Id: AliTriggerAnalysis.h 35782 2009-10-22 11:54:31Z jgrosseo $ */
-#ifndef ALIOFFLINETRIGGER_H
-#define ALIOFFLINETRIGGER_H
+#ifndef ALITRIGGERANALYSIS_H
+#define ALITRIGGERANALYSIS_H
#include <TObject.h>
-#include <AliPWG0Helper.h>
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
//-------------------------------------------------------------------------
-// Implementation of Class AliOfflineTrigger
-// This class provides offline triggers from data in the ESD
+// Implementation of Class AliTriggerAnalysis
+// This class provides function to check if events have been triggered based on the data in the ESD
+// The trigger bits, trigger class inputs and only the data (offline trigger) can be used
// Origin: Jan Fiete Grosse-Oetringhaus, CERN
//-------------------------------------------------------------------------
class AliESDEvent;
class TH1;
+class TCollection;
-class AliOfflineTrigger : public TObject
+class AliTriggerAnalysis : public TObject
{
public:
+ enum Trigger { kAcceptAll = 1, kMB1 = 2, kMB2, kMB3, kSPDGFO, kV0A, kV0C, kZDC, kZDCA, kZDCC, kFMDA, kFMDC, kFPANY, kStartOfFlags = 0x0100, kOfflineFlag = 0x8000 }; // MB1, MB2, MB3 definition from ALICE-INT-2005-025
enum AliceSide { kASide = 1, kCSide, kCentralBarrel };
- AliOfflineTrigger();
- virtual ~AliOfflineTrigger() {}
+ AliTriggerAnalysis();
+ virtual ~AliTriggerAnalysis() {}
void EnableHistograms();
- Bool_t IsEventTriggered(const AliESDEvent* aEsd, AliPWG0Helper::Trigger trigger) const;
+ Bool_t IsTriggerFired(const AliESDEvent* aEsd, Trigger trigger) const;
+
+ // using trigger bits in ESD
+ Bool_t IsTriggerBitFired(const AliESDEvent* aEsd, Trigger trigger) const;
+ Bool_t IsTriggerBitFired(ULong64_t triggerMask, Trigger trigger) const;
+ Bool_t IsTriggerBitFired(const AliESDEvent* aEsd, ULong64_t tclass) const;
+
+ // using ESD data from detectors
+ Bool_t IsOfflineTriggerFired(const AliESDEvent* aEsd, Trigger trigger) const;
+
+ // using trigger classes in ESD
+ Bool_t IsTriggerClassFired(const AliESDEvent* aEsd, const Char_t* tclass) const;
+
+ static const char* GetTriggerName(Trigger trigger);
+
void FillHistograms(const AliESDEvent* aEsd);
void SetSPDGFOThreshhold(Int_t t) { fSPDGFOThreshold = t; }
void WriteHistograms() const;
protected:
+ Bool_t IsL0InputFired(const AliESDEvent* aEsd, UInt_t input) const;
+ Bool_t IsL1InputFired(const AliESDEvent* aEsd, UInt_t input) const;
+ Bool_t IsL2InputFired(const AliESDEvent* aEsd, UInt_t input) const;
+ Bool_t IsInputFired(const AliESDEvent* aEsd, Char_t level, UInt_t input) const;
+
Int_t SPDFiredChips(const AliESDEvent* aEsd) const;
Bool_t SPDGFOTrigger(const AliESDEvent* aEsd) const;
TH1* fHistFMDSingle; // histograms that histogram the criterion the cut is applied on: single mult value (more than one entry per event)
TH1* fHistFMDSum; // histograms that histogram the criterion the cut is applied on: summed mult value (more than one entry per event)
- ClassDef(AliOfflineTrigger, 1)
+ ClassDef(AliTriggerAnalysis, 1)
private:
- AliOfflineTrigger(const AliOfflineTrigger&);
- AliOfflineTrigger& operator=(const AliOfflineTrigger&);
+ AliTriggerAnalysis(const AliTriggerAnalysis&);
+ AliTriggerAnalysis& operator=(const AliTriggerAnalysis&);
};
#endif
#include "AliPWG0Helper.h"
#include "dNdEta/dNdEtaAnalysis.h"
#include "dNdEta/AlidNdEtaCorrection.h"
+#include "AliTriggerAnalysis.h"
ClassImp(AlidNdEtaCorrectionTask)
fOutput(0),
fOption(),
fAnalysisMode((AliPWG0Helper::AnalysisMode) (AliPWG0Helper::kTPC | AliPWG0Helper::kFieldOn)),
- fTrigger(AliPWG0Helper::kMB1),
+ fTrigger(AliTriggerAnalysis::kMB1),
fFillPhi(kFALSE),
fDeltaPhiCut(-1),
fSignMode(0),
fOutput(0),
fOption(opt),
fAnalysisMode((AliPWG0Helper::AnalysisMode) (AliPWG0Helper::kTPC | AliPWG0Helper::kFieldOn)),
- fTrigger(AliPWG0Helper::kMB1),
+ fTrigger(AliTriggerAnalysis::kMB1),
fFillPhi(kFALSE),
fDeltaPhiCut(0),
fSignMode(0),
}
- /*
- fTemp1 = new TH2F("fTemp1", "fTemp1", 200, -0.08, 0.08, 200, -0.08, 0.08);
+ fTemp1 = new TH2F("fTemp1", "fTemp1", 200, -20, 20, 200, -0.5, 199.5);
fOutput->Add(fTemp1);
+ /*
fTemp2 = new TH1F("fTemp2", "fTemp2", 2000, -5, 5);
fOutput->Add(fTemp2);
*/
Printf("WARNING: Statistical error evaluation active!");
// trigger definition
- Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD, fTrigger);
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;
+ Bool_t eventTriggered = triggerAnalysis->IsTriggerFired(fESD, fTrigger);
//Printf("Trigger mask: %lld", fESD->GetTriggerMask());
if (!eventTriggered)
primCount[i] = kFALSE;
}
+ Int_t nEta05 = 0;
for (Int_t i=0; i<inputCount; ++i)
{
+ if (TMath::Abs(etaArr[i]) < 0.5)
+ nEta05++;
+
Int_t label = labelArr[i];
Int_t label2 = labelArr2[i];
fVertexCorrelation->Fill(vtxMC[2], vtx[2]);
fVertexCorrelationShift->Fill(vtxMC[2], vtxMC[2] - vtx[2], inputCount);
fVertexProfile->Fill(vtxMC[2], vtxMC[2] - vtx[2]);
+
+ fTemp1->Fill(vtxMC[2], nEta05);
}
if (eventTriggered && eventVertex)
void SetTrackCuts(AliESDtrackCuts* cuts) { fEsdTrackCuts = cuts; }
void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
void SetOnlyPrimaries(Bool_t flag = kTRUE) { fOnlyPrimaries = flag; }
- void SetTrigger(AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+ void SetTrigger(AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
void SetFillPhi(Bool_t flag = kTRUE) { fFillPhi = flag; }
void SetDeltaPhiCut(Float_t cut) { fDeltaPhiCut = cut; }
TString fOption; // option string
AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
- AliPWG0Helper::Trigger fTrigger; // trigger used in the analysis
+ AliTriggerAnalysis::Trigger fTrigger; // trigger used in the analysis
Bool_t fFillPhi; // if true phi is filled as 3rd coordinate in all maps
Float_t fDeltaPhiCut; // cut in delta phi (only SPD)
#include "AliCorrection.h"
#include "AliCorrectionMatrix3D.h"
#include "dNdEta/dNdEtaAnalysis.h"
+#include "AliTriggerAnalysis.h"
ClassImp(AlidNdEtaTask)
fOutput(0),
fOption(opt),
fAnalysisMode((AliPWG0Helper::AnalysisMode) (AliPWG0Helper::kTPC | AliPWG0Helper::kFieldOn)),
- fTrigger(AliPWG0Helper::kMB1),
+ fTrigger(AliTriggerAnalysis::kMB1),
fFillPhi(kFALSE),
fDeltaPhiCut(-1),
fReadMC(kFALSE),
TString branches("AliESDHeader Vertex ");
- if (fAnalysisMode & AliPWG0Helper::kSPD || fTrigger & AliPWG0Helper::kOfflineFlag)
+ if (fAnalysisMode & AliPWG0Helper::kSPD || fTrigger & AliTriggerAnalysis::kOfflineFlag)
branches += "AliMultiplicity ";
if (fAnalysisMode & AliPWG0Helper::kTPC || fAnalysisMode & AliPWG0Helper::kTPCITS)
// }
// trigger definition
- eventTriggered = AliPWG0Helper::IsEventTriggered(fESD, fTrigger);
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;
+ eventTriggered = triggerAnalysis->IsTriggerFired(fESD, fTrigger);
if (eventTriggered)
fStats->Fill(3);
#include "AliAnalysisTask.h"
#include "AliPWG0Helper.h"
+#include "AliTriggerAnalysis.h"
#include <TString.h>
class AliESDtrackCuts;
void SetUseMCVertex(Bool_t flag = kTRUE) { fUseMCVertex = flag; }
void SetOnlyPrimaries(Bool_t flag = kTRUE) { fOnlyPrimaries = flag; }
void SetUseMCKine(Bool_t flag = kTRUE) { fUseMCKine = flag; }
- void SetTrigger(AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+ void SetTrigger(AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
void SetFillPhi(Bool_t flag = kTRUE) { fFillPhi = flag; }
void SetDeltaPhiCut(Float_t cut) { fDeltaPhiCut = cut; }
TString fOption; // option string
AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
- AliPWG0Helper::Trigger fTrigger; // trigger that is used
+ AliTriggerAnalysis::Trigger fTrigger; // trigger that is used
Bool_t fFillPhi; // if true phi is filled as 3rd coordinate in all maps
Float_t fDeltaPhiCut; // cut in delta phi (only SPD)
axis->SetRangeUser(0, 4.9999);
axis->SetTitle("p_{T} (GeV/c)");
}
- if (strcmp(axis->GetTitle(), "vtx z [cm]") == 0 || strcmp(axis->GetTitle(), "vtx z (cm)") == 0)
+ if (strcmp(axis->GetTitle(), "vtx z [cm]") == 0 || strcmp(axis->GetTitle(), "vtx z (cm)") == 0 || strcmp(axis->GetTitle(), "vtx-z [cm]") == 0 || strcmp(axis->GetTitle(), "vtx-z (cm)") == 0)
{
axis->SetRangeUser(-15, 14.9999);
axis->SetTitle("vtx-z (cm)");
for (Int_t i=AlidNdEtaCorrection::kTrack2Particle; i<=AlidNdEtaCorrection::kND; i++)
{
Printf("Correction %d", i);
- dNdEtaCorrection->GetCorrection(i)->PrintInfo(0);
+ dNdEtaCorrection->GetCorrection(i)->PrintInfo(0.2);
return;
}
}
legend->AddEntry(histESDMB, "Triggered");
legend->AddEntry(histESD, "All events");
- TH2F* dummy = new TH2F("dummy", "", 100, -etaPlotLimit, etaPlotLimit, 1000, 2.1, max * 1.1);
+ TH2F* dummy = new TH2F("dummy", "", 100, -etaPlotLimit, etaPlotLimit, 1000, 0, max * 1.1);
+ dummy->GetYaxis()->SetRangeUser(2.1, max * 1.1);
Prepare1DPlot(dummy);
dummy->SetStats(kFALSE);
dummy->SetXTitle("#eta");
temphist = dNdEtaCorrection->GetCorrection(AlidNdEtaCorrection::kINEL)->GetEventCorrection()->GetGeneratedHistogram();
//temphist = dNdEtaCorrection->GetCorrection(AlidNdEtaCorrection::kINEL)->GetEventCorrection()->GetMeasuredHistogram();
+ temphist = (TH2*) gFile->Get("fTemp1");
+
new TCanvas;
legend = new TLegend(0.7, 0.7, 0.99, 0.99);
legend->SetFillColor(0);
for (Int_t i=0; i<20; i+=5)
{
highmult = temphist->ProjectionX("highmult", i+1, i+1+4);
+ highmult->Rebin(10);
Printf("%f", highmult->Integral());
if (highmult->Integral() <= 0)
continue;
esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDVZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks Kinks Cascades AliESDTZERO ALIESDACORDE MuonTracks TrdTracks CaloClusters");
mgr->SetInputEventHandler(esdH);
- AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC | AliPWG0Helper::kFieldOn;
- AliPWG0Helper::Trigger trigger = AliPWG0Helper::kMB1;
+ AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn;
+ AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kMB1 | AliTriggerAnalysis::kOfflineFlag; // AcceptAll;
AliPWG0Helper::PrintConf(analysisMode, trigger);
, fEsdTrackCuts(0)\r
, fUseMCInfo(kFALSE)\r
, fAnalysisMode(AlidNdPtHelper::kTPC) \r
-, fTrigger(AliPWG0Helper::kMB1) \r
+, fTrigger(AliTriggerAnalysis::kMB1) \r
{\r
// default constructor\r
}\r
, fEsdTrackCuts(0)\r
, fUseMCInfo(kFALSE)\r
, fAnalysisMode(AlidNdPtHelper::kTPC) \r
-, fTrigger(AliPWG0Helper::kMB1) \r
+, fTrigger(AliTriggerAnalysis::kMB1) \r
{\r
// constructor\r
}\r
#include "TNamed.h"
#include "TFolder.h"
-#include "AliPWG0Helper.h"
+#include "AliTriggerAnalysis.h"
#include "AlidNdPtHelper.h"
class AlidNdPt : public TNamed {
void SetTrackCuts(AliESDtrackCuts* const cuts) { fEsdTrackCuts = cuts; }
void SetUseMCInfo(const Bool_t info) { fUseMCInfo = info; }
void SetAnalysisMode(const AlidNdPtHelper::AnalysisMode mode) { fAnalysisMode = mode; }
- void SetTrigger(const AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+ void SetTrigger(const AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
AlidNdPtEventCuts* GetEventCuts() const { return fdNdPtEventCuts; }
AlidNdPtAcceptanceCuts* GetAcceptanceCuts() const { return fdNdPtAcceptanceCuts; }
AliESDtrackCuts* GetTrackCuts() const { return fEsdTrackCuts; }
Bool_t IsUseMCInfo() const { return fUseMCInfo; }
AlidNdPtHelper::AnalysisMode GetAnalysisMode() const { return fAnalysisMode; }
- AliPWG0Helper::Trigger GetTrigger() const { return fTrigger; }
+ AliTriggerAnalysis::Trigger GetTrigger() const { return fTrigger; }
private:
Bool_t fUseMCInfo; // use MC information
AlidNdPtHelper::AnalysisMode fAnalysisMode; // analysis mode TPC only, TPC + ITS
- AliPWG0Helper::Trigger fTrigger; // trigger definition MB1, MB2 ...
+ AliTriggerAnalysis::Trigger fTrigger; // trigger definition MB1, MB2 ...
ClassDef(AlidNdPt,1);
};
// trigger selection\r
Bool_t isEventTriggered = kTRUE;\r
if(evtCuts->IsTriggerRequired()) {\r
- isEventTriggered = AliPWG0Helper::IsEventTriggered(esdEvent->GetTriggerMask(), GetTrigger());\r
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;\r
+ isEventTriggered = triggerAnalysis->IsTriggerFired(esdEvent, GetTrigger());\r
}\r
\r
// use MC information\r
// trigger selection\r
Bool_t isEventTriggered = kTRUE;\r
if(evtCuts->IsTriggerRequired()) {\r
- isEventTriggered = AliPWG0Helper::IsEventTriggered(esdEvent->GetTriggerMask(), GetTrigger());\r
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;\r
+ isEventTriggered = triggerAnalysis->IsTriggerFired(esdEvent, GetTrigger());\r
}\r
\r
// use MC information\r
// trigger selection\r
Bool_t isEventTriggered = kTRUE;\r
if(evtCuts->IsTriggerRequired()) {\r
- isEventTriggered = AliPWG0Helper::IsEventTriggered(esdEvent->GetTriggerMask(), GetTrigger());\r
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;\r
+ isEventTriggered = triggerAnalysis->IsTriggerFired(esdEvent, GetTrigger());\r
}\r
\r
// use MC information\r
}
//____________________________________________________________________
-void AlidNdPtHelper::PrintConf(AnalysisMode analysisMode, AliPWG0Helper::Trigger trigger)
+void AlidNdPtHelper::PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger)
{
//
// Prints the given configuration
}
str += " and trigger ";
- switch (trigger)
- {
- case AliPWG0Helper::kAcceptAll : str += "kAcceptAll"; break;
- case AliPWG0Helper::kMB1 : str += "MB1"; break;
- case AliPWG0Helper::kMB2 : str += "MB2"; break;
- case AliPWG0Helper::kMB3 : str += "MB3"; break;
- case AliPWG0Helper::kSPDGFO : str += "SPDGFO"; break;
- case AliPWG0Helper::kV0A : str += "V0A"; break;
- case AliPWG0Helper::kV0C : str += "V0C"; break;
- case AliPWG0Helper::kZDC : str += "ZDC"; break;
- case AliPWG0Helper::kZDCA : str += "ZDCA"; break;
- case AliPWG0Helper::kZDCC : str += "ZDCC"; break;
- case AliPWG0Helper::kFMDA : str += "FMDA"; break;
- case AliPWG0Helper::kFMDC : str += "FMDC"; break;
- case AliPWG0Helper::kFPANY : str += "FPANY"; break;
- case AliPWG0Helper::kStartOfFlags : str += "StartOfFlags"; break;
- case AliPWG0Helper::kOfflineFlag : str += "kOfflineFlag"; break;
- }
+ str += AliTriggerAnalysis::GetTriggerName(trigger);
str += " <<<<";
static Bool_t TestRecVertex(const AliESDVertex* vertex, AnalysisMode analysisMode, Bool_t debug = kFALSE);
static Bool_t IsPrimaryParticle(AliStack *stack, Int_t idx, AnalysisMode analysisMode);
- static void PrintConf(AnalysisMode analysisMode, AliPWG0Helper::Trigger trigger);
+ static void PrintConf(AnalysisMode analysisMode, AliTriggerAnalysis::Trigger trigger);
static Int_t ConvertPdgToPid(TParticle *particle);
enum OutputObject { kInvalidObject = -1, kCutAnalysis = 0, kAnalysis, kCorrection, kSystematics };
fdNdPtCutAnalysis->SetAcceptanceCuts(accCuts);
fdNdPtCutAnalysis->SetTrackCuts(esdTrackCuts);
fdNdPtCutAnalysis->SetAnalysisMode(analysisMode);
- fdNdPtCutAnalysis->SetTrigger(AliPWG0Helper::kMB1);
+ fdNdPtCutAnalysis->SetTrigger(AliTriggerAnalysis::kMB1);
if (bUseMCInfo) fdNdPtCutAnalysis->SetUseMCInfo(kTRUE);
task->AddAnalysisObject( fdNdPtCutAnalysis );
fdNdPtAnalysis->SetAcceptanceCuts(accCuts);
fdNdPtAnalysis->SetTrackCuts(esdTrackCuts);
fdNdPtAnalysis->SetAnalysisMode(analysisMode);
- fdNdPtAnalysis->SetTrigger(AliPWG0Helper::kMB1);
+ fdNdPtAnalysis->SetTrigger(AliTriggerAnalysis::kMB1);
if (bUseMCInfo) fdNdPtAnalysis->SetUseMCInfo(kTRUE);
fdNdPtAnalysis->SetHistogramsOn(kTRUE);
fdNdPtCorrection->SetAcceptanceCuts(accCuts);
fdNdPtCorrection->SetTrackCuts(esdTrackCuts);
fdNdPtCorrection->SetAnalysisMode(analysisMode);
- fdNdPtCorrection->SetTrigger(AliPWG0Helper::kMB1);
+ fdNdPtCorrection->SetTrigger(AliTriggerAnalysis::kMB1);
if (bUseMCInfo) fdNdPtCorrection->SetUseMCInfo(kTRUE);
task->AddAnalysisObject( fdNdPtCorrection );
#include "AliESDtrackCuts.h"
#include "AliPWG0Helper.h"
+#include "AliTriggerAnalysis.h"
#include "AliAnalysisTask.h"
#include "AliAnalysisManager.h"
//fESD->GetVertex()->Print();
- if (!AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB1) && !AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2))
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;
+
+ if (!triggerAnalysis->IsTriggerFired(fESD, AliTriggerAnalysis::kMB1) && !triggerAnalysis->IsTriggerFired(fESD, AliTriggerAnalysis::kMB2))
fTriggerStats->Fill(0);
- if (AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB1))
+ if (triggerAnalysis->IsTriggerFired(fESD, AliTriggerAnalysis::kMB1))
fTriggerStats->Fill(1);
- if (AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2))
+ if (triggerAnalysis->IsTriggerFired(fESD, AliTriggerAnalysis::kMB2))
fTriggerStats->Fill(2);
if (fESD->GetTriggerMask() & (0x1 << 14))
fTriggerStats->Fill(4);
//if (fESD->GetTriggerMask() & (0x1 << 14) == 0)
- if (!AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB2))
+ if (!triggerAnalysis->IsTriggerFired(fESD, AliTriggerAnalysis::kMB2))
return;
// get the ESD vertex
return kFALSE;
}
- Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD->GetTriggerMask(), AliPWG0Helper::kMB1);
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;
+ Bool_t eventTriggered = triggerAnalysis->IsTriggerBitFired(fESD->GetTriggerMask(), AliTriggerAnalysis::kMB1);
if (!eventTriggered)
{
gSystem->Load("libANALYSIS");
gSystem->Load("libPWG0base");
- .L AliHighMultiplicitySelector.cxx+
+ .L AliHighMultiplicitySelector.cxx++
x = new AliHighMultiplicitySelector();
x->ReadHistograms("highmult_hijing100k.root");
x->DrawHistograms();
AliPWG0Helper.cxx \
AliUnfolding.cxx \
multiplicity/AliMultiplicityCorrection.cxx \
- AliOfflineTrigger.cxx \
+ AliTriggerAnalysis.cxx \
HDRS = $(SRCS:.cxx=.h)
#include "multiplicity/AliMultiplicityCorrection.h"
#include "AliCorrection.h"
#include "AliCorrectionMatrix3D.h"
+#include "AliTriggerAnalysis.h"
ClassImp(AliMultiplicityTask)
AliAnalysisTask("AliMultiplicityTask", ""),
fESD(0),
fOption(opt),
- fAnalysisMode(AliPWG0Helper::kSPD),
- fTrigger(AliPWG0Helper::kMB1),
+ fAnalysisMode((AliPWG0Helper::AnalysisMode) (AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn)),
+ fTrigger(AliTriggerAnalysis::kMB1),
fDeltaPhiCut(-1),
fReadMC(kFALSE),
fUseMCVertex(kFALSE),
tree->SetBranchStatus("AliESDHeader*", 1);
tree->SetBranchStatus("*Vertex*", 1);
- if (fAnalysisMode == AliPWG0Helper::kSPD) {
+ if (fAnalysisMode & AliPWG0Helper::kSPD) {
tree->SetBranchStatus("AliMultiplicity*", 1);
}
- if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS) {
+ if (fAnalysisMode & AliPWG0Helper::kTPC || fAnalysisMode & AliPWG0Helper::kTPCITS) {
//AliESDtrackCuts::EnableNeededBranches(tree);
tree->SetBranchStatus("Tracks*", 1);
}
return;
}
- Bool_t eventTriggered = AliPWG0Helper::IsEventTriggered(fESD, fTrigger);
+ static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis;
+ Bool_t eventTriggered = triggerAnalysis->IsTriggerFired(fESD, fTrigger);
//Printf("%lld", fESD->GetTriggerMask());
const AliESDVertex* vtxESD = AliPWG0Helper::GetVertex(fESD, fAnalysisMode);
Int_t inputCount = 0;
Int_t* labelArr = 0;
Float_t* etaArr = 0;
- if (fAnalysisMode == AliPWG0Helper::kSPD)
+ if (fAnalysisMode & AliPWG0Helper::kSPD)
{
// get tracklets
const AliMultiplicity* mult = fESD->GetMultiplicity();
++inputCount;
}
}
- else if (fAnalysisMode == AliPWG0Helper::kTPC || fAnalysisMode == AliPWG0Helper::kTPCITS)
+ else if (fAnalysisMode & AliPWG0Helper::kTPC || fAnalysisMode & AliPWG0Helper::kTPCITS)
{
if (!fEsdTrackCuts)
{
if (vtxESD)
{
// get multiplicity from ESD tracks
- TObjArray* list = fEsdTrackCuts->GetAcceptedTracks(fESD, (fAnalysisMode == AliPWG0Helper::kTPC));
+ TObjArray* list = fEsdTrackCuts->GetAcceptedTracks(fESD, (fAnalysisMode & AliPWG0Helper::kTPC));
Int_t nGoodTracks = list->GetEntries();
labelArr = new Int_t[nGoodTracks];
}
// eta range for nMCTracksSpecies, nESDTracksSpecies
- Float_t etaRange = -1;
- switch (fAnalysisMode) {
- case AliPWG0Helper::kInvalid: break;
- case AliPWG0Helper::kTPC:
- case AliPWG0Helper::kTPCITS:
- etaRange = 1.0; break;
- case AliPWG0Helper::kSPD: etaRange = 1.0; break;
- default: break;
- }
+ Float_t etaRange = 1.0;
+// switch (fAnalysisMode) {
+// case AliPWG0Helper::kInvalid: break;
+// case AliPWG0Helper::kTPC:
+// case AliPWG0Helper::kTPCITS:
+// etaRange = 1.0; break;
+// case AliPWG0Helper::kSPD: etaRange = 1.0; break;
+// default: break;
+// }
if (!fReadMC) // Processing of ESD information
{
// if the particle decays/stops before this radius we do not see it
// 8cm larger than SPD layer 2
// 123cm TPC radius where a track has about 50 clusters (cut limit)
- const Float_t endRadius = (fAnalysisMode == AliPWG0Helper::kSPD) ? 8. : 123;
+ const Float_t endRadius = (fAnalysisMode & AliPWG0Helper::kSPD) ? 8. : 123;
// loop over all primaries that have not been found
for (Int_t i=0; i<nPrim; i++)
void SetPtSpectrum(TH1D* hist) { fPtSpectrum = hist; }
void SetAnalysisMode(AliPWG0Helper::AnalysisMode mode) { fAnalysisMode = mode; }
- void SetTrigger(AliPWG0Helper::Trigger trigger) { fTrigger = trigger; }
+ void SetTrigger(AliTriggerAnalysis::Trigger trigger) { fTrigger = trigger; }
void SetDeltaPhiCut(Float_t cut) { fDeltaPhiCut = cut; }
void SetReadMC(Bool_t flag = kTRUE) { fReadMC = flag; }
TString fOption; // option string
AliPWG0Helper::AnalysisMode fAnalysisMode; // detector that is used for analysis
- AliPWG0Helper::Trigger fTrigger; // trigger that is used
+ AliTriggerAnalysis::Trigger fTrigger; // trigger that is used
Float_t fDeltaPhiCut; // cut in delta phi (only SPD)
Bool_t fReadMC; // if true reads MC data (to build correlation maps)
AliMultiplicityCorrection* mult = AliMultiplicityCorrection::Open(fileNameMC, folder);
AliMultiplicityCorrection* esd = AliMultiplicityCorrection::Open(fileNameESD, folderESD);
- AliUnfolding::SetNbins(150, 150);
+ //AliUnfolding::SetNbins(150, 150);
+ //AliUnfolding::SetNbins(65, 65);
+ //AliUnfolding::SetNbins(35, 35);
+ //AliUnfolding::SetDebug(1);
- for (hID = ((histID == -1) ? 0 : histID); hID <= ((histID == -1) ? 2 : histID); hID++)
+ for (Int_t hID = ((histID == -1) ? 0 : histID); hID <= ((histID == -1) ? 2 : histID); hID++)
{
+ switch (hID)
+ {
+ case 0: AliUnfolding::SetNbins(35, 35); break;
+ case 1: AliUnfolding::SetNbins(60, 60); break;
+ case 2: AliUnfolding::SetNbins(70, 70); beta *= 3; break;
+ }
+
TH2F* hist = esd->GetMultiplicityESD(hID);
TH2F* hist2 = esd->GetMultiplicityMC(hID, eventType);
if (chi2)
{
AliUnfolding::SetChi2Regularization(AliUnfolding::kPol0, beta);
- //mult->SetCreateBigBin(kFALSE);
+ //AliUnfolding::SetCreateOverflowBin(kFALSE);
//mult->SetRegularizationParameters(AliMultiplicityCorrection::kNone, 0); //mult->SetCreateBigBin(kFALSE);
//mult->SetRegularizationParameters(AliMultiplicityCorrection::kNone, 0, 125); mult->SetCreateBigBin(kFALSE);
- //mult->SetRegularizationParameters(AliMultiplicityCorrection::kEntropy, 1e4);
+ // AliUnfolding::SetChi2Regularization(AliUnfolding::kEntropy, beta);
//mult->SetRegularizationParameters(AliMultiplicityCorrection::kLog, 1e5);
//mult->ApplyMinuitFit(histID, fullPhaseSpace, AliMultiplicityCorrection::kTrVtx, kTRUE, mcCompare);
//mult->SetMultiplicityESDCorrected(histID, (TH1F*) mcCompare);
- mult->ApplyMinuitFit(hID, fullPhaseSpace, eventType, kFALSE); //hist2->ProjectionY("mymchist"));
+ mult->ApplyMinuitFit(hID, fullPhaseSpace, eventType, kFALSE, 0, kFALSE); //hist2->ProjectionY("mymchist"));
//mult->ApplyNBDFit(histID, fullPhaseSpace, eventType);
}
else
{
mult->ApplyBayesianMethod(hID, fullPhaseSpace, eventType, 1, 10, 0, kTRUE);
+ //mult->ApplyBayesianMethod(hID, fullPhaseSpace, eventType, 1, 5, 0, kFALSE);
}
mult->SetMultiplicityMC(hID, eventType, hist2);
}
}
+TH1* GetChi2Bias(Float_t alpha)
+{
+ loadlibs();
+
+ const char* fileNameMC = "multiplicityMC.root";
+ const char* folder = "Multiplicity";
+ const char* fileNameESD = "multiplicityESD.root";
+ const char* folderESD = "Multiplicity";
+
+ AliMultiplicityCorrection* mult = AliMultiplicityCorrection::Open(fileNameMC, folder);
+ AliMultiplicityCorrection* esd = AliMultiplicityCorrection::Open(fileNameESD, folderESD);
+
+ //Int_t hID = 0; const Int_t kMaxBins = 35;
+ //Int_t hID = 1; const Int_t kMaxBins = 60;
+ Int_t hID = 2; const Int_t kMaxBins = 70;
+ AliUnfolding::SetNbins(kMaxBins, kMaxBins);
+ //AliUnfolding::SetDebug(1);
+ //AliUnfolding::SetChi2Regularization(AliUnfolding::kPol0, 50);
+ AliUnfolding::SetChi2Regularization(AliUnfolding::kPol0, alpha);
+
+ TH2F* hist = esd->GetMultiplicityESD(hID);
+ mult->SetMultiplicityESD(hID, hist);
+
+ // without bias calculation
+ mult->ApplyMinuitFit(hID, kFALSE, 0, kFALSE);
+ baseold = (TH1*) mult->GetMultiplicityESDCorrected(hID)->Clone("baseold");
+
+ // with bias calculation
+ mult->ApplyMinuitFit(hID, kFALSE, 0, kFALSE, 0, kTRUE);
+ base = (TH1*) mult->GetMultiplicityESDCorrected(hID)->Clone("base");
+
+ // relative error plots
+ ratio1 = (TH1*) mult->GetMultiplicityESDCorrected(hID)->Clone("hist1");
+ ratio1->SetStats(0);
+ ratio1->SetTitle(";unfolded multiplicity;relative error");
+ ratio1->Reset();
+ ratio2 = (TH1*) mult->GetMultiplicityESDCorrected(hID)->Clone("hist1");
+ ratio2->Reset();
+
+ for (Int_t t = 0; t<kMaxBins; t++)
+ {
+ Printf("Bin %d; Content: %f; Chi2 Error: %f; Bias: %f; In percent: %.2f %.2f", t+1, base->GetBinContent(t+1), baseold->GetBinError(t+1), base->GetBinError(t+1), (base->GetBinContent(t+1) > 0) ? 100.0 * baseold->GetBinError(t+1) / base->GetBinContent(t+1) : -1, (base->GetBinContent(t+1) > 0) ? 100.0 * base->GetBinError(t+1) / base->GetBinContent(t+1) : -1);
+ if (base->GetBinContent(t+1) <= 0)
+ continue;
+ ratio1->SetBinContent(t+1, baseold->GetBinError(t+1) / base->GetBinContent(t+1));
+ ratio2->SetBinContent(t+1, base->GetBinError(t+1) / base->GetBinContent(t+1));
+ }
+
+ //new TCanvas; base->Draw(); gPad->SetLogy();
+
+ new TCanvas;
+ ratio1->GetYaxis()->SetRangeUser(0, 1);
+ ratio1->GetXaxis()->SetRangeUser(0, kMaxBins);
+ ratio1->Draw();
+ ratio2->SetLineColor(2);
+ ratio2->Draw("SAME");
+
+ return base;
+}
+
+void CheckBayesianBias()
+{
+ loadlibs();
+
+ const char* fileNameMC = "multiplicityMC.root";
+ const char* folder = "Multiplicity";
+ const char* fileNameESD = "multiplicityESD.root";
+ const char* folderESD = "Multiplicity";
+
+ AliMultiplicityCorrection* mult = AliMultiplicityCorrection::Open(fileNameMC, folder);
+ AliMultiplicityCorrection* esd = AliMultiplicityCorrection::Open(fileNameESD, folderESD);
+
+ const Int_t kMaxBins = 35;
+ AliUnfolding::SetNbins(kMaxBins, kMaxBins);
+ //AliUnfolding::SetDebug(1);
+
+ Int_t hID = 0;
+
+ TH2F* hist = esd->GetMultiplicityESD(hID);
+ mult->SetMultiplicityESD(hID, hist);
+
+ // without bias calculation
+ mult->ApplyBayesianMethod(hID, kFALSE, 0, 1, 10, 0, 1);
+ baseold = (TH1*) mult->GetMultiplicityESDCorrected(hID)->Clone("baseold");
+
+ // with bias calculation
+ mult->ApplyBayesianMethod(hID, kFALSE, 0, 1, 10, 0, 2);
+ base = (TH1*) mult->GetMultiplicityESDCorrected(hID)->Clone("base");
+
+ TH1* hist1 = new TH1F("hist1", "", 100, 0, 20);
+ TH1* hist2 = new TH1F("hist2", "", 100, 0, 20);
+
+ for (Int_t t = 0; t<kMaxBins; t++)
+ {
+ Printf("Bin %d; Content: %f; Randomization Error: %f; Bias: %f; In percent: %.2f %.2f", t+1, base->GetBinContent(t+1), baseold->GetBinError(t+1), base->GetBinError(t+1), (base->GetBinContent(t+1) > 0) ? 100.0 * baseold->GetBinError(t+1) / base->GetBinContent(t+1) : -1, (base->GetBinContent(t+1) > 0) ? 100.0 * base->GetBinError(t+1) / base->GetBinContent(t+1) : -1);
+
+ hist1->Fill((base->GetBinContent(t+1) > 0) ? 100.0 * baseold->GetBinError(t+1) / base->GetBinContent(t+1) : -1);
+ hist2->Fill((base->GetBinContent(t+1) > 0) ? 100.0 * base->GetBinError(t+1) / base->GetBinContent(t+1) : -1);
+ }
+
+ new TCanvas;
+ hist1->Draw();
+ hist2->SetLineColor(2);
+ hist2->Draw("SAME");
+}
+
+void DataScan(Bool_t redo = kTRUE)
+{
+ // makes a set of unfolded spectra and compares
+ // don't forget FindUnfoldedLimit in plots.C
+
+ loadlibs();
+
+ // files...
+ Bool_t mc = kTRUE;
+ const char* fileNameMC = "multiplicityMC.root";
+ const char* folder = "Multiplicity";
+ const char* fileNameESD = "multiplicityESD.root";
+ const char* folderESD = "Multiplicity";
+ Int_t hID = 0; const Int_t kMaxBins = 35;
+ //Int_t hID = 1; const Int_t kMaxBins = 60;
+ //Int_t hID = 2; const Int_t kMaxBins = 70;
+ AliMultiplicityCorrection::EventType eventType = AliMultiplicityCorrection::kTrVtx;
+ Bool_t evaluteBias = kFALSE;
+
+ Int_t referenceCase = 2; // all results are shown as ratio to this case
+
+ // chi2 range
+ AliUnfolding::RegularizationType regBegin = AliUnfolding::kPol0;
+ AliUnfolding::RegularizationType regEnd = AliUnfolding::kPol0;
+ Float_t regParamBegin[] = { 0, 1, 10 };
+ Float_t regParamEnd[] = { 0, 40, 101 };
+ Float_t regParamStep[] = { 0, TMath::Sqrt(10), TMath::Sqrt(10) };
+
+ // bayesian range
+ Int_t iterBegin = 5;
+ Int_t iterEnd = 21;
+ Int_t iterStep = 5;
+
+ TList labels;
+
+ AliMultiplicityCorrection* mult = AliMultiplicityCorrection::Open(fileNameMC, folder);
+ AliMultiplicityCorrection* esd = AliMultiplicityCorrection::Open(fileNameESD, folderESD);
+
+ mult->SetMultiplicityESD(hID, esd->GetMultiplicityESD(hID));
+
+ if (mc)
+ mult->SetMultiplicityMC(hID, eventType, esd->GetMultiplicityMC(hID, eventType));
+
+ AliUnfolding::SetNbins(kMaxBins, kMaxBins);
+ //AliUnfolding::SetDebug(1);
+
+ Int_t count = -1;
+
+ for (AliUnfolding::RegularizationType reg = regBegin; reg <= regEnd; reg++)
+ {
+ for (Float_t regParam = regParamBegin[reg]; regParam < regParamEnd[reg]; regParam *= regParamStep[reg])
+ {
+ count++;
+ labels.Add(new TObjString(Form("#chi^{2} Reg %d #beta = %.2f", (Int_t) reg, regParam)));
+
+ if (!redo)
+ continue;
+
+ AliUnfolding::SetChi2Regularization(reg, regParam);
+
+ mult->ApplyMinuitFit(hID, kFALSE, eventType, kFALSE, 0, evaluteBias);
+
+ file = TFile::Open(Form("datascan_%d.root", count), "RECREATE");
+ mult->SaveHistograms();
+ file->Close();
+ }
+ }
+
+ for (Int_t iter = iterBegin; iter <= iterEnd; iter += iterStep)
+ {
+ count++;
+ labels.Add(new TObjString(Form("Bayesian Iter = %d", iter)));
+
+ if (!redo)
+ continue;
+
+ mult->ApplyBayesianMethod(hID, kFALSE, eventType, 1, iter, 0, kTRUE);
+
+ file = TFile::Open(Form("datascan_%d.root", count), "RECREATE");
+ mult->SaveHistograms();
+ file->Close();
+ }
+
+ // 1) all distributions
+ // 2) ratio to MC
+ // 3) ratio to ref point
+ // 4) relative error
+ // 5) residuals
+ c = new TCanvas("c", "c", 1200, 800);
+ c->Divide(3, 2);
+
+ c->cd(1)->SetLogy();
+
+ // get reference point
+ mult = AliMultiplicityCorrection::Open(Form("datascan_%d.root", referenceCase));
+ if (!mult)
+ return;
+ refPoint = (TH1*) mult->GetMultiplicityESDCorrected(hID)->Clone("refPoint");
+
+ legend = new TLegend(0.5, 0.5, 0.99, 0.99);
+ legend->SetFillColor(0);
+
+ TH1* residualSum = new TH1F("residualSum", ";;residual squared sum", count + 1, 0.5, count + 1.5);
+
+ count = 0;
+ while (1)
+ {
+ mult = AliMultiplicityCorrection::Open(Form("datascan_%d.root", count++));
+ if (!mult)
+ break;
+
+ hist = (TH1*) mult->GetMultiplicityESDCorrected(hID);
+ hist->SetLineColor((count-1) % 4 + 1);
+ hist->SetLineStyle((count-1) / 4 + 1);
+ hist->GetXaxis()->SetRangeUser(0, kMaxBins);
+ hist->SetStats(kFALSE);
+ hist->SetTitle("");
+
+ legend->AddEntry(hist->Clone(), labels.At(count-1)->GetName());
+
+ c->cd(1);
+ hist->DrawCopy((count == 1) ? "HIST" : "HISTSAME");
+
+ if (mc)
+ {
+ TH2* mcHist2d = mult->GetMultiplicityMC(hID, eventType);
+ mcHist = mcHist2d->ProjectionY("mcmchist", 1, mcHist2d->GetNbinsX());
+
+ c->cd(1);
+ mcHist->SetMarkerStyle(24);
+ mcHist->Draw("P SAME");
+
+ c->cd(2);
+ // calculate ratio using only the error on the mc bin
+ ratio = (TH1*) hist->Clone("ratio");
+ for (Int_t bin=1; bin<=ratio->GetNbinsX(); bin++)
+ {
+ if (mcHist->GetBinContent(bin) <= 0)
+ continue;
+ ratio->SetBinContent(bin, hist->GetBinContent(bin) / mcHist->GetBinContent(bin));
+ ratio->SetBinError(bin, mcHist->GetBinError(bin) / mcHist->GetBinContent(bin) * ratio->GetBinContent(bin));
+ }
+
+ ratio->GetYaxis()->SetRangeUser(0.5, 1.5);
+ ratio->GetYaxis()->SetTitle("Ratio unfolded / MC");
+ ratio->DrawCopy((count == 1) ? "HIST" : "HISTSAME");
+ }
+
+ c->cd(3);
+ // calculate ratio using no errors for now
+ ratio = (TH1*) hist->Clone("ratio");
+ for (Int_t bin=1; bin<=ratio->GetNbinsX(); bin++)
+ {
+ if (refPoint->GetBinContent(bin) <= 0)
+ continue;
+ ratio->SetBinContent(bin, hist->GetBinContent(bin) / refPoint->GetBinContent(bin));
+ ratio->SetBinError(bin, 0);
+ }
+
+ ratio->GetYaxis()->SetRangeUser(0.5, 1.5);
+ ratio->GetYaxis()->SetTitle("Ratio unfolded / unfolded reference case");
+ ratio->DrawCopy((count == 1) ? "" : "SAME");
+
+ c->cd(4);
+ ratio = (TH1*) hist->Clone("ratio");
+ for (Int_t bin=1; bin<=ratio->GetNbinsX(); bin++)
+ {
+ if (ratio->GetBinContent(bin) <= 0)
+ continue;
+ ratio->SetBinContent(bin, ratio->GetBinError(bin) / ratio->GetBinContent(bin));
+ ratio->SetBinError(bin, 0);
+ }
+ ratio->GetYaxis()->SetRangeUser(0, 1);
+ ratio->GetYaxis()->SetTitle("Relative error");
+ ratio->DrawCopy((count == 1) ? "" : "SAME");
+
+ c->cd(5);
+ Float_t sum;
+ residuals = mult->GetResiduals(hID, AliMultiplicityCorrection::kTrVtx, sum);
+ residuals->SetStats(0);
+ residuals->GetXaxis()->SetRangeUser(0, kMaxBins);
+ residuals->SetStats(kFALSE);
+ residuals->SetLineColor((count-1) % 4 + 1);
+ residuals->SetLineStyle((count-1) / 4 + 1);
+ residuals->GetYaxis()->SetRangeUser(-5, 5);
+ residuals->DrawCopy((count == 1) ? "" : "SAME");
+
+ residualSum->Fill(count, sum);
+ residualSum->GetXaxis()->SetBinLabel(count, labels.At(count-1)->GetName());
+ }
+
+ c->cd(6);
+ residualSum->Draw();
+ legend->Draw();
+}
+
void DrawBayesianIterations(const char* fileNameMC = "multiplicityMC.root", const char* fileNameESD = "multiplicityESD.root", Int_t histID = 1, Int_t eventType = 0 /* AliMultiplicityCorrection::kTrVtx */)
{
loadlibs();
//mult->ApplyLaszloMethod(2, kFALSE, AliMultiplicityCorrection::kTrVtx);
}
-void smoothCorrelationMap(const char* fileName = "multiplicityMC.root", Int_t corrMatrix = 2)
+void smoothCorrelationMap(const char* fileName = "multiplicity.root", Int_t corrMatrix = 1)
{
gSystem->Load("libPWG0base");
const char* fitWith = "gaus";
- for (Int_t i=1; i<=150; ++i)
+ for (Int_t i=1; i<=80; ++i)
{
printf("Fitting %d...\n", i);
pad->SetLogy();
}
- scaling->Fill(i, func->GetParameter(0));
- mean->Fill(i, func->GetParameter(1));
- width->Fill(i, func->GetParameter(2));
+ scaling->SetBinContent(i, func->GetParameter(0));
+ mean->SetBinContent(i, func->GetParameter(1));
+ width->SetBinContent(i, func->GetParameter(2));
+
+ scaling->SetBinError(i, func->GetParError(0));
+ mean->SetBinError(i, func->GetParError(1));
+ width->SetBinError(i, func->GetParError(2));
}
TF1* log = new TF1("log", "[0] + [1] * log([2] * x)", 0.01, 500);
scaling->Fit(scalingFit, "", "", 3, 140);
scalingFit->SetRange(0, 200);
scalingFit->Draw("SAME");
-
+
c1->cd(2);
mean->Draw("P");
width->Fit(widthFit, "", "", 5, 140);
widthFit->SetRange(0, 200);
widthFit->Draw("SAME");
-
+
// build new correction matrix
TH2* new = (TH2*) proj->Clone("new");
new->Reset();
for (Int_t i=1; i<=new->GetNbinsX(); ++i)
for (Int_t j=1; j<=new->GetNbinsY(); ++j)
- corr->SetBinContent(corr->GetXaxis()->GetNbins() / 2, i, j, new->GetBinContent(i, j));
+ corr->SetBinContent(corr->GetXaxis()->GetNbins() / 2 + 1, i, j, new->GetBinContent(i, j));
new TCanvas;
corr->Project3D("zy")->Draw("COLZ");
// SPD TPC
//const char* fileName[] = { "multiplicityMC_400k_syst.root", "multiplicityMC_TPC_4kfiles_syst.root" };
+ const char* fileName[] = { "LHC09b9_0.9TeV_0T/mb1/spd/multiplicity.root", "LHC09b8_0.9TeV_0.5T/mb1/tpc/multiplicity.root" };
//const char* fileName[] = { "spd/multiplicity.root", "tpc/multiplicity.root" };
- const char* fileName[] = { "multiplicity.root", "multiplicity.root" };
+ //const char* fileName[] = { "multiplicity.root", "multiplicity.root" };
Float_t etaRangeArr[] = {0.49, 0.9};
const char* titles[] = { "SPD Tracklets", "TPC Tracks" };
TLegend* legends[2];
- for (Int_t loop=1; loop<2; ++loop)
+ for (Int_t loop=0; loop<2; ++loop)
{
Printf("%s", fileName[loop]);
Float_t sumGen = 0;
Float_t sumMeas = 0;
+ Float_t sumGenAbove02 = 0;
+ Float_t sumMeasAbove02 = 0;
+
for (Int_t i=0; i<3; ++i)
{
Printf("correction %d", i);
TH1* genePt = gene->Project3D(Form("z_%d", i));
TH1* measPt = meas->Project3D(Form("z_%d", i));
+
+ if (i == 2)
+ {
+ Printf("WARNING: Rebinning for protons!");
+ genePt->Rebin(2);
+ measPt->Rebin(2);
+ }
genePt->Sumw2();
measPt->Sumw2();
sumGen += genePt->Integral();
sumMeas += measPt->Integral();
+ sumGenAbove02 += genePt->Integral(genePt->GetXaxis()->FindBin(0.21), genePt->GetNbinsX());
+ sumMeasAbove02 += measPt->Integral(genePt->GetXaxis()->FindBin(0.21), genePt->GetNbinsX());
+
TH1* effPt = (TH1*) genePt->Clone(Form("effPt_%d", i));
effPt->Reset();
effPt->Divide(measPt, genePt, 1, 1, "B");
Printf("In total %.4f of the particles are below their effective pt cut off", (Float_t) below / total);
Printf("%f measured, %f generated, effiency: %f", sumGen, sumMeas, sumMeas / sumGen);
+ Printf("Above 0.2 GeV/c: %f measured, %f generated, effiency: %f", sumGenAbove02, sumMeasAbove02, sumMeasAbove02 / sumGenAbove02);
canvas->cd(loop+1);
legend->Draw();
TH1* mcHist = mult2->GetMultiplicityVtx(etaRange)->ProjectionY("mymc", 1, 1);
- mult->SetRegularizationParameters(AliMultiplicityCorrection::kPol0, 1e5);
+ AliUnfolding::SetNbins(70, 70);
+ //AliUnfolding::SetNbins(35, 35);
+ AliUnfolding::SetChi2Regularization(AliUnfolding::kPol0, 1e3);
+ AliUnfolding::SetBayesianParameters(1, 10);
+
+ TH1* errorMeasured = (TH1*) mult->StatisticalUncertainty((AliUnfolding::MethodType) methodType, etaRange, kFALSE, AliMultiplicityCorrection::kTrVtx, kTRUE, kFALSE, ((mc) ? mcHist : 0))->Clone("errorMeasured");
- TH1* errorMeasured = (TH1*) mult->StatisticalUncertainty((AliMultiplicityCorrection::MethodType) methodType, etaRange, kFALSE, AliMultiplicityCorrection::kTrVtx, kTRUE, kFALSE, ((mc) ? mcHist : 0))->Clone("errorMeasured");
+ new TCanvas; errorMeasured->Draw();
+ new TCanvas;
+
+ mult->GetMultiplicityESDCorrected(etaRange)->Scale(1.0 / mult->GetMultiplicityESDCorrected(etaRange)->Integral());
+ mult->GetMultiplicityESDCorrected(etaRange)->Draw();
+ mcHist->Scale(1.0 / mcHist->Integral());
+ mcHist->SetLineColor(2);
+ mcHist->Draw("SAME");
+ gPad->SetLogy();
return;
- TH1* errorResponse = (TH1*) mult->StatisticalUncertainty((AliMultiplicityCorrection::MethodType) methodType, etaRange, kFALSE, AliMultiplicityCorrection::kTrVtx, kFALSE, kTRUE, ((mc) ? mcHist : 0))->Clone("errorResponse");
+ TH1* errorResponse = (TH1*) mult->StatisticalUncertainty((AliUnfolding::MethodType) methodType, etaRange, kFALSE, AliMultiplicityCorrection::kTrVtx, kFALSE, kTRUE, ((mc) ? mcHist : 0))->Clone("errorResponse");
- TH1* errorBoth = (TH1*) mult->StatisticalUncertainty((AliMultiplicityCorrection::MethodType) methodType, etaRange, kFALSE, AliMultiplicityCorrection::kTrVtx, kTRUE, kTRUE, ((mc) ? mcHist : 0))->Clone("errorBoth");
+ TH1* errorBoth = (TH1*) mult->StatisticalUncertainty((AliUnfolding::MethodType) methodType, etaRange, kFALSE, AliMultiplicityCorrection::kTrVtx, kTRUE, kTRUE, ((mc) ? mcHist : 0))->Clone("errorBoth");
if (!mc)
{
legend->SetFillColor(0);
legend->SetTextSize(0.04);
- Int_t displayRanges[] = { 50, 80, 120 };
+ Int_t displayRanges[] = { 30, 45, 65 };
- TH2* dummy = new TH2F("dummy", ";True multiplicity N_{ch};P(N_{ch})", 100, -0.5, displayRanges[2]+10, 1000, 5e-5, 5);
+ TH2* dummy = new TH2F("dummy", ";True multiplicity N_{ch};P(N_{ch})", 100, -0.5, displayRanges[2]+10, 1000, 5e-6, 5);
dummy->SetStats(0);
dummy->Draw();
TString tmpStr;
tmpStr.Form("|#eta| < %.1f (x %d)", etaRangeArr[etaR], (Int_t) TMath::Power(5, etaR));
if (etaR == 0)
- Tl->DrawLatex(36, result->GetBinContent(41), tmpStr);
+ Tl->DrawLatex(15, result->GetBinContent(20), tmpStr);
if (etaR == 1)
{
Tl->SetTextAlign(12);
- Tl->DrawLatex(82, result->GetBinContent(81), tmpStr);
+ Tl->DrawLatex(40, result->GetBinContent(40), tmpStr);
}
if (etaR == 2)
{
Tl->SetTextAlign(12);
- Tl->DrawLatex(106, result->GetBinContent(101), tmpStr);
+ Tl->DrawLatex(60, result->GetBinContent(50), tmpStr);
}
}
//mult->ApplyBayesianMethod(0, kFALSE, AliMultiplicityCorrection::kTrVtx, 0, -1, 0, kFALSE);
mult->DrawComparison("BlobelExample", 0, kFALSE, kTRUE, mult->GetMultiplicityVtx(0)->ProjectionY("mcmchist", 1, mult->GetMultiplicityVtx(0)->GetNbinsX()));
+}
+
+void TestWithDiagonalMatrix()
+{
+ const Int_t kSize = 20;
+
+ TMatrixD matrix(kSize, kSize);
+ for (Int_t x=0; x<kSize; x++)
+ matrix(x, x) = 1;
+
+ if (1)
+ {
+ for (Int_t x=0; x<kSize; x++)
+ {
+ for (Int_t y=0; y<kSize; y++)
+ {
+ if (x == y)
+ {
+ if (x == 0 || x == kSize -1)
+ {
+ matrix(x, y) = 0.75;
+ }
+ else
+ matrix(x, y) = 0.5;
+ }
+ else if (TMath::Abs(x - y) == 1)
+ {
+ matrix(x, y) = 0.25;
+ }
+ }
+ }
+ }
+
+ //matrix.Print();
+
+ TH1F* inputDist = new TH1F("inputDist", ";t;Entries", kSize, -0.5, (Float_t) kSize - 0.5);
+ TVectorD inputDistVector(kSize);
+
+ TH1F* measuredIdealDist = inputDist->Clone("measuredIdealDist");
+ measuredIdealDist->SetTitle(";m;Entries");
+ TH1F* measuredDist = measuredIdealDist->Clone("measuredDist");
+
+ TF1* gaus = new TF1("func", "gaus(0)", -0.5, kSize);
+ // norm: 1/(sqrt(2pi)sigma)
+ gaus->SetParameters(10000 / sqrt(2 * TMath::Pi()) / ((Float_t) kSize / 8), (Float_t) kSize / 2, (Float_t) kSize / 8);
+ //gaus->Print();
+
+ for (Int_t x=1; x<=inputDist->GetNbinsX(); x++)
+ {
+ Float_t value = gaus->Eval(inputDist->GetBinCenter(x));
+ inputDist->SetBinContent(x, value);
+ inputDistVector(x-1) = value;
+ }
+
+ TVectorD measuredDistIdealVector = matrix * inputDistVector;
+ for (Int_t x=1; x<=measuredIdealDist->GetNbinsX(); x++)
+ measuredIdealDist->SetBinContent(x, measuredDistIdealVector(x-1));
+
+ // randomize
+ //measuredDist->FillRandom(measuredIdealDist, 10000);
+ measuredDist = measuredIdealDist;
+ measuredDist->Sumw2();
+ for (Int_t x=0; x<kSize; x++)
+ Printf("bin %d %.2f +- %.2f", x+1, measuredDist->GetBinContent(x+1), measuredDist->GetBinError(x+1));
+
+ // now unfold this
+ loadlibs();
+
+ // fill a multiplicity object
+ mult = new AliMultiplicityCorrection("mult", "mult");
+ for (Int_t x=0; x<kSize; x++)
+ {
+ mult->GetMultiplicityVtx(0)->SetBinContent(1, x+1, inputDistVector(x));
+ mult->GetMultiplicityESD(0)->SetBinContent(1, x+1, measuredDist->GetBinContent(x+1));
+ for (Int_t y=0; y<kSize; y++)
+ mult->GetCorrelation(0)->SetBinContent(1, x+1, y+1, matrix(x, y));
+ }
+
+ //mult->DrawHistograms();
+
+ AliUnfolding::SetNbins(20, 20);
+ AliUnfolding::SetChi2Regularization(AliUnfolding::kNone, 0);
+ AliUnfolding::SetChi2Regularization(AliUnfolding::kPol1, 1e-14);
+ //mult->SetCreateBigBin(kFALSE);
+ mult->ApplyMinuitFit(0, kFALSE, AliMultiplicityCorrection::kTrVtx, kFALSE); //hist2->ProjectionY("mymchist"));
+
+ //mult->ApplyBayesianMethod(0, kFALSE, AliMultiplicityCorrection::kTrVtx, 0, -1, 0, kFALSE);
+
+ mult->DrawComparison("TestWithDiagonalMatrix", 0, kFALSE, kTRUE, mult->GetMultiplicityVtx(0)->ProjectionY("mcmchist", 1, mult->GetMultiplicityVtx(0)->GetNbinsX()));
}
+
void E735Fit()
{
TH1* fCurrentESD = new TH1F("mult", "mult", 501, -0.5, 500.5);
}
+
+void FindUnfoldedLimit()
+{
+ loadlibs();
+
+ AliMultiplicityCorrection* mult = AliMultiplicityCorrection::Open("multiplicityMC.root");
+ AliMultiplicityCorrection* esd = AliMultiplicityCorrection::Open("multiplicityESD.root");
+
+ TH1* hist = mult->GetCorrelation(etaRange);
+ for (Int_t y=0; y<=hist->GetYaxis()->GetNbins()+1; ++y)
+ {
+ for (Int_t z=0; z<=hist->GetZaxis()->GetNbins()+1; ++z)
+ {
+ hist->SetBinContent(0, y, z, 0);
+ hist->SetBinContent(hist->GetXaxis()->GetNbins()+1, y, z, 0);
+ }
+ }
+ TH2* corr = (TH2*) ((TH3*) mult->GetCorrelation(etaRange))->Project3D("zy");
+
+ TH1* esd_proj = esd->GetMultiplicityESD(etaRange)->ProjectionY("esd_proj", 1, esd->GetMultiplicityESD(etaRange)->GetNbinsX());
+ //esd_proj = corr->ProjectionY("esd_proj", 1, corr->GetNbinsX());
+
+ new TCanvas; corr->Draw("COLZ");
+ new TCanvas; esd_proj->DrawCopy();
+
+ TH1* percentage = (TH1*) (esd_proj->Clone("percentage"));
+ percentage->Reset();
+
+ for (Int_t i=1; i<=esd_proj->GetNbinsX(); i++)
+ if (esd_proj->GetBinContent(i) > 0)
+ esd_proj->SetBinContent(i, 1);
+
+ for (Int_t i=1; i<=percentage->GetNbinsX(); i++)
+ {
+ TH1* binResponse = corr->ProjectionY("proj", i, i);
+ if (binResponse->Integral() <= 0)
+ continue;
+ binResponse->Scale(1.0 / binResponse->Integral());
+ binResponse->Multiply(esd_proj);
+ //new TCanvas; binResponse->Draw();
+ percentage->SetBinContent(i, binResponse->Integral());
+ //return;
+ }
+
+ new TCanvas; percentage->Draw();
+ new TCanvas;
+ mc = esd->GetMultiplicityVtx(etaRange)->ProjectionY("mc", 1, esd->GetMultiplicityVtx(etaRange)->GetNbinsX());
+ mc->SetLineColor(2);
+ mc->Draw("");
+}
+
+void CompareUnfoldedWithMC()
+{
+ loadlibs();
+
+ AliMultiplicityCorrection* mult = AliMultiplicityCorrection::Open("unfolded.root");
+
+ //mult->GetMultiplicityESDCorrected(etaRange)->Scale(1.0 / mult->GetMultiplicityESDCorrected(etaRange)->Integral());
+ mult->GetMultiplicityESDCorrected(etaRange)->SetTitle(";multiplicity;events");
+ mult->GetMultiplicityESDCorrected(etaRange)->SetStats(0);
+ mult->GetMultiplicityESDCorrected(etaRange)->Draw();
+ //mcHist->Scale(1.0 / mcHist->Integral());
+ mcHist = mult->GetMultiplicityVtx(etaRange)->ProjectionY("mymc", 1, 1);
+ mcHist->SetLineColor(2);
+ mcHist->Draw("SAME");
+ gPad->SetLogy();
+}
if (aProof)
{
+ gEnv->SetValue("XSec.GSI.DelegProxy", "2");
TProof::Open("alicecaf");
//gProof->SetParallel(1);
// Create the analysis manager
mgr = new AliAnalysisManager;
- AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD;
- AliPWG0Helper::Trigger trigger = AliPWG0Helper::kMB1;
+ AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPC | AliPWG0Helper::kFieldOn;
+ AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kMB1;
AliPWG0Helper::PrintConf(analysisMode, trigger);
task = new AliMultiplicityTask(option);
- if (analysisMode != AliPWG0Helper::kSPD)
+ if (!(analysisMode & AliPWG0Helper::kSPD))
{
// selection of esd tracks
gROOT->ProcessLine(".L ../CreateStandardCuts.C");
#include <AliAnalysisManager.h>
#include <AliESDInputHandler.h>
#include <AliESDHeader.h>
-#include <AliOfflineTrigger.h>
+#include <AliTriggerAnalysis.h>
ClassImp(AliTriggerTask)
fNTriggers(0),
fTriggerList(0),
fStats(0),
- fOfflineTrigger(0)
+ fTrigger(0)
{
//
// Constructor. Initialization of pointers
fNTriggers = 13;
- static AliPWG0Helper::Trigger triggerList[] = { AliPWG0Helper::kAcceptAll, AliPWG0Helper::kFPANY, AliPWG0Helper::kMB1, AliPWG0Helper::kMB2, AliPWG0Helper::kMB3, AliPWG0Helper::kSPDGFO, AliPWG0Helper::kV0A, AliPWG0Helper::kV0C, AliPWG0Helper::kZDC, AliPWG0Helper::kZDCA, AliPWG0Helper::kZDCC, AliPWG0Helper::kFMDA, AliPWG0Helper::kFMDC };
+ static AliTriggerAnalysis::Trigger triggerList[] = { AliTriggerAnalysis::kAcceptAll, AliTriggerAnalysis::kFPANY, AliTriggerAnalysis::kMB1, AliTriggerAnalysis::kMB2, AliTriggerAnalysis::kMB3, AliTriggerAnalysis::kSPDGFO, AliTriggerAnalysis::kV0A, AliTriggerAnalysis::kV0C, AliTriggerAnalysis::kZDC, AliTriggerAnalysis::kZDCA, AliTriggerAnalysis::kZDCC, AliTriggerAnalysis::kFMDA, AliTriggerAnalysis::kFMDC };
fTriggerList = triggerList;
fStats = new TH1*[fNTriggers];
- fOfflineTrigger = new AliOfflineTrigger;
- fOfflineTrigger->EnableHistograms();
+ fTrigger = new AliTriggerAnalysis;
+ fTrigger->EnableHistograms();
AliLog::SetClassDebugLevel("AliTriggerTask", AliLog::kWarning);
}
nBins = fEndTime - fStartTime;
for (Int_t i=0; i<fNTriggers; i++)
{
- fStats[i] = new TH1F(Form("fStats_%d", i), Form("%s;time;counts", AliPWG0Helper::GetTriggerName(fTriggerList[i])), nBins, 0, fEndTime - fStartTime);
+ fStats[i] = new TH1F(Form("fStats_%d", i), Form("%s;time;counts", AliTriggerAnalysis::GetTriggerName(fTriggerList[i])), nBins, 0, fEndTime - fStartTime);
fOutput->Add(fStats[i]);
}
- fOutput->Add(fOfflineTrigger);
+ fOutput->Add(fTrigger);
}
void AliTriggerTask::Exec(Option_t*)
//Printf("Trigger classes: %s:", fESD->GetFiredTriggerClasses().Data());
- fOfflineTrigger->FillHistograms(fESD);
+ fTrigger->FillHistograms(fESD);
UInt_t timeStamp = fESD->GetTimeStamp() - fStartTime;
//Printf("%d", timeStamp);
for (Int_t i = 0; i < fNTriggers; i++)
{
- Bool_t triggered = fOfflineTrigger->IsEventTriggered(fESD, fTriggerList[i]);
+ Bool_t triggered = fTrigger->IsOfflineTriggerFired(fESD, fTriggerList[i]);
if (triggered)
fStats[i]->Fill(timeStamp);
- //Printf("%s: %d", AliPWG0Helper::GetTriggerName(fTriggerList[i]), triggered);
+ //Printf("%s: %d", AliTriggerAnalysis::GetTriggerName(fTriggerList[i]), triggered);
}
}
{
for (Int_t i=0; i<fNTriggers; i++)
fStats[i] = dynamic_cast<TH1*> (fOutput->FindObject(Form("fStats_%d", i)));
- fOfflineTrigger = dynamic_cast<AliOfflineTrigger*> (fOutput->FindObject("AliOfflineTrigger"));
+ fTrigger = dynamic_cast<AliTriggerAnalysis*> (fOutput->FindObject("AliTriggerAnalysis"));
}
TFile* fout = new TFile("trigger.root", "RECREATE");
for (Int_t i=0; i<fNTriggers; i++)
if (fStats[i])
fStats[i]->Write();
- if (fOfflineTrigger)
- fOfflineTrigger->WriteHistograms();
+ if (fTrigger)
+ fTrigger->WriteHistograms();
fout->Write();
fout->Close();
{
c->cd(i+1);
fStats[i]->Draw();
- Printf("%s: %d triggers | %f %% of all triggered | Rate: %f Hz", AliPWG0Helper::GetTriggerName(fTriggerList[i]), (UInt_t) fStats[i]->Integral(), 100.0 * fStats[i]->Integral() / base, (length > 0) ? (fStats[i]->Integral() / length) : -1);
+ Printf("%s: %d triggers | %f %% of all triggered | Rate: %f Hz", AliTriggerAnalysis::GetTriggerName(fTriggerList[i]), (UInt_t) fStats[i]->Integral(), 100.0 * fStats[i]->Integral() / base, (length > 0) ? (fStats[i]->Integral() / length) : -1);
}
Printf("Writting result to trigger.root");
class TH1;
class AliESDEvent;
-class AliOfflineTrigger;
+class AliTriggerAnalysis;
class AliTriggerTask : public AliAnalysisTask {
public:
UInt_t fEndTime; // run end time
Int_t fNTriggers; //! number triggers
- AliPWG0Helper::Trigger* fTriggerList; //! list of triggers
+ AliTriggerAnalysis::Trigger* fTriggerList; //! list of triggers
TH1** fStats; //! trigger stats
- AliOfflineTrigger* fOfflineTrigger; // offline trigger object
+ AliTriggerAnalysis* fTrigger; // trigger object
private:
AliTriggerTask(const AliTriggerTask&);
void show(const char* fileName = "trigger.root")
{
+ TH1* fStats[100];
+
TFile::Open(fileName);
Int_t count = 0;
c->SaveAs(Form("trigger_%d.png", count));
Printf("%s: %d", hist->GetTitle(), (Int_t) hist->GetEntries());
+ fStats[count] = hist;
count++;
}
+
+ Int_t base = 1;
+ if (fStats[0])
+ base = (Int_t) fStats[0]->Integral();
+
+ for (Int_t i=0; i<count; i++)
+ if (fStats[i])
+ {
+ c->cd(i+1);
+ fStats[i]->Draw();
+ Printf("%s: %d triggers | %f %% of all triggered", fStats[i]->GetTitle(), (UInt_t) fStats[i]->Integral(), 100.0 * fStats[i]->Integral() / base);
+ }
+
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff