[u/mrichter/AliRoot.git] / PWG0 / AliTriggerAnalysis.cxx

/* $Id: AliTriggerAnalysis.cxx 35782 2009-10-22 11:54:31Z jgrosseo $ */

/**************************************************************************
 * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//-------------------------------------------------------------------------
//                      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 <TH2F.h>
#include <TList.h>
#include <TIterator.h>

#include <AliTriggerAnalysis.h>

#include <AliLog.h>

#include <AliESDEvent.h>

#include <AliMultiplicity.h>
#include <AliESDVZERO.h>
#include <AliESDZDC.h>
#include <AliESDFMD.h>

ClassImp(AliTriggerAnalysis)

AliTriggerAnalysis::AliTriggerAnalysis() :
  fSPDGFOThreshold(2),
  fV0AThreshold(1),
  fV0CThreshold(1),
  fFMDLowCut(0.2),
  fFMDHitCut(0.5),
  fHistSPD(0),
  fHistBitsSPD(0),
  fHistV0A(0),       
  fHistV0C(0),    
  fHistZDC(0),    
  fHistFMDA(0),    
  fHistFMDC(0),   
  fHistFMDSingle(0),
  fHistFMDSum(0)
{
}

void AliTriggerAnalysis::EnableHistograms()
{
  // creates the monitoring histograms
  
  fHistSPD = new TH1F("fHistSPD", "SPD GFO;number of fired chips;events", 1202, -1.5, 1200.5);
  fHistBitsSPD = new TH2F("fHistBitsSPD", "SPD GFO;number of fired chips (offline);number of fired chips (hardware)", 1202, -1.5, 1200.5, 1202, -1.5, 1200.5);
  fHistV0A = new TH1F("fHistV0A", "V0A;number of BB triggers;events", 34, -1.5, 32.5);
  fHistV0C = new TH1F("fHistV0C", "V0C;number of BB triggers;events", 34, -1.5, 32.5);
  fHistZDC = new TH1F("fHistZDC", "ZDC;trigger bits;events", 8, -1.5, 6.5);
  
  // TODO check limits
  fHistFMDA = new TH1F("fHistFMDA", "FMDA;combinations above threshold;events", 102, -1.5, 100.5);
  fHistFMDC = new TH1F("fHistFMDC", "FMDC;combinations above threshold;events", 102, -1.5, 100.5);
  fHistFMDSingle = new TH1F("fHistFMDSingle", "FMD single;multiplicity value;counts", 1000, 0, 10);
  fHistFMDSum = new TH1F("fHistFMDSum", "FMD sum;multiplicity value;counts", 1000, 0, 10);
}

//____________________________________________________________________
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) kStartOfFlags;
  
  switch (triggerNoFlags)
  {
    case kAcceptAll:
    {
      return kTRUE;
      break;
    }
    case kMB1:
    {
      if (SPDGFOTrigger(aEsd) || V0Trigger(aEsd, kASide) || V0Trigger(aEsd, kCSide))
        return kTRUE;
      break;
    }
    case kMB2:
    {
      if (SPDGFOTrigger(aEsd) && (V0Trigger(aEsd, kASide) || V0Trigger(aEsd, kCSide)))
        return kTRUE;
      break;
    }
    case kMB3:
    {
      if (SPDGFOTrigger(aEsd) && V0Trigger(aEsd, kASide) && V0Trigger(aEsd, kCSide))
        return kTRUE;
      break;
    }
    case kSPDGFO:
    {
      if (SPDGFOTrigger(aEsd))
        return kTRUE;
      break;
    }
    case kV0A:
    {
      if (V0Trigger(aEsd, kASide))
        return kTRUE;
      break;
    }
    case kV0C:
    {
      if (V0Trigger(aEsd, kCSide))
        return kTRUE;
      break;
    }
    case kZDC:
    {
      if (ZDCTrigger(aEsd, kASide) || ZDCTrigger(aEsd, kCentralBarrel) || ZDCTrigger(aEsd, kCSide))
        return kTRUE;
      break;
    }
    case kZDCA:
    {
      if (ZDCTrigger(aEsd, kASide))
        return kTRUE;
      break;
    }
    case kZDCC:
    {
      if (ZDCTrigger(aEsd, kCSide))
        return kTRUE;
      break;
    }
    case kFMDA:
    {
      if (FMDTrigger(aEsd, kASide))
        return kTRUE;
      break;
    }
    case kFMDC:
    {
      if (FMDTrigger(aEsd, kCSide))
        return kTRUE;
      break;
    }
    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;
      break;
    }
    default:
    {
      AliFatal(Form("Trigger type %d not implemented", triggerNoFlags));
    }
  }
  
  return kFALSE;
}


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
  
  fHistSPD->Fill(SPDFiredChips(aEsd));
  fHistBitsSPD->Fill(SPDFiredChips(aEsd, 0), SPDFiredChips(aEsd, 1));
  
  fHistV0A->Fill(V0BBTriggers(aEsd, kASide));  
  fHistV0C->Fill(V0BBTriggers(aEsd, kCSide));
  
  AliESDZDC* zdcData = aEsd->GetESDZDC();
  if (zdcData)
  {
    UInt_t quality = zdcData->GetESDQuality();
    
    // from Nora's presentation, general first physics meeting 16.10.09
    static UInt_t zpc  = 0x20;
    static UInt_t znc  = 0x10;
    static UInt_t zem1 = 0x08;
    static UInt_t zem2 = 0x04;
    static UInt_t zpa  = 0x02;
    static UInt_t zna  = 0x01;
   
    fHistZDC->Fill(1, quality & zna);
    fHistZDC->Fill(2, quality & zpa);
    fHistZDC->Fill(3, quality & zem2);
    fHistZDC->Fill(4, quality & zem1);
    fHistZDC->Fill(5, quality & znc);
    fHistZDC->Fill(6, quality & zpc);
  }
  else
  {
    fHistZDC->Fill(-1);
    AliError("AliESDZDC not available");
  }
  
  fHistFMDA->Fill(FMDHitCombinations(aEsd, kASide, kTRUE));
  fHistFMDC->Fill(FMDHitCombinations(aEsd, kCSide, kTRUE));
}

Int_t AliTriggerAnalysis::SPDFiredChips(const AliESDEvent* aEsd, Int_t origin) const
{
  // returns the number of fired chips in the SPD
  //
  // origin = 0 --> aEsd->GetMultiplicity()->GetNumberOfFiredChips() (filled from clusters)
  // origin = 1 --> aEsd->GetMultiplicity()->TestFastOrFiredChips() (from hardware bits)
  
  const AliMultiplicity* mult = aEsd->GetMultiplicity();
  if (!mult)
  {
    AliError("AliMultiplicity not available");
    return -1;
  }
  
  if (origin == 0)
    return mult->GetNumberOfFiredChips(0) + mult->GetNumberOfFiredChips(1);
    
  if (origin == 1)
  {
    Int_t nChips = 0;
    for (Int_t i=0; i<1200; i++)
      if (mult->TestFastOrFiredChips(i) == kTRUE)
        nChips++;
    return nChips;
  }
  
  return -1;
}

Bool_t AliTriggerAnalysis::SPDGFOTrigger(const AliESDEvent* aEsd) const
{
  // Returns if the SPD gave a global Fast OR trigger
  
  Int_t firedChips = SPDFiredChips(aEsd);
  
  if (firedChips >= fSPDGFOThreshold)
    return kTRUE;
  return kFALSE;
}

Int_t AliTriggerAnalysis::V0BBTriggers(const AliESDEvent* aEsd, AliceSide side) const
{
  // returns the number of BB triggers in V0A | V0C
  
  AliESDVZERO* v0Data = aEsd->GetVZEROData();
  if (!v0Data)
  {
    AliError("AliESDVZERO not available");
    return -1;
  }
  
  Int_t count = 0;
  for (Int_t i=0; i<32; i++)
  {
    if (side == kASide && v0Data->BBTriggerV0A(i))
      count++;
    if (side == kCSide && v0Data->BBTriggerV0C(i))
      count++;
  }
  
  return count;
}

Bool_t AliTriggerAnalysis::V0Trigger(const AliESDEvent* aEsd, AliceSide side) const
{
  // Returns if the V0 triggered
  
  Int_t count = V0BBTriggers(aEsd, side);
  
  if (side == kASide && count >= fV0AThreshold)
    return kTRUE;
  if (side == kCSide && count >= fV0CThreshold)
    return kTRUE;
  return kFALSE;
}

Bool_t AliTriggerAnalysis::ZDCTrigger(const AliESDEvent* aEsd, AliceSide side) const
{
  // Returns if ZDC triggered
  
  AliESDZDC* zdcData = aEsd->GetESDZDC();
  if (!zdcData)
  {
    AliError("AliESDZDC not available");
    return kFALSE;
  }
  
  UInt_t quality = zdcData->GetESDQuality();
  
  // from Nora's presentation, general first physics meeting 16.10.09
  static UInt_t zpc  = 0x20;
  static UInt_t znc  = 0x10;
  static UInt_t zem1 = 0x08;
  static UInt_t zem2 = 0x04;
  static UInt_t zpa  = 0x02;
  static UInt_t zna  = 0x01;
  
  if (side == kASide && ((quality & zpa) || (quality & zna)))
    return kTRUE;
  if (side == kCentralBarrel && ((quality & zem1) || (quality & zem2)))
    return kTRUE;
  if (side == kCSide && ((quality & zpc) || (quality & znc)))
    return kTRUE;
  
  return kFALSE;
}

Int_t AliTriggerAnalysis::FMDHitCombinations(const AliESDEvent* aEsd, AliceSide side, Bool_t fillHistograms) const
{
  // returns number of hit combinations agove threshold
  //
  // Authors: FMD team, Hans Dalsgaard (code merged from FMD/AliFMDOfflineTrigger)

  // Workaround for AliESDEvent::GetFMDData is not const!
  const AliESDFMD* fmdData = (const_cast<AliESDEvent*>(aEsd))->GetFMDData();
  if (!fmdData)
  {
    AliError("AliESDFMD not available");
    return -1;
  }

  Int_t detFrom = (side == kASide) ? 1 : 3;
  Int_t detTo   = (side == kASide) ? 2 : 3;

  Int_t triggers = 0;
  Float_t totalMult = 0;
  for (UShort_t det=detFrom;det<=detTo;det++) {
    Int_t nRings = (det == 1 ? 1 : 2);
    for (UShort_t ir = 0; ir < nRings; ir++) {
      Char_t   ring = (ir == 0 ? 'I' : 'O');
      UShort_t nsec = (ir == 0 ? 20  : 40);
      UShort_t nstr = (ir == 0 ? 512 : 256);
      for (UShort_t sec =0; sec < nsec;  sec++) {
        for (UShort_t strip = 0; strip < nstr; strip++) {
          Float_t mult = fmdData->Multiplicity(det,ring,sec,strip);
          if (mult == AliESDFMD::kInvalidMult) continue;
          
          if (fillHistograms)
            fHistFMDSingle->Fill(mult);
          
          if (mult > fFMDLowCut)
            totalMult = totalMult + mult;
          else
          {
            if (totalMult > fFMDHitCut)
              triggers++;
              
            if (fillHistograms)
              fHistFMDSum->Fill(totalMult);
              
            totalMult = 0;
          }
        }
      }
    }
  }
  
  return triggers;
}

Bool_t AliTriggerAnalysis::FMDTrigger(const AliESDEvent* aEsd, AliceSide side) const
{
  // Returns if the FMD triggered
  //
  // Authors: FMD team, Hans Dalsgaard (code merged from FMD/AliFMDOfflineTrigger)

  Int_t triggers = FMDHitCombinations(aEsd, side, kFALSE);
  
  if (triggers > 0)
    return kTRUE;
    
  return kFALSE;
}

Long64_t AliTriggerAnalysis::Merge(TCollection* list)
{
  // Merge a list of AliMultiplicityCorrection objects with this (needed for
  // PROOF).
  // Returns the number of merged objects (including this).

  if (!list)
    return 0;

  if (list->IsEmpty())
    return 1;

  TIterator* iter = list->MakeIterator();
  TObject* obj;

  // collections of all histograms
  const Int_t nHists = 9;
  TList collections[nHists];

  Int_t count = 0;
  while ((obj = iter->Next())) {

    AliTriggerAnalysis* entry = dynamic_cast<AliTriggerAnalysis*> (obj);
    if (entry == 0) 
      continue;

    collections[0].Add(entry->fHistSPD);
    collections[1].Add(entry->fHistV0A);
    collections[2].Add(entry->fHistV0C);
    collections[3].Add(entry->fHistZDC);
    collections[4].Add(entry->fHistFMDA);
    collections[5].Add(entry->fHistFMDC);
    collections[6].Add(entry->fHistFMDSingle);
    collections[7].Add(entry->fHistFMDSum);
    collections[8].Add(entry->fHistBitsSPD);

    count++;
  }

  fHistSPD->Merge(&collections[0]);
  fHistV0A->Merge(&collections[1]);
  fHistV0C->Merge(&collections[2]);
  fHistZDC->Merge(&collections[3]);
  fHistFMDA->Merge(&collections[4]);
  fHistFMDC->Merge(&collections[5]);
  fHistFMDSingle->Merge(&collections[6]);
  fHistFMDSum->Merge(&collections[7]);
  fHistBitsSPD->Merge(&collections[8]);

  delete iter;

  return count+1;
}

void AliTriggerAnalysis::WriteHistograms() const
{
  // write histograms to current directory
  
  if (!fHistSPD)
    return;
    
  fHistSPD->Write();
  fHistBitsSPD->Write();
  fHistV0A->Write();
  fHistV0C->Write();
  fHistZDC->Write();
  fHistFMDA->Write();
  fHistFMDC->Write();
  fHistFMDSingle->Write();
  fHistFMDSum->Write();
}
Commit	Line	Data
70fdd197	1	/* $Id: AliTriggerAnalysis.cxx 35782 2009-10-22 11:54:31Z jgrosseo $ */
ff8c4f30	2
7a11141c	3	/**************************************************************************
	4	* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Author: The ALICE Off-line Project. *
	7	* Contributors are mentioned in the code where appropriate. *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	//-------------------------------------------------------------------------
70fdd197	19	// Implementation of Class AliTriggerAnalysis
	20	// This class provides function to check if events have been triggered based on the data in the ESD
	21	// The trigger bits, trigger class inputs and only the data (offline trigger) can be used
7a11141c	22	// Origin: Jan Fiete Grosse-Oetringhaus, CERN
	23	//-------------------------------------------------------------------------
	24
70fdd197	25	#include <Riostream.h>
907972ff	26	#include <TH1F.h>
90dc86e9	27	#include <TH2F.h>
907972ff	28	#include <TList.h>
	29	#include <TIterator.h>
	30
70fdd197	31	#include <AliTriggerAnalysis.h>
ff8c4f30	32
	33	#include <AliLog.h>
	34
	35	#include <AliESDEvent.h>
	36
	37	#include <AliMultiplicity.h>
	38	#include <AliESDVZERO.h>
c8d3e441	39	#include <AliESDZDC.h>
7a11141c	40	#include <AliESDFMD.h>
ff8c4f30	41
70fdd197	42	ClassImp(AliTriggerAnalysis)
ff8c4f30	43
70fdd197	44	AliTriggerAnalysis::AliTriggerAnalysis() :
90dc86e9	45	fSPDGFOThreshold(2),
ff8c4f30	46	fV0AThreshold(1),
7a11141c	47	fV0CThreshold(1),
90dc86e9	48	fFMDLowCut(0.2),
90dc86e9	49	fFMDHitCut(0.5),
907972ff	50	fHistSPD(0),
90dc86e9	51	fHistBitsSPD(0),
907972ff	52	fHistV0A(0),
	53	fHistV0C(0),
	54	fHistZDC(0),
	55	fHistFMDA(0),
	56	fHistFMDC(0),
	57	fHistFMDSingle(0),
	58	fHistFMDSum(0)
ff8c4f30	59	{
	60	}
	61
70fdd197	62	void AliTriggerAnalysis::EnableHistograms()
907972ff	63	{
	64	// creates the monitoring histograms
	65
	66	fHistSPD = new TH1F("fHistSPD", "SPD GFO;number of fired chips;events", 1202, -1.5, 1200.5);
90dc86e9	67	fHistBitsSPD = new TH2F("fHistBitsSPD", "SPD GFO;number of fired chips (offline);number of fired chips (hardware)", 1202, -1.5, 1200.5, 1202, -1.5, 1200.5);
907972ff	68	fHistV0A = new TH1F("fHistV0A", "V0A;number of BB triggers;events", 34, -1.5, 32.5);
	69	fHistV0C = new TH1F("fHistV0C", "V0C;number of BB triggers;events", 34, -1.5, 32.5);
	70	fHistZDC = new TH1F("fHistZDC", "ZDC;trigger bits;events", 8, -1.5, 6.5);
	71
	72	// TODO check limits
	73	fHistFMDA = new TH1F("fHistFMDA", "FMDA;combinations above threshold;events", 102, -1.5, 100.5);
	74	fHistFMDC = new TH1F("fHistFMDC", "FMDC;combinations above threshold;events", 102, -1.5, 100.5);
	75	fHistFMDSingle = new TH1F("fHistFMDSingle", "FMD single;multiplicity value;counts", 1000, 0, 10);
	76	fHistFMDSum = new TH1F("fHistFMDSum", "FMD sum;multiplicity value;counts", 1000, 0, 10);
	77	}
	78
70fdd197	79	//____________________________________________________________________
	80	const char* AliTriggerAnalysis::GetTriggerName(Trigger trigger)
	81	{
	82	// returns the name of the requested trigger
	83	// the returned string will only be valid until the next call to this function [not thread-safe]
	84
	85	static TString str;
	86
	87	UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
	88
	89	switch (triggerNoFlags)
	90	{
	91	case kAcceptAll : str = "ACCEPT ALL (bypass!)"; break;
	92	case kMB1 : str = "MB1"; break;
	93	case kMB2 : str = "MB2"; break;
	94	case kMB3 : str = "MB3"; break;
	95	case kSPDGFO : str = "SPD GFO"; break;
	96	case kV0A : str = "V0 A"; break;
	97	case kV0C : str = "V0 C"; break;
	98	case kZDC : str = "ZDC"; break;
	99	case kZDCA : str = "ZDC A"; break;
	100	case kZDCC : str = "ZDC C"; break;
	101	case kFMDA : str = "FMD A"; break;
	102	case kFMDC : str = "FMD C"; break;
	103	case kFPANY : str = "SPD GFO \| V0 \| ZDC \| FMD"; break;
	104	default: str = ""; break;
	105	}
	106
	107	if (trigger & kOfflineFlag)
	108	str += " OFFLINE";
	109
	110	return str;
	111	}
	112
	113	Bool_t AliTriggerAnalysis::IsTriggerFired(const AliESDEvent* aEsd, Trigger trigger) const
	114	{
	115	// checks if an event has been triggered
	116
	117	if (trigger & kOfflineFlag)
	118	return IsOfflineTriggerFired(aEsd, trigger);
	119
	120	return IsTriggerBitFired(aEsd, trigger);
	121	}
	122
	123	Bool_t AliTriggerAnalysis::IsTriggerBitFired(const AliESDEvent* aEsd, Trigger trigger) const
	124	{
	125	// checks if an event is fired using the trigger bits
	126
	127	return IsTriggerBitFired(aEsd->GetTriggerMask(), trigger);
	128	}
	129
	130	Bool_t AliTriggerAnalysis::IsTriggerBitFired(ULong64_t triggerMask, Trigger trigger) const
	131	{
	132	// checks if an event is fired using the trigger bits
	133	//
	134	// this function needs the branch TriggerMask in the ESD
	135
	136	// definitions from p-p.cfg
	137	ULong64_t spdFO = (1 << 14);
	138	ULong64_t v0left = (1 << 10);
	139	ULong64_t v0right = (1 << 11);
	140
	141	switch (trigger)
	142	{
143	case kAcceptAll:
144	{
145	return kTRUE;
146	break;
147	}
148	case kMB1:
149	{
150	if (triggerMask & spdFO \|\| ((triggerMask & v0left) \|\| (triggerMask & v0right)))
151	return kTRUE;
152	break;
153	}
154	case kMB2:
155	{
156	if (triggerMask & spdFO && ((triggerMask & v0left) \|\| (triggerMask & v0right)))
157	return kTRUE;
158	break;
159	}
160	case kMB3:
161	{
162	if (triggerMask & spdFO && (triggerMask & v0left) && (triggerMask & v0right))
163	return kTRUE;
164	break;
165	}
166	case kSPDGFO:
167	{
168	if (triggerMask & spdFO)
169	return kTRUE;
170	break;
171	}
172	default:
173	Printf("IsEventTriggered: ERROR: Trigger type %d not implemented in this method", (Int_t) trigger);
174	break;
175	}
176
177	return kFALSE;
178	}
179
180	Bool_t AliTriggerAnalysis::IsTriggerBitFired(const AliESDEvent* aEsd, ULong64_t tclass) const
181	{
182	// Checks if corresponding bit in mask is on
183
184	ULong64_t trigmask = aEsd->GetTriggerMask();
185	return (trigmask & (1ull << (tclass-1)));
186	}
187
188	Bool_t AliTriggerAnalysis::IsOfflineTriggerFired(const AliESDEvent* aEsd, Trigger trigger) const
ff8c4f30	189	{
	190	// checks if an event has been triggered "offline"
	191
70fdd197	192	UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) kStartOfFlags;
ff8c4f30	193
	194	switch (triggerNoFlags)
	195	{
70fdd197	196	case kAcceptAll:
ff8c4f30	197	{
	198	return kTRUE;
	199	break;
	200	}
70fdd197	201	case kMB1:
ff8c4f30	202	{
	203	if (SPDGFOTrigger(aEsd) \|\| V0Trigger(aEsd, kASide) \|\| V0Trigger(aEsd, kCSide))
	204	return kTRUE;
	205	break;
	206	}
70fdd197	207	case kMB2:
ff8c4f30	208	{
	209	if (SPDGFOTrigger(aEsd) && (V0Trigger(aEsd, kASide) \|\| V0Trigger(aEsd, kCSide)))
	210	return kTRUE;
	211	break;
	212	}
70fdd197	213	case kMB3:
ff8c4f30	214	{
	215	if (SPDGFOTrigger(aEsd) && V0Trigger(aEsd, kASide) && V0Trigger(aEsd, kCSide))
	216	return kTRUE;
	217	break;
	218	}
70fdd197	219	case kSPDGFO:
ff8c4f30	220	{
	221	if (SPDGFOTrigger(aEsd))
	222	return kTRUE;
	223	break;
	224	}
70fdd197	225	case kV0A:
ff8c4f30	226	{
	227	if (V0Trigger(aEsd, kASide))
	228	return kTRUE;
	229	break;
	230	}
70fdd197	231	case kV0C:
ff8c4f30	232	{
	233	if (V0Trigger(aEsd, kCSide))
	234	return kTRUE;
	235	break;
	236	}
70fdd197	237	case kZDC:
c8d3e441	238	{
	239	if (ZDCTrigger(aEsd, kASide) \|\| ZDCTrigger(aEsd, kCentralBarrel) \|\| ZDCTrigger(aEsd, kCSide))
	240	return kTRUE;
	241	break;
	242	}
70fdd197	243	case kZDCA:
ff8c4f30	244	{
	245	if (ZDCTrigger(aEsd, kASide))
	246	return kTRUE;
	247	break;
	248	}
70fdd197	249	case kZDCC:
ff8c4f30	250	{
	251	if (ZDCTrigger(aEsd, kCSide))
	252	return kTRUE;
	253	break;
	254	}
70fdd197	255	case kFMDA:
7a11141c	256	{
	257	if (FMDTrigger(aEsd, kASide))
	258	return kTRUE;
	259	break;
	260	}
70fdd197	261	case kFMDC:
7a11141c	262	{
	263	if (FMDTrigger(aEsd, kCSide))
	264	return kTRUE;
	265	break;
	266	}
70fdd197	267	case kFPANY:
ff8c4f30	268	{
7a11141c	269	if (SPDGFOTrigger(aEsd) \|\| V0Trigger(aEsd, kASide) \|\| V0Trigger(aEsd, kCSide) \|\| ZDCTrigger(aEsd, kASide) \|\| ZDCTrigger(aEsd, kCentralBarrel) \|\| ZDCTrigger(aEsd, kCSide) \|\| FMDTrigger(aEsd, kASide) \|\| FMDTrigger(aEsd, kCSide))
ff8c4f30	270	return kTRUE;
	271	break;
	272	}
	273	default:
	274	{
	275	AliFatal(Form("Trigger type %d not implemented", triggerNoFlags));
	276	}
	277	}
	278
	279	return kFALSE;
	280	}
	281
70fdd197	282
	283	Bool_t AliTriggerAnalysis::IsTriggerClassFired(const AliESDEvent* aEsd, const Char_t* tclass) const
	284	{
	285	// tclass is logical function of inputs, e.g. 01 && 02 \|\| 03 && 11 && 21
	286	// = L0 inp 1 && L0 inp 2 \|\| L0 inp 3 && L1 inp 1 && L2 inp 1
	287	// NO brackets in logical function !
	288	// Spaces between operators and inputs.
	289	// Not all logical functions are available in CTP=
	290	// =any function of first 4 inputs; 'AND' of other inputs, check not done
	291	// This method will be replaced/complemened by similar one
	292	// which works withh class and inputs names as in CTP cfg file
	293
	294	TString TClass(tclass);
	295	TObjArray* tcltokens = TClass.Tokenize(" ");
	296	Char_t level=((TObjString*)tcltokens->At(0))->String()[0];
	297	UInt_t input=atoi((((TObjString*)tcltokens->At(0))->String()).Remove(0));
	298	Bool_t tcl = IsInputFired(aEsd,level,input);
	299
	300	for (Int_t i=1;i<tcltokens->GetEntriesFast();i=i+2) {
	301	level=((TObjString*)tcltokens->At(i+1))->String()[0];
	302	input=atoi((((TObjString*)tcltokens->At(i+1))->String()).Remove(0));
	303	Bool_t inpnext = IsInputFired(aEsd,level,input);
	304	Char_t op =((TObjString*)tcltokens->At(i))->String()[0];
	305	if (op == '&') tcl=tcl && inpnext;
	306	else if (op == '\|') tcl =tcl \|\| inpnext;
	307	else {
	308	AliError(Form("Syntax error in %s", tclass));
	309	tcltokens->Delete();
	310	return kFALSE;
	311	}
	312	}
	313	tcltokens->Delete();
	314	return tcl;
	315	}
	316
	317	Bool_t AliTriggerAnalysis::IsInputFired(const AliESDEvent* aEsd, Char_t level, UInt_t input) const
	318	{
	319	// Checks trigger input of any level
	320
	321	switch (level)
	322	{
	323	case '0': return IsL0InputFired(aEsd,input);
	324	case '1': return IsL1InputFired(aEsd,input);
	325	case '2': return IsL2InputFired(aEsd,input);
	326	default:
	327	AliError(Form("Wrong level %i",level));
	328	return kFALSE;
	329	}
	330	}
	331
	332	Bool_t AliTriggerAnalysis::IsL0InputFired(const AliESDEvent* aEsd, UInt_t input) const
	333	{
	334	// Checks if corresponding bit in mask is on
	335
	336	UInt_t inpmask = aEsd->GetHeader()->GetL0TriggerInputs();
	337	return (inpmask & (1<<(input-1)));
	338	}
	339
	340	Bool_t AliTriggerAnalysis::IsL1InputFired(const AliESDEvent* aEsd, UInt_t input) const
	341	{
	342	// Checks if corresponding bit in mask is on
	343
	344	UInt_t inpmask = aEsd->GetHeader()->GetL1TriggerInputs();
	345	return (inpmask & (1<<(input-1)));
346	}
347
348	Bool_t AliTriggerAnalysis::IsL2InputFired(const AliESDEvent* aEsd, UInt_t input) const
349	{
350	// Checks if corresponding bit in mask is on
351
352	UInt_t inpmask = aEsd->GetHeader()->GetL2TriggerInputs();
353	return (inpmask & (1<<(input-1)));
354	}
355
356	void AliTriggerAnalysis::FillHistograms(const AliESDEvent* aEsd)
ff8c4f30	357	{
907972ff	358	// fills the histograms with the info from the ESD
	359
	360	fHistSPD->Fill(SPDFiredChips(aEsd));
90dc86e9	361	fHistBitsSPD->Fill(SPDFiredChips(aEsd, 0), SPDFiredChips(aEsd, 1));
907972ff	362
	363	fHistV0A->Fill(V0BBTriggers(aEsd, kASide));
	364	fHistV0C->Fill(V0BBTriggers(aEsd, kCSide));
	365
	366	AliESDZDC* zdcData = aEsd->GetESDZDC();
	367	if (zdcData)
	368	{
	369	UInt_t quality = zdcData->GetESDQuality();
	370
	371	// from Nora's presentation, general first physics meeting 16.10.09
	372	static UInt_t zpc = 0x20;
	373	static UInt_t znc = 0x10;
	374	static UInt_t zem1 = 0x08;
	375	static UInt_t zem2 = 0x04;
	376	static UInt_t zpa = 0x02;
	377	static UInt_t zna = 0x01;
	378
	379	fHistZDC->Fill(1, quality & zna);
	380	fHistZDC->Fill(2, quality & zpa);
	381	fHistZDC->Fill(3, quality & zem2);
	382	fHistZDC->Fill(4, quality & zem1);
	383	fHistZDC->Fill(5, quality & znc);
	384	fHistZDC->Fill(6, quality & zpc);
	385	}
	386	else
	387	{
	388	fHistZDC->Fill(-1);
	389	AliError("AliESDZDC not available");
	390	}
	391
	392	fHistFMDA->Fill(FMDHitCombinations(aEsd, kASide, kTRUE));
	393	fHistFMDC->Fill(FMDHitCombinations(aEsd, kCSide, kTRUE));
	394	}
	395
90dc86e9	396	Int_t AliTriggerAnalysis::SPDFiredChips(const AliESDEvent* aEsd, Int_t origin) const
907972ff	397	{
907972ff	398	// returns the number of fired chips in the SPD
90dc86e9	399	//
	400	// origin = 0 --> aEsd->GetMultiplicity()->GetNumberOfFiredChips() (filled from clusters)
	401	// origin = 1 --> aEsd->GetMultiplicity()->TestFastOrFiredChips() (from hardware bits)
ff8c4f30	402
ff8c4f30	403	const AliMultiplicity* mult = aEsd->GetMultiplicity();
	404	if (!mult)
	405	{
	406	AliError("AliMultiplicity not available");
907972ff	407	return -1;
ff8c4f30	408	}
90dc86e9	409
	410	if (origin == 0)
	411	return mult->GetNumberOfFiredChips(0) + mult->GetNumberOfFiredChips(1);
	412
	413	if (origin == 1)
	414	{
	415	Int_t nChips = 0;
	416	for (Int_t i=0; i<1200; i++)
	417	if (mult->TestFastOrFiredChips(i) == kTRUE)
	418	nChips++;
	419	return nChips;
	420	}
	421
	422	return -1;
907972ff	423	}
907972ff	424
70fdd197	425	Bool_t AliTriggerAnalysis::SPDGFOTrigger(const AliESDEvent* aEsd) const
907972ff	426	{
	427	// Returns if the SPD gave a global Fast OR trigger
	428
	429	Int_t firedChips = SPDFiredChips(aEsd);
ff8c4f30	430
	431	if (firedChips >= fSPDGFOThreshold)
	432	return kTRUE;
	433	return kFALSE;
	434	}
	435
70fdd197	436	Int_t AliTriggerAnalysis::V0BBTriggers(const AliESDEvent* aEsd, AliceSide side) const
ff8c4f30	437	{
907972ff	438	// returns the number of BB triggers in V0A \| V0C
ff8c4f30	439
	440	AliESDVZERO* v0Data = aEsd->GetVZEROData();
	441	if (!v0Data)
	442	{
	443	AliError("AliESDVZERO not available");
907972ff	444	return -1;
ff8c4f30	445	}
ff8c4f30	446
907972ff	447	Int_t count = 0;
ff8c4f30	448	for (Int_t i=0; i<32; i++)
ff8c4f30	449	{
907972ff	450	if (side == kASide && v0Data->BBTriggerV0A(i))
	451	count++;
	452	if (side == kCSide && v0Data->BBTriggerV0C(i))
	453	count++;
ff8c4f30	454	}
ff8c4f30	455
907972ff	456	return count;
	457	}
	458
70fdd197	459	Bool_t AliTriggerAnalysis::V0Trigger(const AliESDEvent* aEsd, AliceSide side) const
907972ff	460	{
	461	// Returns if the V0 triggered
	462
	463	Int_t count = V0BBTriggers(aEsd, side);
	464
	465	if (side == kASide && count >= fV0AThreshold)
ff8c4f30	466	return kTRUE;
907972ff	467	if (side == kCSide && count >= fV0CThreshold)
ff8c4f30	468	return kTRUE;
907972ff	469	return kFALSE;
ff8c4f30	470	}
ff8c4f30	471
70fdd197	472	Bool_t AliTriggerAnalysis::ZDCTrigger(const AliESDEvent* aEsd, AliceSide side) const
ff8c4f30	473	{
	474	// Returns if ZDC triggered
	475
c8d3e441	476	AliESDZDC* zdcData = aEsd->GetESDZDC();
	477	if (!zdcData)
	478	{
	479	AliError("AliESDZDC not available");
	480	return kFALSE;
	481	}
	482
	483	UInt_t quality = zdcData->GetESDQuality();
	484
	485	// from Nora's presentation, general first physics meeting 16.10.09
	486	static UInt_t zpc = 0x20;
	487	static UInt_t znc = 0x10;
	488	static UInt_t zem1 = 0x08;
	489	static UInt_t zem2 = 0x04;
	490	static UInt_t zpa = 0x02;
	491	static UInt_t zna = 0x01;
	492
	493	if (side == kASide && ((quality & zpa) \|\| (quality & zna)))
	494	return kTRUE;
	495	if (side == kCentralBarrel && ((quality & zem1) \|\| (quality & zem2)))
	496	return kTRUE;
	497	if (side == kCSide && ((quality & zpc) \|\| (quality & znc)))
	498	return kTRUE;
ff8c4f30	499
	500	return kFALSE;
	501	}
	502
70fdd197	503	Int_t AliTriggerAnalysis::FMDHitCombinations(const AliESDEvent* aEsd, AliceSide side, Bool_t fillHistograms) const
ff8c4f30	504	{
907972ff	505	// returns number of hit combinations agove threshold
7a11141c	506	//
7a11141c	507	// Authors: FMD team, Hans Dalsgaard (code merged from FMD/AliFMDOfflineTrigger)
ff8c4f30	508
7a11141c	509	// Workaround for AliESDEvent::GetFMDData is not const!
	510	const AliESDFMD* fmdData = (const_cast<AliESDEvent*>(aEsd))->GetFMDData();
	511	if (!fmdData)
	512	{
	513	AliError("AliESDFMD not available");
907972ff	514	return -1;
7a11141c	515	}
	516
	517	Int_t detFrom = (side == kASide) ? 1 : 3;
	518	Int_t detTo = (side == kASide) ? 2 : 3;
	519
907972ff	520	Int_t triggers = 0;
7a11141c	521	Float_t totalMult = 0;
	522	for (UShort_t det=detFrom;det<=detTo;det++) {
	523	Int_t nRings = (det == 1 ? 1 : 2);
	524	for (UShort_t ir = 0; ir < nRings; ir++) {
	525	Char_t ring = (ir == 0 ? 'I' : 'O');
	526	UShort_t nsec = (ir == 0 ? 20 : 40);
	527	UShort_t nstr = (ir == 0 ? 512 : 256);
039db886	528	for (UShort_t sec =0; sec < nsec; sec++) {
	529	for (UShort_t strip = 0; strip < nstr; strip++) {
	530	Float_t mult = fmdData->Multiplicity(det,ring,sec,strip);
	531	if (mult == AliESDFMD::kInvalidMult) continue;
	532
907972ff	533	if (fillHistograms)
	534	fHistFMDSingle->Fill(mult);
	535
039db886	536	if (mult > fFMDLowCut)
	537	totalMult = totalMult + mult;
	538	else
907972ff	539	{
	540	if (totalMult > fFMDHitCut)
	541	triggers++;
	542
	543	if (fillHistograms)
	544	fHistFMDSum->Fill(totalMult);
	545
	546	totalMult = 0;
	547	}
039db886	548	}
7a11141c	549	}
	550	}
	551	}
907972ff	552
	553	return triggers;
	554	}
	555
70fdd197	556	Bool_t AliTriggerAnalysis::FMDTrigger(const AliESDEvent* aEsd, AliceSide side) const
907972ff	557	{
	558	// Returns if the FMD triggered
	559	//
	560	// Authors: FMD team, Hans Dalsgaard (code merged from FMD/AliFMDOfflineTrigger)
	561
	562	Int_t triggers = FMDHitCombinations(aEsd, side, kFALSE);
	563
	564	if (triggers > 0)
	565	return kTRUE;
	566
ff8c4f30	567	return kFALSE;
ff8c4f30	568	}
907972ff	569
70fdd197	570	Long64_t AliTriggerAnalysis::Merge(TCollection* list)
907972ff	571	{
	572	// Merge a list of AliMultiplicityCorrection objects with this (needed for
	573	// PROOF).
	574	// Returns the number of merged objects (including this).
	575
	576	if (!list)
	577	return 0;
	578
	579	if (list->IsEmpty())
	580	return 1;
	581
	582	TIterator* iter = list->MakeIterator();
	583	TObject* obj;
	584
	585	// collections of all histograms
90dc86e9	586	const Int_t nHists = 9;
907972ff	587	TList collections[nHists];
	588
	589	Int_t count = 0;
	590	while ((obj = iter->Next())) {
	591
70fdd197	592	AliTriggerAnalysis* entry = dynamic_cast<AliTriggerAnalysis*> (obj);
907972ff	593	if (entry == 0)
	594	continue;
	595
	596	collections[0].Add(entry->fHistSPD);
	597	collections[1].Add(entry->fHistV0A);
	598	collections[2].Add(entry->fHistV0C);
	599	collections[3].Add(entry->fHistZDC);
	600	collections[4].Add(entry->fHistFMDA);
	601	collections[5].Add(entry->fHistFMDC);
	602	collections[6].Add(entry->fHistFMDSingle);
	603	collections[7].Add(entry->fHistFMDSum);
90dc86e9	604	collections[8].Add(entry->fHistBitsSPD);
907972ff	605
	606	count++;
	607	}
	608
	609	fHistSPD->Merge(&collections[0]);
	610	fHistV0A->Merge(&collections[1]);
	611	fHistV0C->Merge(&collections[2]);
	612	fHistZDC->Merge(&collections[3]);
	613	fHistFMDA->Merge(&collections[4]);
	614	fHistFMDC->Merge(&collections[5]);
	615	fHistFMDSingle->Merge(&collections[6]);
	616	fHistFMDSum->Merge(&collections[7]);
90dc86e9	617	fHistBitsSPD->Merge(&collections[8]);
907972ff	618
	619	delete iter;
	620
	621	return count+1;
	622	}
	623
70fdd197	624	void AliTriggerAnalysis::WriteHistograms() const
907972ff	625	{
	626	// write histograms to current directory
	627
	628	if (!fHistSPD)
	629	return;
	630
	631	fHistSPD->Write();
90dc86e9	632	fHistBitsSPD->Write();
907972ff	633	fHistV0A->Write();
	634	fHistV0C->Write();
	635	fHistZDC->Write();
	636	fHistFMDA->Write();
	637	fHistFMDC->Write();
	638	fHistFMDSingle->Write();
	639	fHistFMDSum->Write();
	640	}