CbmMuchSegmentManual.h

Go to the documentation of this file.

/* Copyright (C) 2009-2020 St. Petersburg Polytechnic University, St. Petersburg
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Mikhail Ryzhinskiy [committer], Florian Uhlig */
 
#ifndef CBMMUCHSEGMENTMANUAL_H
#define CBMMUCHSEGMENTMANUAL_H 1
 
#include <FairTask.h>  // for FairTask, InitStatus
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Int_t, Double_t, Bool_t, Char_t, Option_t
#include <TString.h>     // for TString
 
#include <fstream>   // for string, getline, char_traits, basic_istream
#include <map>       // for map
#include <sstream>   // for stringstream
#include <typeinfo>  // for bad_cast
#include <vector>    // for vector
 
class CbmGeoMuchPar;
class CbmMuchLayerSide;
class CbmMuchModuleGemRectangular;
class CbmMuchSectorRectangular;
class TObjArray;
 
class CbmMuchSegmentManual : public FairTask {
 
public:
  CbmMuchSegmentManual();
 
  virtual ~CbmMuchSegmentManual();
 
  CbmMuchSegmentManual(char* inputFile, char* digiFileName);
 
  virtual InitStatus Init();
 
  void SegmentMuch();
 
  void SetNStations(Int_t nStations) { fNStations = nStations; }
 
  void SetNRegions(Int_t iStation, Int_t nRegions);
 
  void SetRegionRadius(Int_t iStation, Int_t iRegion, Double_t radius);
 
  void SetNChannels(Int_t iStation, Int_t nChannels);
 
  void SetSigma(Int_t iStation, Int_t iRegion, Double_t sigmaX, Double_t sigmaY);
 
  void SetPadSize(Int_t iStation, Int_t iRegion, Double_t padLx, Double_t padLy);
 
  void DebugSwitchOn() { fDebug = 1; }
 
private:
  CbmGeoMuchPar* fGeoPar;            // Geometry parameters container
  Int_t fNStations;                  // Number of stations
  TObjArray* fStations;              // Array of stations
  Char_t* fInputFileName;            // Name of the file with input parameters
  Char_t* fDigiFileName;             // Name of the file with segmentation parameters
  std::map<Int_t, Int_t> fNRegions;  // Map from a station index to a number of circled regions in the station
  std::map<Int_t, std::vector<Double_t>> fRadii;  // Map from a station index to a vector of circled regions radii
  std::map<Int_t, std::vector<Double_t>>
    fSecLx;  // Map from a station index to a vector of sector widths for each region
  std::map<Int_t, std::vector<Double_t>>
    fSecLy;                                    // Map from a station index to a vector of sector lengths for each region
  std::map<Int_t, Int_t> fNChannels;           // Map from a station index to a number of channels per sector
  std::map<Int_t, std::vector<Int_t>> fNCols;  // Map from a station index to a vector of number of columns in a sector
  std::map<Int_t, std::vector<Int_t>> fNRows;  // Map from a station index to a vector of number of rows in a sector
  Int_t fDebug;                                // Debug info switch
 
  virtual void SetParContainers();
 
  Int_t IntersectsRad(CbmMuchModuleGemRectangular* module, Double_t radius);
 
  Int_t IntersectsRad(CbmMuchSectorRectangular* sector, Double_t radius);
 
  void SegmentLayerSide(CbmMuchLayerSide* layerSide);
 
  void SegmentModule(CbmMuchModuleGemRectangular* module, Bool_t useModuleDesign);
 
  void SegmentSector(CbmMuchModuleGemRectangular* module, CbmMuchSectorRectangular* sector);
 
  Double_t GetSectorMaxSize(CbmMuchModuleGemRectangular* module, const TString side, Int_t& iRegion);
 
  Double_t GetPadMaxSize(CbmMuchModuleGemRectangular* module, const TString side);
 
  Bool_t ShouldSegment(CbmMuchSectorRectangular* sector, const TString direction, Int_t& iRegion);
 
  Int_t GetRegionIndex(CbmMuchSectorRectangular* sector);
 
  Bool_t IsIncompleteSector(CbmMuchSectorRectangular* sector);
 
  void DrawSegmentation();
 
  void Print(Option_t* = "") const;
 
  void ReadInputFile();
 
 
  // -------------------- Methods for working with strings --------------------------
  void Trim(std::string& str)
  {
    std::string::size_type pos1 = str.find_first_not_of(' ');
    std::string::size_type pos2 = str.find_last_not_of(' ');
    str =
      str.substr(pos1 == std::string::npos ? 0 : pos1, pos2 == std::string::npos ? str.length() - 1 : pos2 - pos1 + 1);
  }
 
  Bool_t IsDummyLine(std::string& str)
  {
    Trim(str);
    return str[0] == '#' || str.length() == 0 || str[0] == '\0' || str[0] == '\n';
  }
 
  void OmitDummyLines(std::ifstream& infile, std::string& str)
  {
    getline(infile, str);
    while (IsDummyLine(str))
      getline(infile, str);
  }
 
  std::vector<std::string>& Split(const std::string& s, char delim, std::vector<std::string>& elems)
  {
    std::stringstream ss(s);
    std::string item;
    while (getline(ss, item, delim)) {
      if (item.length() != 0) elems.push_back(item);
    }
    return elems;
  }
 
 
  std::vector<std::string> Split(const std::string& s, char delim)
  {
    std::vector<std::string> elems;
    return Split(s, delim, elems);
  }
 
  template<class T>
  void StrToNum(std::string& str, T& number)
  {
    try {
      std::stringstream ss(str);
      if ((ss >> number).fail() || !(ss >> std::ws).eof()) throw std::bad_cast();
    }
    catch (const std::bad_cast& exc) {
      Fatal("", "Invalid cast.\n");
    }
  }
  // --------------------------------------------------------------------------------
 
  CbmMuchSegmentManual(const CbmMuchSegmentManual&);
  CbmMuchSegmentManual& operator=(const CbmMuchSegmentManual&);
 
  ClassDef(CbmMuchSegmentManual, 1)
};
 
#endif