CbmMuchSegmentManual.h

Go to the documentation of this file.

 
#ifndef CBMMUCHSEGMENTMANUAL_H
#define CBMMUCHSEGMENTMANUAL_H 1
 
#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 <typeinfo>  // for bad_cast
#include <vector>    // for vector
 
#include <FairTask.h>  // for FairTask, InitStatus
 
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 (std::bad_cast exc) { Fatal("", "Invalid cast.\n"); }
  }
  // --------------------------------------------------------------------------------
 
  CbmMuchSegmentManual(const CbmMuchSegmentManual&);
  CbmMuchSegmentManual& operator=(const CbmMuchSegmentManual&);
 
  ClassDef(CbmMuchSegmentManual, 1)
};
 
#endif