EcalDccWeightBuilder.h

Go to the documentation of this file.

/*
 */

#ifndef ECALDCCWEIGHTBUILDER_CC
#define ECALDCCWEIGHTBUILDER_CC


#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EBShape.h"
#include "SimCalorimetry/EcalSimAlgos/interface/EEShape.h"
#include "DataFormats/EcalDetId/interface/EBDetId.h"
#include "DataFormats/EcalDetId/interface/EEDetId.h"
#include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"

#include <vector>
#include <map>
#include <cinttypes>

// Forward declarations:
class EcalElectronicsMapping;

class EcalDccWeightBuilder: public edm::EDAnalyzer {
private:
  enum mode_t { WEIGHTS_FROM_CONFIG, COMPUTE_WEIGHTS};
  
  //constructor(s) and destructor(s)
public:
  EcalDccWeightBuilder(edm::ParameterSet const& ps);
  
  ~EcalDccWeightBuilder() override{};

  //method(s)
public:

  void analyze(const edm::Event& event, const edm::EventSetup& es) override;

private:

  void
  computeWeights(const EcalShapeBase& shape,
         int binOfMax, double timePhase, 
         int iFirst0, int nWeights, int iSkip0,
                 std::vector<double>& result);

  void computeAllWeights(bool withIntercalib);
  
  int encodeWeight(double w);

  double decodeWeight(int W);

  void unbiasWeights(std::vector<double>& weights,
                     std::vector<int32_t>* encodedWeigths);

  double intercalib(const DetId& detId);
  
  void writeWeightToAsciiFile();
  void writeWeightToRootFile();   
  void writeWeightToDB();

  //converts DetId to IDs used by DB:
  void dbId(const DetId& detId, int& fedId, int& smId, int& ruId,
           int& xtalId) const;

  template<class T>
  void sort(const std::vector<T>& a,
        std::vector<int>& s,
        bool decreasingOrder = false);

  
  //attribute(s)
protected:
private:
  int dcc1stSample_;
  int sampleToSkip_;
  int nDccWeights_;
  std::vector<double> inputWeights_;
  std::string mode_;
  mode_t imode_;
  bool dccWeightsWithIntercalib_;
  bool writeToDB_;
  bool writeToAsciiFile_;
  bool writeToRootFile_;
  std::string asciiOutputFileName_;
  std::string rootOutputFileName_;
  std::string dbSid_;
  std::string dbUser_;
  std::string dbPassword_;
  std::string dbTag_;
  int dbVersion_;
  bool sqlMode_;
  
  edm::ESHandle<CaloGeometry> geom_;
  
  EcalIntercalibConstantMap& calibMap_;
  EcalIntercalibConstantMap emptyCalibMap_;
  std::map<DetId, std::vector<int> > encodedWeights_;

  static const double weightScale_;
  const EcalElectronicsMapping* ecalElectronicsMap_;

  static const int ecalDccFedIdMin = 601;
  static const int ecalDccFedIdMax = 654;
  static const int nDccs = ecalDccFedIdMax-ecalDccFedIdMin+1;
};

#endif //ECALDCCWEIGHTBUILDER_CC not defined