PedeSteererWeakModeConstraints.h

Go to the documentation of this file.

#ifndef PEDESTEERERWEAKMODECONSTRAINTS_H
#define PEDESTEERERWEAKMODECONSTRAINTS_H

#include <list>
#include <vector>
#include <map> 
#include <set> 
#include <string>
// forward ofstream:
#include <iosfwd> 

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "Alignment/MillePedeAlignmentAlgorithm/src/PedeSteerer.h"

#include <DataFormats/GeometryVector/interface/GlobalPoint.h>
#include <CondFormats/Alignment/interface/Definitions.h>

class Alignable;
class PedeLabelerBase;

/***************************************
****************************************/

//FIXME: move GeometryConstraintConfigData to PedeSteererWeakModeConstraints?
class GeometryConstraintConfigData {
 public:
  GeometryConstraintConfigData(const std::vector<double> co,
                               const std::string c,
                               const std::vector<std::pair<Alignable*,std::string> > &alisFile,
                               const int sd,
                               const std::vector<Alignable*> ex
                               );
  const std::vector<double> coefficients_;
  const std::string constraintName_;
  const std::vector<std::pair<Alignable*, std::string> > levelsFilenames_;
  const std::vector<Alignable*> excludedAlignables_;
  std::map<std::string, std::ofstream*> mapFileName_;
  std::list<std::pair<Alignable*, std::list<Alignable*> > > HLSsubdets_; //first pointer to HLS object, second list is the list of pointers to the lowest components
  int sysdeformation_;
};

class PedeSteererWeakModeConstraints {
 public:
  ~PedeSteererWeakModeConstraints();
  PedeSteererWeakModeConstraints(AlignableTracker *aliTracker,
                                 const PedeLabelerBase *labels,
                                 const std::vector<edm::ParameterSet> &config,
                                 std::string sf
                                 );

  //FIXME: split the code of the method into smaller pieces/submethods
  // Main method that configures everything and calculates also the constraints
  unsigned int constructConstraints(const std::vector<Alignable*> &alis);
 
  // Returns a references to the container in which the configuration is stored
  std::list<GeometryConstraintConfigData>* getConfigData() { return &ConstraintsConfigContainer_; }

 private:
  // Method creates the data structures with the full configuration
  unsigned int createAlignablesDataStructure();

  // Write the calculated constraints to the output files
  void writeOutput(const std::list<std::pair<unsigned int,double> > &output,
                   const std::list<GeometryConstraintConfigData>::const_iterator &it, Alignable* iHLS, double sum_xi_x0);

  // Close the output files
  void closeOutputfiles();

  // Checks whether lowleveldet is a daugther of HLS
  bool checkMother(const Alignable * const lowleveldet, const Alignable * const HLS) const;

  std::pair<align::GlobalPoint, align::GlobalPoint> getDoubleSensorPosition(const Alignable *ali) const;

  double getPhase(const std::vector<double> &coefficients) const;

  // The function for the geometry deformation is defined as f(x).
  // The methods returns x depending on the type of deformation
  double getX(const int sysdeformation, const align::GlobalPoint &pos, const double phase) const;

  double getX0(std::list<std::pair<Alignable*, std::list<Alignable*> > >::iterator &iHLS,
               std::list<GeometryConstraintConfigData>::iterator &it);

  // Calculates and returns the coefficient for alignment parameter iParameter
  // for an alignable at position pos.
  double getCoefficient(const int sysdeformation,
                        const align::GlobalPoint &pos,
                        const GlobalPoint gUDirection,
                        const GlobalPoint gVDirection,
                        const GlobalPoint gWDirection,
                        const int iParameter, const double &x0,
                        const std::vector<double> &constraintparameters) const;

  //returns true if iParameter of Alignable is selected in configuration file
  bool checkSelectionShiftParameter(const Alignable *ali, unsigned int iParameter) const;
 
  // Method used to test the provided configuration for unknown parameters
  void verifyParameterNames(const edm::ParameterSet &pset, unsigned int psetnr) const;

  // Method which creates the associative map between levels and coefficient file names
  const std::vector<std::pair<Alignable*, std::string> > makeLevelsFilenames(
                                                                             std::set<std::string> &steerFilePrefixContainer,
                                                                             const std::vector<Alignable*> &alis,
                                                                             const std::string &steerFilePrefix
                                                                             ) const;

  // Verify that the name of the configured deformation is known and that the number of coefficients has been correctly configured
  int verifyDeformationName(const std::string &name, const std::vector<double> &coefficients) const;
  
  //list of dead modules which are not used in any constraint
  std::list<align::ID> deadmodules_; 

  //the data structure that holds all needed informations for the constraint configuration
  std::list<GeometryConstraintConfigData> ConstraintsConfigContainer_;

  const PedeLabelerBase *myLabels_; //PedeLabeler needed to get for the alignables the corresponding Pede label

  const std::vector<edm::ParameterSet> myConfig_; //the VPSet with the configurations for all constraints

  const std::string steerFile_; // the name of the PedeSteerer steering file

  enum SystematicDeformations {
    kUnknown = 0,
    kTwist,
    kZexpansion,
    kSagitta,
    kRadial,
    kTelescope,
    kLayerRotation,
    kElliptical,
    kBowing,
    kSkew
  };
};
 
#endif