CbmMuchSegmentSector.h

Go to the documentation of this file.

 
#ifndef CbmMuchSegmentSector_H
#define CbmMuchSegmentSector_H 1
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Int_t, Double_t, Bool_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 CbmMuchModuleGemRadial;
class CbmMuchSectorRadial;
class TObjArray;
 
class CbmMuchSegmentSector : public FairTask {
 
public:
  CbmMuchSegmentSector();
 
  virtual ~CbmMuchSegmentSector();
 
  CbmMuchSegmentSector(TString inputFile, TString digiFileName, Int_t flag);
 
  virtual InitStatus Init();
 
  void SegmentMuch();
 
  void DebugSwitchOn() { fDebug = 1; }
 
private:
  CbmGeoMuchPar* fGeoPar;  // Geometry parameters container
  Int_t fNStations;        // Number of stations
  Int_t fFlag;             // falg for geometry
  TObjArray* fStations;    // Array of stations
  TString fInputFileName;  // Name of the file with input parameters
  TString 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>>
    fAngles;  // Map from a station index to a vector of single pad angles for given regions
  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 SegmentLayerSide(CbmMuchLayerSide* layerSide);
 
  Int_t SegmentModule(CbmMuchModuleGemRadial* module, Bool_t useModuleDesign);
 
  void SegmentSector(CbmMuchModuleGemRadial* module,
                     CbmMuchSectorRadial* sector);
 
  void ReadInputFile();
 
  void DrawSegmentation();
 
  // -------------------- 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"); }
  }
  // --------------------------------------------------------------------------------
 
  CbmMuchSegmentSector(const CbmMuchSegmentSector&);
  CbmMuchSegmentSector& operator=(const CbmMuchSegmentSector&);
 
  ClassDef(CbmMuchSegmentSector, 1)
};
 
#endif