AliEmcalCorrectionCellCombineCollections.cxx

Go to the documentation of this file.

// AliEmcalCorrectionCellCombineCollections
//

#include <sstream>

#include <AliAODEvent.h>
#include <AliVCaloCells.h>
#include <AliAODCaloCells.h>
#include <AliESDCaloCells.h>

#include "AliAnalysisTaskEmcalEmbeddingHelper.h"
#include "AliEmcalContainerUtils.h"

#include "AliEmcalCorrectionCellCombineCollections.h"

ClassImp(AliEmcalCorrectionCellCombineCollections);

// Actually registers the class with the base class
RegisterCorrectionComponent<AliEmcalCorrectionCellCombineCollections> AliEmcalCorrectionCellCombineCollections::reg("AliEmcalCorrectionCellCombineCollections");

AliEmcalCorrectionCellCombineCollections::AliEmcalCorrectionCellCombineCollections() :
  AliEmcalCorrectionComponent("AliEmcalCorrectionCellCombineCollections"),
  fExternalCellsBranchName("emcalCells"),
  fCreatedCellsBranchName("emcalCellsCombined"),
  fVerifyCombinedCells(true),
  fInitializedCombinedCells(false),
  fCombinedCells(0)
{
  // Default constructor
  AliDebug(3, Form("%s", __PRETTY_FUNCTION__));
}

AliEmcalCorrectionCellCombineCollections::~AliEmcalCorrectionCellCombineCollections()
{
  // Destructor
}

Bool_t AliEmcalCorrectionCellCombineCollections::Initialize()
{
  // Initialization
  AliDebug(3, Form("%s", __PRETTY_FUNCTION__));
  AliEmcalCorrectionComponent::Initialize();

  GetProperty("externalCellsBranchName", fExternalCellsBranchName);
  GetProperty("combinedCellsBranchName", fCreatedCellsBranchName);
  GetProperty("verifyCombinedCells", fVerifyCombinedCells);

  // Check for "usedefault"
  if (fExternalCellsBranchName == "usedefault") {
    fExternalCellsBranchName = AliEmcalContainerUtils::DetermineUseDefaultName(AliEmcalContainerUtils::kCaloCells, fEsdMode);
  }

  // NOTE: "usedefault" doesn't make sense for the combined cell branch name. The name needs to be distinct!
  //       Thus, we only do it for fExternalCellsBranchName.
  
  return kTRUE;
}

void AliEmcalCorrectionCellCombineCollections::UserCreateOutputObjects()
{
  AliDebug(3, Form("%s", __PRETTY_FUNCTION__));
  AliEmcalCorrectionComponent::UserCreateOutputObjects();
}

void AliEmcalCorrectionCellCombineCollections::ExecOnce()
{
  SetupCombinedCells();
}

void AliEmcalCorrectionCellCombineCollections::SetupCombinedCells()
{
  if (fEsdMode) {
    fCombinedCells = new AliESDCaloCells(fCreatedCellsBranchName.c_str(), fCreatedCellsBranchName.c_str(), AliVCaloCells::kEMCALCell);
  }
  else {
    fCombinedCells = new AliAODCaloCells(fCreatedCellsBranchName.c_str(), fCreatedCellsBranchName.c_str(), AliVCaloCells::kEMCALCell);
  }

  // Add it to the input event
  // While the CorrectionTask can handle cells in the external event, it is not well handled by
  // other classes, so it should stay in the input event to ensure it is easily available.
  AddObjectToEvent(fCombinedCells, fEventManager.InputEvent());

  AliDebugStream(2) << "Added combined calo cells \"" << fCombinedCells->GetName() << "\" with " << fCombinedCells->GetNumberOfCells() << " cells to the input event" << std::endl;

  fInitializedCombinedCells = true;
}

Bool_t AliEmcalCorrectionCellCombineCollections::Run()
{
  // Run
  AliDebug(3, Form("%s", __PRETTY_FUNCTION__));
  AliEmcalCorrectionComponent::Run();

  CreateCombinedCells();

  return kTRUE;
}

void AliEmcalCorrectionCellCombineCollections::CreateCombinedCells()
{
  // Create cells.
  // In general, the memory allocation process for cells is not very efficient...
  if (fInitializedCombinedCells == false) {
    SetupCombinedCells();
  }

  // Get the external event
  const AliAnalysisTaskEmcalEmbeddingHelper* embedding = AliAnalysisTaskEmcalEmbeddingHelper::GetInstance();
  if (!embedding) {
    AliFatal("Could not retrieve external event!");
  }

  // Get the cells to copy
  AliVCaloCells * externalCells = dynamic_cast<AliVCaloCells *>(embedding->GetExternalEvent()->FindListObject(fExternalCellsBranchName.c_str()));
  if (!externalCells) {
    AliFatal(TString::Format("Could not retrieve cells \"%s\" from external event!", fExternalCellsBranchName.c_str()));
  }

  // Delete any previous container
  fCombinedCells->DeleteContainer();
  // Create a new container
  fCombinedCells->CreateContainer(fCaloCells->GetNumberOfCells() + externalCells->GetNumberOfCells());
  // Add internal and external cells to the combined cells
  AddCellsToCombinedCellObject(fCaloCells, 0);
  AddCellsToCombinedCellObject(externalCells, fCaloCells->GetNumberOfCells());

  if (fVerifyCombinedCells) {
    VerifyCombinedCells({fCaloCells, externalCells});
  }
}

