AliEMCalTriggerAnaTriggerDecision.cxx

Go to the documentation of this file.

/**************************************************************************
 * Copyright(c) 1998-2014, 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.                  *
 **************************************************************************/
#include <iostream>
#include <TClonesArray.h>
#include <TString.h>
#include "AliVEvent.h"
#include "AliEmcalTriggerPatchInfo.h"
#include "AliEMCalTriggerAnaTriggerDecision.h"
#include "AliEMCalTriggerEventData.h"

ClassImp(EMCalTriggerPtAnalysis::AliEMCalTriggerAnaTriggerDecision)
ClassImp(EMCalTriggerPtAnalysis::AliEMCalTriggerAnaTriggerDecisionConfig)

namespace EMCalTriggerPtAnalysis {

AliEMCalTriggerAnaTriggerDecision::AliEMCalTriggerAnaTriggerDecision() :
    fIsMinBias(kFALSE),
    fDoDebug(kFALSE)
{
  Reset();
}

void AliEMCalTriggerAnaTriggerDecision::Create(const AliEMCalTriggerEventData* const data) {
  Reset();
  MakeDecisionFromPatches(*(data->GetTriggerPatchContainer()));
  MakeDecisionFromString(data->GetRecEvent()->GetFiredTriggerClasses());
}

void AliEMCalTriggerAnaTriggerDecision::Reset() {
  for(int itrg = 0; itrg < 4; itrg++){
    fDecisionFromPatches[itrg] = kFALSE;
    fDecisionFromString[itrg] = kFALSE;
  }
}

void AliEMCalTriggerAnaTriggerDecision::MakeDecisionFromString(const TString& triggerstring) {
  if(triggerstring.Contains("EJ1") || triggerstring.Contains("EJE")) fDecisionFromString[kTAEMCJHigh]  = kTRUE;
  if(triggerstring.Contains("EJ2")) fDecisionFromString[kTAEMCJLow]   = kTRUE;
  if(triggerstring.Contains("EG1") || triggerstring.Contains("EGA")) fDecisionFromString[kTAEMCGHigh]  = kTRUE;
  if(triggerstring.Contains("EG2")) fDecisionFromString[kTAEMCGLow]   = kTRUE;
}

bool AliEMCalTriggerAnaTriggerDecision::CheckConsistency() const{
  bool result = true;
  for(int icls = 0; icls < 4; icls++){
    if(fDecisionFromString[icls] != fDecisionFromPatches[icls]) result = false;
  }
  return result;
}

void AliEMCalTriggerAnaTriggerDecision::MakeDecisionFromPatches(const TClonesArray& listOfPatches) {
  TIter patchIter(&listOfPatches);
  AliEmcalTriggerPatchInfo *mypatch(NULL);
  if(fDoDebug){
    std::cout << "Generating trigger decision from found patches: " << listOfPatches.GetEntries() << std::endl;
    if(fConfiguration.IsUsingOfflinePatches()) std::cout << "Using offline patches\n";
    else std::cout << "Using online patches\n";
  }
  int foundpatches[4] = {0,0,0,0};
  int index = -1;
  while((mypatch = dynamic_cast<AliEmcalTriggerPatchInfo *>(patchIter()))){
    if(fDoDebug) std::cout << "Next patch: " << (mypatch->IsOfflineSimple() ? "offline" : "online:") << std::endl;
    for(int icase = 0; icase < 4; icase++){
      if(SelectTriggerPatch(ETATriggerType(icase), mypatch)){
        fDecisionFromPatches[icase] = kTRUE;
        foundpatches[icase]++;
      }
    }
  }
  if(fDoDebug){
    std::cout << "Found patches:" << std::endl;
    std::cout << "Jet high:    " << foundpatches[kTAEMCJHigh] << std::endl;
    std::cout << "Jet low:     " << foundpatches[kTAEMCJLow] << std::endl;
    std::cout << "Gamma high:  " << foundpatches[kTAEMCGHigh] << std::endl;
    std::cout << "Gamma low:   " << foundpatches[kTAEMCGLow] << std::endl;
  }
}

Bool_t AliEMCalTriggerAnaTriggerDecision::SelectTriggerPatch(ETATriggerType trigger, const AliEmcalTriggerPatchInfo* const recpatch) const {
  bool swapThresholds = fConfiguration.IsSwapThresholds();
  bool selectPatchType = kFALSE;
  if(fConfiguration.IsUsingOfflinePatches()){
    if(!recpatch->IsOfflineSimple()) return kFALSE;
    switch(trigger){
    case kTAEMCJHigh: selectPatchType = swapThresholds ? recpatch->IsJetLowSimple() :  recpatch->IsJetHighSimple(); break;
    case kTAEMCJLow: selectPatchType = swapThresholds ? recpatch->IsJetHighSimple() :  recpatch->IsJetLowSimple(); break;
    case kTAEMCGHigh: selectPatchType = swapThresholds ? recpatch->IsGammaLowSimple() :  recpatch->IsGammaHighSimple(); break;
    case kTAEMCGLow: selectPatchType = swapThresholds ? recpatch->IsGammaHighSimple() :  recpatch->IsGammaLowSimple(); break;
    };
  } else {
    if(recpatch->IsOfflineSimple()) return kFALSE;
    switch(trigger){
    case kTAEMCJHigh: selectPatchType = swapThresholds ? recpatch->IsJetLow() :  recpatch->IsJetHigh(); break;
    case kTAEMCJLow: selectPatchType = swapThresholds ? recpatch->IsJetHigh() :  recpatch->IsJetLow(); break;
    case kTAEMCGHigh: selectPatchType = swapThresholds ? recpatch->IsGammaLow() :  recpatch->IsGammaHigh(); break;
    case kTAEMCGLow: selectPatchType = swapThresholds ? recpatch->IsGammaHigh() :  recpatch->IsGammaLow(); break;
    };
  }

  if(!selectPatchType) return kFALSE;

  if(fConfiguration.HasEnergyThreshold(trigger)){
    // Additional threshold on energy requested to select the patch
    return GetPatchEnergy(fConfiguration.GetPatchEnergyType(), recpatch) > fConfiguration.GetEnergyThreshold(trigger);
  }
  return kTRUE;
}
Double_t AliEMCalTriggerAnaTriggerDecision::GetPatchEnergy(EPatchEnergyType_t energytype, const AliEmcalTriggerPatchInfo *const patch) const {
  Double_t energy = 0.;
  switch(energytype){
  case kAmplitudeOnline:      energy = patch->GetADCAmp(); break;
  case kAmplitudeOffline:     energy = patch->GetADCOfflineAmp(); break;
  case kEnergyOnline:         energy = patch->GetADCAmpGeVRough(); break;
  case kEnergyOffline:        energy = patch->GetPatchE(); break;
  };
  return energy;
}

void AliEMCalTriggerAnaTriggerDecision::Print(Option_t*) const {
  std::cout << "Trigger decision" << std::endl;
  std::cout << "===============================" << std::endl;
  std::cout << "MinBias:                   " << (fIsMinBias ? "yes" : "no") << std::endl;
  std::string triggertitles[4] = {"Jet High", "Jet Low", "Gamma High", "Gamma Low"};
  for(int icase = 0; icase < 4; icase++){
    std::cout << triggertitles[icase] << ": String[" << (fDecisionFromString[icase] ? "yes" : "no")
        << "], Patches[" << (fDecisionFromPatches[icase] ? "yes" : "no") << "]" << std::endl;
  }
}

/*
 * Resources of class AliEMCalTriggerAnaTriggerDecisionConfig
 */

AliEMCalTriggerAnaTriggerDecisionConfig::AliEMCalTriggerAnaTriggerDecisionConfig():
  fSwapThresholds(kFALSE),
  fUseOfflinePatches(kFALSE),
  fEnergyType(kAmplitudeOnline)
{
  memset(fEnergyThresholds, 0, sizeof(double) * 4);
}


} /* namespace EMCalTriggerPtAnalysis */