AlignmentParameterStore.h

Go to the documentation of this file.

#ifndef Alignment_CommonAlignmentAlgorithm_AlignmentParameterStore_h
#define Alignment_CommonAlignmentAlgorithm_AlignmentParameterStore_h

#include "Alignment/CommonAlignment/interface/Utilities.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignableData.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentCorrelationsStore.h"
#include "Alignment/CommonAlignmentParametrization/interface/CompositeAlignmentParameters.h"


namespace edm {
  class ParameterSet;
}
class AlignmentUserVariables;
class TrackerTopology;

class AlignmentParameterStore {
public:
  typedef std::vector<AlignmentParameters*> Parameters;
  typedef std::map<std::pair<Alignable*, Alignable*>, AlgebraicMatrix> Correlations;
  typedef std::vector<unsigned int> DetIds;

  AlignmentParameterStore(const align::Alignables& alis, const edm::ParameterSet& config);

  virtual ~AlignmentParameterStore();

  CompositeAlignmentParameters selectParameters(const std::vector<AlignableDet*>& alignabledets) const;
  CompositeAlignmentParameters selectParameters(const std::vector<AlignableDetOrUnitPtr>& alignabledets) const;
  CompositeAlignmentParameters selectParameters(const align::Alignables&) const;

  void updateParameters(const CompositeAlignmentParameters& aap, bool updateCorrelations = true);

  const align::Alignables& alignables(void) const { return theAlignables; }

  align::Alignables validAlignables(void) const;

  int numObjects(void) const { return theAlignables.size(); }

  AlignmentCorrelationsStore* correlationsStore(void) const { return theCorrelationsStore; }

  const unsigned int numCorrelations(void) const { return theCorrelationsStore->size(); }

  /*   Alignable* alignableFromGeomDet( const GeomDet* geomDet ) const; */

  Alignable* alignableFromAlignableDet(const AlignableDetOrUnitPtr& alignableDet) const;

  /*   Alignable* alignableFromDetId(const unsigned int& detId) const; */

  void applyParameters(void);

  void applyParameters(Alignable* alignable);

  void resetParameters(void);

  void resetParameters(Alignable* ali);

  void cacheTransformations(void);

  void cacheTransformations(const align::RunNumber&);

  void restoreCachedTransformations(void);

  void restoreCachedTransformations(const align::RunNumber&);

  void acquireRelativeParameters(void);

  void applyAlignableAbsolutePositions(const align::Alignables& alis, const AlignablePositions& newpos, int& ierr);

  void applyAlignableRelativePositions(const align::Alignables& alivec, const AlignableShifts& shifts, int& ierr);

  void attachAlignmentParameters(const align::Alignables& alivec, const Parameters& parvec, int& ierr);

  void attachAlignmentParameters(const Parameters& parvec, int& ierr);

  void attachCorrelations(const align::Alignables& alivec, const Correlations& cormap, bool overwrite, int& ierr);

  void attachCorrelations(const Correlations& cormap, bool overwrite, int& ierr);

  void attachUserVariables(const align::Alignables& alivec,
                           const std::vector<AlignmentUserVariables*>& uvarvec,
                           int& ierr);

  void setAlignmentPositionError(const align::Alignables& alivec, double valshift, double valrot);

  std::pair<int, int> typeAndLayer(const Alignable* ali, const TrackerTopology* tTopo) const;

  typedef std::pair<Alignable*, unsigned int> ParameterId;
  bool hierarchyConstraints(const Alignable* aliMaster,
                            const align::Alignables& aliComps,
                            std::vector<std::vector<ParameterId> >& paramIdsVecOut,
                            std::vector<std::vector<double> >& factorsVecOut,
                            bool all,
                            double epsilon) const;

protected:
  // storage for correlations
  AlignmentCorrelationsStore* theCorrelationsStore;

private:
  enum TypeOfConstraints { NONE, HIERARCHY_CONSTRAINTS, APPROX_AVERAGING_CONSTRAINTS };

  // data members

  align::Alignables theAlignables;

  TypeOfConstraints theTypeOfConstraints;
};

#endif