CbmMuchModuleGemRadial.cxx

Go to the documentation of this file.

/* Copyright (C) 2011-2020 Petersburg Nuclear Physics Institute named by B.P.Konstantinov of National Research Centre "Kurchatov Institute", Gatchina
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Evgeny Kryshen [committer], Florian Uhlig */
 
#include "CbmMuchModuleGemRadial.h"
 
#include "CbmMuchPad.h"           // for CbmMuchPad
#include "CbmMuchPadRadial.h"     // for CbmMuchPadRadial
#include "CbmMuchSectorRadial.h"  // for CbmMuchSectorRadial
 
#include <Logger.h>  // for LOG
 
#include <TVector3.h>  // for TVector3
 
#include <algorithm>  // for upper_bound
#include <vector>     // for vector<>::iterator, vector
 
using std::vector;
 
// -------------------------------------------------------------------------
CbmMuchModuleGemRadial::CbmMuchModuleGemRadial()
  : CbmMuchModuleGem()
  , fSectorRadii()
  , fDx1(0.)
  , fDx2(0.)
  , fDy(0.)
  , fDz(0.)
{
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
CbmMuchModuleGemRadial::CbmMuchModuleGemRadial(Int_t DetType, Int_t iStation, Int_t iLayer, Bool_t iSide, Int_t iModule,
                                               TVector3 pos, Double_t dx1, Double_t dx2, Double_t dy, Double_t dz,
                                               Double_t cutRadius)
  : CbmMuchModuleGem(iStation, iLayer, iSide, iModule, pos, TVector3(dx1 + dx2, 2 * dy, 2 * dz), cutRadius)
  , fSectorRadii()
  , fDx1(dx1)
  , fDx2(dx2)
  , fDy(dy)
  , fDz(dz)
  , fDetType(DetType)
{
  fDetectorType = fDetType;
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
CbmMuchSectorRadial* CbmMuchModuleGemRadial::GetSectorByRadius(Double_t r)
{
  vector<Double_t>::iterator i0, ie, i;
  i0 = fSectorRadii.begin();
  ie = fSectorRadii.end();
  i  = upper_bound(i0, ie, r);
  return i - i0 - 1 >= 0 ? (CbmMuchSectorRadial*) fSectors[i - i0 - 1] : nullptr;
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
CbmMuchPadRadial* CbmMuchModuleGemRadial::GetPad(Double_t x, Double_t y)
{
  TVector3 v                  = TVector3(x, y, 0);
  CbmMuchSectorRadial* sector = GetSectorByRadius(v.Mag());
  return sector->GetPadByPhi(v.Phi());
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
Bool_t CbmMuchModuleGemRadial::InitModule()
{
  for (Int_t s = 0; s < GetNSectors(); s++) {
    CbmMuchSectorRadial* sector = (CbmMuchSectorRadial*) GetSectorByIndex(s);
    if (!sector) continue;
    fSectorRadii.push_back(sector->GetR1());
    sector->AddPads();
  }
  vector<CbmMuchPad*> neighbours;
  for (Int_t s = 0; s < GetNSectors(); s++) {
    CbmMuchSectorRadial* sector = (CbmMuchSectorRadial*) GetSectorByIndex(s);
    if (!sector) continue;
    for (Int_t p = 0; p < sector->GetNChannels(); p++) {
      CbmMuchPadRadial* pad = (CbmMuchPadRadial*) sector->GetPadByChannelIndex(p);
      if (!pad) continue;
      if (p > 0) neighbours.push_back(sector->GetPadByChannelIndex(p - 1));
      if (p < sector->GetNChannels() - 1) neighbours.push_back(sector->GetPadByChannelIndex(p + 1));
      CbmMuchSectorRadial* sec1 = s > 0 ? (CbmMuchSectorRadial*) GetSectorByIndex(s - 1) : 0;
      CbmMuchSectorRadial* sec2 = s < GetNSectors() - 1 ? (CbmMuchSectorRadial*) GetSectorByIndex(s + 1) : 0;
      Double_t phi1             = pad->GetPhi1() - 0.001;
      Double_t phi2             = pad->GetPhi2() + 0.001;
      if (sec1) {
        CbmMuchPad* pad11 = sec1->GetPadByPhi(phi1);
        CbmMuchPad* pad12 = sec1->GetPadByPhi(phi2);
        Int_t iMin        = (pad11) ? pad11->GetChannelIndex() : 0;
        Int_t iMax        = (pad12) ? pad12->GetChannelIndex() : sec1->GetNChannels() - 1;
        for (Int_t i = iMin; i <= iMax; i++)
          neighbours.push_back(sec1->GetPadByChannelIndex(i));
      }
      if (sec2) {
        CbmMuchPad* pad21 = sec2->GetPadByPhi(phi1);
        CbmMuchPad* pad22 = sec2->GetPadByPhi(phi2);
        Int_t iMin        = (pad21) ? pad21->GetChannelIndex() : 0;
        Int_t iMax        = (pad22) ? pad22->GetChannelIndex() : sec2->GetNChannels() - 1;
        for (Int_t i = iMin; i <= iMax; i++)
          neighbours.push_back(sec2->GetPadByChannelIndex(i));
      }
      pad->SetNeighbours(neighbours);
      neighbours.clear();
    }
  }
  LOG(debug4) << "Init module successful";
  return kTRUE;
}
// -------------------------------------------------------------------------
 
ClassImp(CbmMuchModuleGemRadial)