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 = 0,
                      AlignableExtras *aliExtras = 0);

  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