AlignmentParameterSelector.h

Go to the documentation of this file.

#ifndef ALIGNMENTPARAMETERSELECTOR_H
#define ALIGNMENTPARAMETERSELECTOR_H
 
#include "Alignment/CommonAlignment/interface/Utilities.h"
 
class AlignableExtras;
class AlignableTracker;
class AlignableMuon;
 
namespace edm {
  class ParameterSet;
}
 
class AlignmentParameterSelector {
public:
  explicit AlignmentParameterSelector(AlignableTracker *aliTracker,
                                      AlignableMuon *aliMuon = nullptr,
                                      AlignableExtras *aliExtras = nullptr);
 
  virtual ~AlignmentParameterSelector() {}
 
  const align::Alignables &selectedAlignables() const { return theSelectedAlignables; }
  const std::vector<std::vector<char> > &selectedParameters() const { return theSelectedParameters; }
  void clear();
  void clearGeometryCuts();
 
  unsigned int addSelections(const edm::ParameterSet &pSet);
  void setGeometryCuts(const edm::ParameterSet &pSet);
  unsigned int addSelection(const std::string &name, const std::vector<char> &paramSel);
  unsigned int addSelection(const std::string &name, const std::vector<char> &paramSel, const edm::ParameterSet &pSet);
  bool layerDeselected(const Alignable *alignable) const;
  bool detUnitDeselected(const Alignable *alignable) const;
  bool outsideGeometricalRanges(const Alignable *alignable) const;
  bool outsideDetIdRanges(const Alignable *alignable) const;
  template <typename T>
  bool insideRanges(T value, const std::vector<T> &ranges, bool isPhi = false) const;
  bool isMemberOfVector(int value, const std::vector<int> &values) const;
  std::vector<std::string> decompose(const std::string &s, std::string::value_type delimiter) const;
  std::vector<char> convertParamSel(const std::string &selString) const;
 
protected:
  unsigned int add(const align::Alignables &alignables, const std::vector<char> &paramSel);
  unsigned int addAllDets(const std::vector<char> &paramSel);
  unsigned int addAllRods(const std::vector<char> &paramSel);
  unsigned int addAllLayers(const std::vector<char> &paramSel);
  unsigned int addAllAlignables(const std::vector<char> &paramSel);
 
  void setPXBDetIdCuts(const edm::ParameterSet &pSet);
  void setPXFDetIdCuts(const edm::ParameterSet &pSet);
  void setTIBDetIdCuts(const edm::ParameterSet &pSet);
  void setTIDDetIdCuts(const edm::ParameterSet &pSet);
  void setTOBDetIdCuts(const edm::ParameterSet &pSet);
  void setTECDetIdCuts(const edm::ParameterSet &pSet);
 
  const AlignableTracker *alignableTracker() const;
 
private:
  AlignableTracker *theTracker;
  AlignableMuon *theMuon;
  AlignableExtras *theExtras;
  align::Alignables theSelectedAlignables;
  std::vector<std::vector<char> > theSelectedParameters;
 
  std::vector<double> theRangesEta;
  std::vector<double> theRangesPhi;
  std::vector<double> theRangesR;
  std::vector<double> theRangesX;
  std::vector<double> theRangesY;
  std::vector<double> theRangesZ;
 
  std::vector<int> theDetIds;
  std::vector<int> theDetIdRanges;
  std::vector<int> theExcludedDetIds;
  std::vector<int> theExcludedDetIdRanges;
  struct PXBDetIdRanges {
    std::vector<int> theLadderRanges;
    std::vector<int> theLayerRanges;
    std::vector<int> theModuleRanges;
    void clear() {
      theLadderRanges.clear();
      theLayerRanges.clear();
      theModuleRanges.clear();
    }
  } thePXBDetIdRanges;
  struct PXFDetIdRanges {
    std::vector<int> theBladeRanges;
    std::vector<int> theDiskRanges;
    std::vector<int> theModuleRanges;
    std::vector<int> thePanelRanges;
    std::vector<int> theSideRanges;
    void clear() {
      theBladeRanges.clear();
      theDiskRanges.clear();
      theModuleRanges.clear();
      thePanelRanges.clear();
      theSideRanges.clear();
    }
  } thePXFDetIdRanges;
  struct TIBDetIdRanges {
    std::vector<int> theLayerRanges;
    std::vector<int> theModuleRanges;
    std::vector<int> theStringRanges;
    std::vector<int> theSideRanges;
    void clear() {
      theLayerRanges.clear();
      theModuleRanges.clear();
      theSideRanges.clear();
      theStringRanges.clear();
    }
  } theTIBDetIdRanges;
  struct TIDDetIdRanges {
    std::vector<int> theDiskRanges;
    std::vector<int> theModuleRanges;
    std::vector<int> theRingRanges;
    std::vector<int> theSideRanges;
    void clear() {
      theDiskRanges.clear();
      theModuleRanges.clear();
      theRingRanges.clear();
      theSideRanges.clear();
    }
  } theTIDDetIdRanges;
  struct TOBDetIdRanges {
    std::vector<int> theLayerRanges;
    std::vector<int> theModuleRanges;
    std::vector<int> theRodRanges;
    std::vector<int> theSideRanges;
    void clear() {
      theLayerRanges.clear();
      theModuleRanges.clear();
      theRodRanges.clear();
      theSideRanges.clear();
    }
  } theTOBDetIdRanges;
  struct TECDetIdRanges {
    std::vector<int> theWheelRanges;
    std::vector<int> thePetalRanges;
    std::vector<int> theModuleRanges;
    std::vector<int> theRingRanges;
    std::vector<int> theSideRanges;
    void clear() {
      theWheelRanges.clear();
      thePetalRanges.clear();
      theModuleRanges.clear();
      theRingRanges.clear();
      theSideRanges.clear();
    }
  } theTECDetIdRanges;
 
  // further switches used in add(...)
  bool theOnlyDS;
  bool theOnlySS;
  bool theSelLayers;
  int theMinLayer;
  int theMaxLayer;
  enum RphiOrStereoDetUnit { Stereo, Both, Rphi };
  RphiOrStereoDetUnit theRphiOrStereoDetUnit;
  std::string setSpecials(const std::string &name);
};
 
template <>
bool AlignmentParameterSelector::insideRanges<int>(int value, const std::vector<int> &ranges, bool isPhi) const;
 
#endif