void AliEmcalCorrectionCellCombineCollections::AddCellsToCombinedCellObject(AliVCaloCells * inputCells, int indexOffset)
{
  // Cell properties
  Short_t cellNumber;
  Double_t amplitude, time, eFrac;
  Int_t mcLabel;
  Bool_t cellHighGain;
  Bool_t getCellResult = kFALSE;

  AliDebugStream(3) << "Adding caloCells \"" << inputCells->GetName() << "\" of type \"" << inputCells->GetType() << "\" with " << inputCells->GetNumberOfCells() << " cells to the combined cells" << std::endl;

  // Loop over the input cells and add them to the combined cells
  for (unsigned int i = 0; i < static_cast<unsigned int>(inputCells->GetNumberOfCells()); i++)
  {
    getCellResult = inputCells->GetCell(i, cellNumber, amplitude, time, mcLabel, eFrac);
    if (!getCellResult) {
      AliWarning(TString::Format("Could not get cell %i from cell collection %s", i, inputCells->GetName()));
    }
    // Get high gain attribute in addition to cell
    // NOTE: GetCellHighGain() uses the cell position, not cell index, and thus should _NOT_ be used!
    cellHighGain = inputCells->GetHighGain(i);

    // Set the properties in the combined cell
    fCombinedCells->SetCell(i + indexOffset, cellNumber, amplitude, time, mcLabel, eFrac, cellHighGain);
  }
}

void AliEmcalCorrectionCellCombineCollections::VerifyCombinedCells(std::vector <AliVCaloCells *> inputCaloCells)
{
  // Input cell arrays properties
  Short_t cellNumber;
  Double_t amplitude, time, eFrac;
  Int_t mcLabel;
  Bool_t cellHighGain;
  Bool_t getCellResult = kFALSE;
  // Combined cell array properties
  Short_t cellNumberCombined;
  Double_t amplitudeCombined, timeCombined, eFracCombined;
  Int_t mcLabelCombined;
  Bool_t cellHighGainCombined;
  Bool_t getCellResultCombined = kFALSE;

  unsigned int combinedCellsIndex = 0;
  for (auto caloCells : inputCaloCells)
  {
    AliDebugStream(2) << "Verifying cells from cell collection " << caloCells->GetName() << "\n";
    for (unsigned int i = 0; i < static_cast<unsigned int>(caloCells->GetNumberOfCells()); i++)
    {
      // Get input calo cell
      getCellResult = caloCells->GetCell(i, cellNumber, amplitude, time, mcLabel, eFrac);
      if (!getCellResult) {
        AliWarning(TString::Format("Could not get cell %i from cell collection %s", i, caloCells->GetName()));
      }
      // Get high gain attribute in addition to cell
      cellHighGain = caloCells->GetHighGain(i);
      // Get combined calo cell
      getCellResultCombined = fCombinedCells->GetCell(combinedCellsIndex, cellNumberCombined, amplitudeCombined, timeCombined, mcLabelCombined, eFracCombined);
      if (!getCellResultCombined) {
        AliWarning(TString::Format("Could not get cell %i from combined cell collection %s", combinedCellsIndex, fCombinedCells->GetName()));
      }
      // Get high gain attribute in addition to cell
      cellHighGainCombined = fCombinedCells->GetHighGain(combinedCellsIndex);

      if (cellNumberCombined != cellNumber ||
        amplitudeCombined != amplitude ||
        timeCombined != time ||
        mcLabelCombined != mcLabel ||
        eFracCombined != eFrac ||
        cellHighGainCombined != cellHighGain)
      {
        std::stringstream errorMessage;
        errorMessage << std::boolalpha;
        errorMessage << "Cell mistmatch at index " << i << " of cell collection " << caloCells->GetName() << ", combined cells " << combinedCellsIndex << " of combined cell collection " << fCombinedCells->GetName() << "\n";
        errorMessage << "Input cell: cell number: " << cellNumber << ", amplitude: " << amplitude << ", time: " << time << ", mcLabel: " << mcLabel << ", eFrac: " << eFrac << ", cellHighGain: " << cellHighGain << "\n";
        errorMessage << "Combined cell: cell number: " << cellNumberCombined << ", amplitude: " << amplitudeCombined << ", time: " << timeCombined << ", mcLabel: " << mcLabelCombined << ", eFrac: " << eFracCombined << ", cellHighGain: " << cellHighGainCombined << "\n";
        AliFatal(errorMessage.str().c_str());
      }

      combinedCellsIndex++;
    }
  }

  AliDebugStream(1) << "Input cells were successfully combined into the combined cells.\n";
}

void AliEmcalCorrectionCellCombineCollections::AddObjectToEvent(TObject *obj, AliVEvent * event, Bool_t attempt)
{
  if (!(event->FindListObject(obj->GetName()))) {
    event->AddObject(obj);
  }
  else {
    if (!attempt) {
      AliFatal(Form("Container with name %s already present. Aborting", obj->GetName()));
    }
  }
}