BackgroundFunction Class Reference

#include <BackgroundFunction.h>

Inheritance diagram for BackgroundFunction:

Public Member Functions
	BackgroundFunction (TString identifier)
	BackgroundFunction (const MuScleFitDBobject *dbObject)
backgroundFunctionBase *	function (const unsigned int i)
	Get the ith background function. More...
	~BackgroundFunction ()
Public Member Functions inherited from BaseFunction
	BaseFunction ()
	BaseFunction (const MuScleFitDBobject *dbObject)
	Constructor when receiving database parameters. More...
std::vector< double >	fitQuality () const
	Return the vector of fit quality values. More...
std::vector< int >	identifiers () const
	Return the vector of function identifiers. More...
std::vector< double >	parameters () const
	Return the vector of parameters. More...

Protected Member Functions
void	readParameters (TString fileName)
	Parser of the parameters file. More...
Protected Member Functions inherited from BaseFunction
template<class T >
void	convertToArrays (T **&function_, const std::vector< T *> &functionVec_)
	Convert vectors to arrays for faster random access. The first pointer is replaced, thus it is taken by reference. More...

Protected Attributes
backgroundFunctionBase **	backgroundFunction_
std::vector< backgroundFunctionBase * >	backgroundFunctionVec_
Protected Attributes inherited from BaseFunction
std::vector< double >	fitQuality_
double **	fitQualityArray_
std::vector< int >	functionId_
int	iterationNum_
double **	parArray_
std::vector< double >	parVecVec_

Detailed Description

Class for the resolution function. It can be built from local file or from db.

Definition at line 15 of file BackgroundFunction.h.

Constructor & Destructor Documentation

BackgroundFunction() [1/2]

BackgroundFunction::BackgroundFunction ( TString  identifier )

inline

The constructor takes a string identifying the parameters to read. It parses the txt file containing the parameters, extracts the index of the correction function and saves the corresponding pointer. It then fills the vector of parameters.

Definition at line 23 of file BackgroundFunction.h.

References gather_cfg::cout, BaseFunction::functionId_, and readParameters().

                                         {
    identifier.Prepend("MuonAnalysis/MomentumScaleCalibration/data/");
    identifier.Append(".txt");
    edm::FileInPath fileWithFullPath(identifier.Data());
    readParameters(fileWithFullPath.fullPath());

    std::vector<int>::const_iterator idIt = functionId_.begin();
    for (; idIt != functionId_.end(); ++idIt)
      std::cout << "idIt = " << *idIt << std::endl;
  }

BackgroundFunction() [2/2]

BackgroundFunction::BackgroundFunction ( const MuScleFitDBobject *  dbObject )

inline

This constructor is used when reading parameters from the db. It receives a pointer to an object of type MuScleFitDBobject containing the parameters and the functions identifiers. The object is the same for all the functions.

Definition at line 39 of file BackgroundFunction.h.

References backgroundFunction_, backgroundFunctionService(), backgroundFunctionVec_, BaseFunction::convertToArrays(), BaseFunction::functionId_, and l1ctLayer2EG_cff::id.

                                                        : BaseFunction(dbObject) {
    std::vector<int>::const_iterator id = functionId_.begin();
    for (; id != functionId_.end(); ++id) {
      // TODO: fix the values for the lower and upper limits
      backgroundFunctionVec_.push_back(backgroundFunctionService(*id, 0., 200.));
    }
    // Fill the arrays that will be used when calling the correction function.
    convertToArrays(backgroundFunction_, backgroundFunctionVec_);
  }

~BackgroundFunction()

BackgroundFunction::~BackgroundFunction ( )

inline

Definition at line 49 of file BackgroundFunction.h.

References backgroundFunction_, BaseFunction::functionId_, mps_fire::i, and BaseFunction::parArray_.

                        {
    if (parArray_ != nullptr) {
      for (unsigned int i = 0; i < functionId_.size(); ++i) {
        delete[] parArray_[i];
        delete backgroundFunction_[i];
      }
      delete[] parArray_;
      delete[] backgroundFunction_;
    }
  }

Member Function Documentation

function()

backgroundFunctionBase* BackgroundFunction::function ( const unsigned int  i )

inline

Get the ith background function.

Definition at line 60 of file BackgroundFunction.h.

