BmnSiMDDigitizer.cxx

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                   BmnSiMDDigitizer source file                -----
// -----                  Created 23/12/20  by I. Kozlov (SPSU)        -----
// -------------------------------------------------------------------------
 
#include "BmnSiMDDigitizer.h"
#include "BmnSiMDPoint.h"
#include "BmnTrigDigit.h"
 
#include "FairRootManager.h"
 
#include "TClonesArray.h"
#include "TMath.h"
 
#include <iostream>
 
static Double_t workTime = 0.0;
 
 
using namespace std;
using namespace TMath;
 
// -----   Default constructor   -------------------------------------------
BmnSiMDDigitizer::BmnSiMDDigitizer()
  : FairTask("Bmn SiMD Digitizer"),
  fPointArray(nullptr),
  fDigitArray(),
  fNMod(64) {
}
// -------------------------------------------------------------------------
 
// -----   Destructor   ----------------------------------------------------
BmnSiMDDigitizer::~BmnSiMDDigitizer() {}
// -------------------------------------------------------------------------
 
// -----   Public method Init   --------------------------------------------
InitStatus BmnSiMDDigitizer::Init() {
 
  if (fVerbose) cout << "BmnSiMDDigitizer::Init() started\n ";
 
  // Get RootManager
  FairRootManager* ioman = FairRootManager::Instance();
  if (!ioman) {
    cout << "-E- BmnSiMDDigitizer::Init: " << "RootManager not instantiated!" << endl;
    return kFATAL;
  }
 
  // Get input array
  fPointArray = (TClonesArray*)ioman->GetObject("SiMDPoint");
  if (!fPointArray) {
    cout << "BmnSiMDDigitizer::Init(): branch SiMDPoint not found! Task will be deactivated" << endl;
    SetActive(kFALSE);
    return kERROR;
  }
 
  // Create and register output array
  fDigitArray = new TClonesArray("BmnTrigDigit");
  ioman->Register("SiMDDigit", "SiMD", fDigitArray, kTRUE);
 
  fModsAngles = new Double_t[fNMod];
  for (Int_t i = 0; i < fNMod; i++) {
    fModsAngles[i] = i * 5.625;
  }
 
  if (fVerbose) cout << "BmnSiMDDigitizer::Init() finished\n";
  return kSUCCESS;
 
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
// -----   Public method Exec   --------------------------------------------
void BmnSiMDDigitizer::Exec(Option_t* opt) {
 
  if (!IsActive())
    return;
 
  TStopwatch sw;
  sw.Start();
  
  if (fVerbose) cout << " BmnSiMDDigitizer::Exec() started\n";
 
  // Reset output array
  if (!fDigitArray) Fatal("Exec", "No SiMDDigit array");
 
  fDigitArray->Delete();
 
  //map for storage energies at modules
  map<Int_t, Double_t> ampMap;
 
  // Loop over MCPoints
  for (Int_t iPoint = 0; iPoint < fPointArray->GetEntriesFast(); iPoint++) {
    BmnSiMDPoint* point = (BmnSiMDPoint*)fPointArray->At(iPoint);
    if (!point) continue;
 
    Int_t mod = ModByPoint(point->GetXOut(), point->GetYOut());
 
    auto it = ampMap.find(mod);
    if (it != ampMap.end()) {
      ampMap[mod] += point->GetEnergyLoss();
    } else {
      ampMap[mod] = point->GetEnergyLoss();
    }
  }
 
  //for (map<Int_t, Double_t>::iterator mit = ampMap.begin(); mit != ampMap.end(); ++mit) {
  for (auto mit : ampMap) {
    BmnTrigDigit digi;
    digi.SetMod((Short_t)mit.first);
    digi.SetAmp(mit.second);
    new ((*fDigitArray)[fDigitArray->GetEntriesFast()]) BmnTrigDigit(digi);
  }
 
  if (fVerbose) {
    printf("   Number of BmnSiMDPoints = %d\n", fPointArray->GetEntriesFast());
    printf("   Number of BmnSiMDDigits = %d\n", fDigitArray->GetEntriesFast());
    cout << " BmnSiMDDigitizer::Exec() finished\n";
  } 
 
  sw.Stop();
  workTime += sw.RealTime();
}
 
Int_t BmnSiMDDigitizer::ModByPoint(Double_t x, Double_t y) {
 
  //Double_t XPOS = 0.5;
  //Double_t YPOS = -4.6;
 
  Double_t newX = x;// -XPOS;
  Double_t newY = y;// -YPOS;
  // Double_t pAngle = GetPointAngle(newX, newY);
  Double_t pAngle = TVector2(newX, newY).Phi() * RadToDeg();
  for (Int_t i = 0; i < fNMod; i++) {
    if (pAngle >= fModsAngles[i] && pAngle <= (fModsAngles[i] + 5.6))
      return i;
  }
  return -1;
}
 
void BmnSiMDDigitizer::Finish() {
  printf("Work time of the SiMD digitizer: %4.4f sec.\n", workTime);
}