CbmMuchModuleGemRectangular.cxx

Go to the documentation of this file.

/* Copyright (C) 2012-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: Mikhail Ryzhinskiy, Evgeny Kryshen [committer] */
 
#include "CbmMuchModuleGemRectangular.h"
 
#include "CbmMuchPadRectangular.h"     // for CbmMuchPadRectangular
#include "CbmMuchSectorRectangular.h"  // for CbmMuchSectorRectangular
 
#include <TMathBase.h>  // for Abs
 
#include <algorithm>  // for find
#include <limits>     // for numeric_limits
#include <vector>     // for vector, vector<>::iterator
 
using std::vector;
 
// -----   Default constructor   -------------------------------------------
CbmMuchModuleGemRectangular::CbmMuchModuleGemRectangular()
  : CbmMuchModuleGem()
  , fUseModuleDesign(kFALSE)
  , fGridNx(0)
  , fGridNy(0)
  , fGridDx(0.)
  , fGridDy(0.)
  , fGrid()
{
  fDetectorType = 1;
}
// -------------------------------------------------------------------------
 
 
// -----   Standard constructor   ------------------------------------------
CbmMuchModuleGemRectangular::CbmMuchModuleGemRectangular(Int_t iStation, Int_t iLayer, Bool_t iSide, Int_t iModule,
                                                         TVector3 position, TVector3 size, Double_t cutRadius)
  : CbmMuchModuleGem(iStation, iLayer, iSide, iModule, position, size, cutRadius)
  , fUseModuleDesign(kFALSE)
  , fGridNx(0)
  , fGridNy(0)
  , fGridDx(0.)
  , fGridDy(0.)
  , fGrid()
{
  fDetectorType = 1;
}
// -------------------------------------------------------------------------
 
 
// -----   Public method GetSector   ---------------------------------------
CbmMuchSectorRectangular* CbmMuchModuleGemRectangular::GetSector(Int_t ix, Int_t iy)
{
  if (ix < 0 || ix >= fGridNx) return nullptr;
  if (iy < 0 || iy >= fGridNy) return nullptr;
  Long64_t iSector = fGrid[ix][iy];
  if (iSector == -1) return nullptr;
  return (CbmMuchSectorRectangular*) fSectors[iSector];
}
// -------------------------------------------------------------------------
 
 
// -----   Public method GetSector   ---------------------------------------
CbmMuchSectorRectangular* CbmMuchModuleGemRectangular::GetSector(Double_t x, Double_t y)
{
  return GetSector(GetGridIndexX(x), GetGridIndexY(y));
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
Int_t CbmMuchModuleGemRectangular::GetGridIndexX(Double_t x)
{
  Double_t mx0 = fPosition[0];
  Double_t mlx = fSize[0];
  Double_t msx = mx0 > 0 ? +1 : -1;
  Double_t mx1 = mx0 - msx * mlx / 2;
  return Int_t((x - mx1) / msx / fGridDx);
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
Int_t CbmMuchModuleGemRectangular::GetGridIndexY(Double_t y)
{
  Double_t my0 = fPosition[1];
  Double_t mly = fSize[1];
  Double_t msy = my0 > 0 ? +1 : -1;
  Double_t my1 = my0 - msy * mly / 2;
  return Int_t((y - my1) / msy / fGridDy);
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
CbmMuchPadRectangular* CbmMuchModuleGemRectangular::GetPad(Double_t x, Double_t y)
{
  CbmMuchSectorRectangular* sector = GetSector(x, y);
  if (!sector) return nullptr;
  return sector->GetPad(x, y);
}
// -------------------------------------------------------------------------
 
 
// -----   Public method InitGrid  -----------------------------------------
Bool_t CbmMuchModuleGemRectangular::InitGrid(Bool_t useModuleDesign)
{
  Int_t nSectors = GetNSectors();
  if (!nSectors) return kFALSE;
  fUseModuleDesign = useModuleDesign;
 
  Double_t mx0 = fPosition[0];
  Double_t my0 = fPosition[1];
  Double_t mlx = fSize[0];
  Double_t mly = fSize[1];
  Double_t msx = mx0 > 0 ? +1 : -1;
  Double_t msy = my0 > 0 ? +1 : -1;
  Double_t mx1 = mx0 - msx * mlx / 2;
  Double_t my1 = my0 - msy * mly / 2;
 
  // Determine grid dimensions
  fGridDx = std::numeric_limits<Double_t>::max();
  fGridDy = std::numeric_limits<Double_t>::max();
  for (Int_t iSector = 0; iSector < nSectors; iSector++) {
    CbmMuchSectorRectangular* s = (CbmMuchSectorRectangular*) fSectors[iSector];
    if (s->IsIncomplete()) continue;
    Double_t dx = s->GetSize()[0];
    Double_t dy = s->GetSize()[1];
    if (dx < fGridDx) fGridDx = dx;
    if (dy < fGridDy) fGridDy = dy;
  }
 
  Int_t nCell = fUseModuleDesign ? 1 : 2;  // Number of additional columns/rows in the grid
  fGridNx     = Int_t((mlx + 1e-5) / fGridDx) + nCell;
  fGridNy     = Int_t((mly + 1e-5) / fGridDy) + nCell;
 
  // Fill grid
  fGrid.resize(fGridNx);
  for (Int_t ix = 0; ix < fGridNx; ix++) {
    fGrid[ix].resize(fGridNy);
    for (Int_t iy = 0; iy < fGridNy; iy++) {
      Double_t x    = mx1 + msx * fGridDx * (ix + 1e-3);
      Double_t y    = my1 + msy * fGridDy * (iy + 1e-3);
      fGrid[ix][iy] = -1;
      for (int iSector = 0; iSector < nSectors; iSector++) {
        CbmMuchSectorRectangular* sec = (CbmMuchSectorRectangular*) fSectors[iSector];
        if (sec->Inside(x, y)) {
          fGrid[ix][iy] = sec->GetSectorIndex();
          break;
        }
      }
    }
  }
  return kTRUE;
}
// -------------------------------------------------------------------------
 
// ------ Public method InitNeighbours  ------------------------------------
void CbmMuchModuleGemRectangular::InitNeighbourSectors()
{
  vector<CbmMuchSectorRectangular*> neighbours;
  vector<CbmMuchSectorRectangular*>::iterator it;
  for (Int_t iSector = 0; iSector < GetNSectors(); iSector++) {
    CbmMuchSectorRectangular* sector = (CbmMuchSectorRectangular*) fSectors[iSector];
    Double_t x1                      = sector->GetX1() - 1e-3;
    Double_t x2                      = sector->GetX2() + 1e-3;
    Double_t y1                      = sector->GetY1() - 1e-3;
    Double_t y2                      = sector->GetY2() + 1e-3;
    Double_t ix1                     = GetGridIndexX(x1);
    Double_t ix2                     = GetGridIndexX(x2);
    Double_t iy1                     = GetGridIndexY(y1);
    Double_t iy2                     = GetGridIndexY(y2);
    Double_t ixmin                   = (ix1 < ix2) ? ix1 : ix2;
    Double_t ixmax                   = (ix1 < ix2) ? ix2 : ix1;
    Double_t iymin                   = (iy1 < iy2) ? iy1 : iy2;
    Double_t iymax                   = (iy1 < iy2) ? iy2 : iy1;
    if (ixmin < 0) ixmin = 0;
    if (ixmax >= fGridNx) ixmax = fGridNx - 1;
    if (iymin < 0) iymin = 0;
    if (iymax >= fGridNy) iymax = fGridNy - 1;
 
    for (Int_t ix = ixmin; ix <= ixmax; ix++) {
      for (Int_t iy = iymin; iy <= iymax; iy++) {
        Int_t iSec = fGrid[ix][iy];
        if (iSec < 0) continue;
        if (iSec == iSector) continue;
        CbmMuchSectorRectangular* sec = (CbmMuchSectorRectangular*) fSectors[iSec];
        it                            = find(neighbours.begin(), neighbours.end(), sec);
        if (it == neighbours.end()) neighbours.push_back(sec);
      }
    }
    sector->SetNeighbours(neighbours);
    neighbours.clear();
  }
}
// -------------------------------------------------------------------------
 
// ------ Public method InitNeighbourPads ----------------------------------
void CbmMuchModuleGemRectangular::InitNeighbourPads()
{
  vector<CbmMuchPad*>::iterator it;
  vector<CbmMuchPad*> neighbours;
 
  // Loop over all sectors within the module
  for (Int_t iSector = 0; iSector < GetNSectors(); iSector++) {
    CbmMuchSectorRectangular* sector = (CbmMuchSectorRectangular*) fSectors[iSector];
    if (!sector) continue;
    Double_t mindx                                     = sector->GetPadDx();
    Double_t mindy                                     = sector->GetPadDy();
    vector<CbmMuchSectorRectangular*> neighbourSectors = sector->GetNeighbours();
    for (UInt_t iSec = 0; iSec < neighbourSectors.size(); iSec++) {
      CbmMuchSectorRectangular* sec = neighbourSectors[iSec];
      Double_t dx                   = sec->GetPadDx();
      Double_t dy                   = sec->GetPadDy();
      if (dx < mindx) mindx = dx;
      if (dy < mindy) mindy = dy;
    }
 
    for (Int_t iChannel = 0; iChannel < sector->GetNChannels(); iChannel++) {
      CbmMuchPadRectangular* pad = (CbmMuchPadRectangular*) sector->GetPadByChannelIndex(iChannel);
      Double_t x1                = pad->GetX1();
      Double_t x2                = pad->GetX2();
      Double_t y1                = pad->GetY1();
      Double_t y2                = pad->GetY2();
      for (Double_t x = x1 - mindx / 2; x < x2 + mindx / 2 + 1e-3; x += mindx) {
        for (Double_t y = y1 - mindy / 2; y < y2 + mindy / 2 + 1e-3; y += mindy) {
          CbmMuchPad* p = GetPad(x, y);
          if (!p) continue;
          if (p == pad) continue;
          it = find(neighbours.begin(), neighbours.end(), p);
          if (it == neighbours.end()) neighbours.push_back(p);
        }
      }
      pad->SetNeighbours(neighbours);
      neighbours.clear();
    }
  }
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
Bool_t CbmMuchModuleGemRectangular::InitModule()
{
  Bool_t useModuleDesign = TMath::Abs(fPosition[0]) > 1e-5 || TMath::Abs(fPosition[1]) > 1e-5;
  if (!InitGrid(useModuleDesign)) return kFALSE;
  InitNeighbourSectors();
  for (Int_t iSector = 0; iSector < GetNSectors(); iSector++) {
    CbmMuchSectorRectangular* sector = (CbmMuchSectorRectangular*) fSectors[iSector];
    if (!sector) continue;
    sector->AddPads();
  }
  InitNeighbourPads();
  return kTRUE;
}
// -------------------------------------------------------------------------
 
ClassImp(CbmMuchModuleGemRectangular)