References backgroundFunction_, backgroundFunctionVec_, and mps_fire::i.

                                                         {
    if (backgroundFunctionVec_.size() > i)
      return backgroundFunction_[i];
    else
      return nullptr;
  }

readParameters()

void BackgroundFunction::readParameters ( TString  fileName )

protected

Parser of the parameters file.

Definition at line 3 of file BackgroundFunction.cc.

References backgroundFunction_, backgroundFunctionService(), backgroundFunctionVec_, BaseFunction::convertToArrays(), MillePedeFileConverter_cfg::fileName, BaseFunction::functionId_, recoMuon::in, align_cfg::iteration, BaseFunction::iterationNum_, mps_splice::line, EgammaValidation_cff::num, BaseFunction::parArray_, BaseFunction::parVecVec_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by BackgroundFunction().

                                                        {
  iterationNum_ = 0;
  parArray_ = nullptr;
  // std::vector<double> parameterErrors;

  // Read the parameters file
  std::ifstream parametersFile(fileName.Data());
  std::string line;

  std::string iteration("Iteration ");
  // Loop on the file lines
  while (parametersFile) {
    getline(parametersFile, line);
    size_t lineInt = line.find("value");

    // if( line.find(iteration) != std::string::npos ) {
    size_t iterationSubStr = line.find(iteration);

    // Take the iteration number
    if (iterationSubStr != std::string::npos) {
      int functionNum = 0;
      // This can be used when dealing with multiple iterations

      // std::cout << "line = " << line << std::endl;
      std::stringstream sLine(line);
      std::string num;
      int wordCounter = 0;
      // Warning: this strongly depends on the parameters file structure.
      while (sLine >> num) {
        ++wordCounter;
        //         std::cout << "num["<<wordCounter<<"] = " << num << std::endl;
        if (wordCounter == 10) {
          std::stringstream in(num);
          in >> functionNum;
        }
        if (wordCounter == 13) {
          std::stringstream in(num);
          in >> iterationNum_;
        }
      }
      // std::cout << "iteration number = " << iterationNum_ << std::endl;
      // std::cout << "scale function number = " << scaleFunctionNum << std::endl;

      //       // Create a new vector to hold the parameters for this iteration
      //       std::vector<double> parVec;
      //       parVecVec_.push_back(parVec);

      // Set the scaleFunction
      // scaleFunction_ = scaleFunctionArrayForVec[scaleFunctionNum];
      // scaleFunction_ = scaleFunctionArray[scaleFunctionNum];
      functionId_.push_back(functionNum);
      // scaleFunctionVec_.push_back( scaleFunctionArray[scaleFunctionNum] );
      // TODO: fix the lower and upper limits of the function
      backgroundFunctionVec_.push_back(backgroundFunctionService(functionNum, 0., 200.));
    }
    // Take the parameters for the current iteration
    if ((lineInt != std::string::npos)) {
      size_t subStr1 = line.find("value");
      std::stringstream paramStr;
      double param = 0;
      // Even if all the rest of the line is taken, the following
      // convertion to a double will stop at the end of the first number.
      paramStr << line.substr(subStr1 + 5);
      paramStr >> param;
      //       // Fill the last vector of parameters, which corresponds to this iteration.
      //       parVecVec_.back().push_back(param);
      parVecVec_.push_back(param);
      // std::cout << "param = " << param << std::endl;

      // This is to extract parameter errors
      // size_t subStr2 = line.find("+-");
      // std::stringstream parErrorStr;
      // double parError = 0;
      // parErrorStr << line.substr(subStr2+1);
      // parErrorStr >> parError;
      // parameterErrors.push_back(parError);
      // std::cout << "parError = " << parError << std::endl;
    }
  }

  convertToArrays(backgroundFunction_, backgroundFunctionVec_);
}

Member Data Documentation

backgroundFunction_

backgroundFunctionBase** BackgroundFunction::backgroundFunction_

protected

Definition at line 71 of file BackgroundFunction.h.

Referenced by BackgroundFunction(), function(), readParameters(), and ~BackgroundFunction().

backgroundFunctionVec_

std::vector<backgroundFunctionBase*> BackgroundFunction::backgroundFunctionVec_

protected

Definition at line 72 of file BackgroundFunction.h.

Referenced by BackgroundFunction(), function(), and readParameters().