ConeAreaFunction.cc

Go to the documentation of this file.

#include "PhysicsTools/IsolationUtils/interface/ConeAreaFunction.h"

// -*- C++ -*-
//
// Package:    ConeAreaFunction
// Class:      ConeAreaFunction
// 
//
// Original Author:  Christian Veelken, UC Davis
//         Created:  Thu Nov  2 13:47:40 CST 2006
//
//

// C++ standard library include files
#include <iostream>
#include <iomanip>
#include <vector>

// ROOT include files
#include <TMath.h>

// CMSSW include files
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "PhysicsTools/IsolationUtils/interface/IntegrandThetaFunction.h"
#include "DataFormats/Math/interface/normalizedPhi.h"

//
// constructors and destructor
//

ConeAreaFunction::ConeAreaFunction()
  : ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>(2)
{
  theta0_ = 0.; 
  phi0_ = 0.; 

  etaMax_ = -1;

  fTheta_ = new IntegrandThetaFunction();
  integrator_ = new ROOT::Math::Integrator(*fTheta_);
}

ConeAreaFunction::ConeAreaFunction(const ConeAreaFunction& bluePrint)
{
  theta0_ = bluePrint.theta0_;
  phi0_ = bluePrint.phi0_;

  etaMax_ = bluePrint.etaMax_;

  fTheta_ = new IntegrandThetaFunction(*bluePrint.fTheta_);
  integrator_ = new ROOT::Math::Integrator(*fTheta_);
}

ConeAreaFunction::~ConeAreaFunction()
{
  delete fTheta_; // function gets deleted automatically by Integrator ?
  delete integrator_;
}

//
// assignment operator
//

ConeAreaFunction& ConeAreaFunction::operator=(const ConeAreaFunction& bluePrint)
{
  theta0_ = bluePrint.theta0_;
  phi0_ = bluePrint.phi0_;
  
  etaMax_ = bluePrint.etaMax_;

  (*fTheta_) = (*bluePrint.fTheta_);
  integrator_->SetFunction(*fTheta_);

  return (*this);
}

//
// member functions
//

void ConeAreaFunction::SetParameterTheta0(double theta0)
{
  theta0_ = theta0;
}

void ConeAreaFunction::SetParameterPhi0(double phi0)
{
  phi0_ = normalizedPhi(phi0); // map azimuth angle into interval [-pi,+pi]
}

void ConeAreaFunction::SetParameters(const double* param)
{
  if ( debugLevel_ > 0 ) {
    edm::LogVerbatim("") << "<ConeAreaFunction::SetParameters>:" << std::endl
             << " theta0 = " << param[0] << std::endl
             << " phi0 = " << param[1] << std::endl;
  }

  theta0_ = param[0];
  phi0_ = param[1];
}

void ConeAreaFunction::SetAcceptanceLimit(double etaMax)
{
//--- check that pseudo-rapidity given as function argument is positive
//    (assume equal acceptance for positive and negative pseudo-rapidities)

  if ( etaMax > 0 ) {
    etaMax_ = etaMax;
  } else {
    edm::LogError("") << "etaMax cannot be negative !" << std::endl;
  }
}

double ConeAreaFunction::DoEvalPar(double x, const double* param) const
{
//--- calculate area covered by cone of opening angle alpha
//    (measured from cone axis);
//    evaluate integral over angle theta
//    (polar angle of point within cone)
// FIXME: the const above is actually not true as it is implemented now.

  theta0_ = param[0];
  phi0_ = param[1];

  return DoEval(x);
}


double ConeAreaFunction::DoEval(double x) const
{
//--- calculate area covered by cone of opening angle alpha
//    (measured from cone axis);
//    evaluate integral over angle theta
//    (polar angle of point within cone)

  fTheta_->SetParameterTheta0(theta0_);
  fTheta_->SetParameterPhi0(phi0_);
  fTheta_->SetParameterAlpha(x);

  integrator_->SetFunction(*fTheta_); // set updated parameter values in Integrator

  double thetaMin = (etaMax_ > 0) ? 2*TMath::ATan(TMath::Exp(-etaMax_)) : 0.;
  double thetaMax = TMath::Pi() - thetaMin;

  double integralOverTheta = integrator_->Integral(thetaMin, thetaMax);

  return integralOverTheta;
}  

double ConeAreaFunction::DoDerivative(double x) const
{
//--- virtual function inherited from ROOT::Math::ParamFunction base class;
//    not implemented, because not neccessary, but needs to be defined to make code compile...
  edm::LogWarning("") << "Function not implemented yet !" << std::endl;

  return 0.;
}

double ConeAreaFunction::DoParameterDerivative(double, const double*, unsigned int) const
{
//--- virtual function inherited from ROOT::Math::ParamFunction base class;
//    not implemented, because not neccessary, but needs to be defined to make code compile...
  edm::LogWarning("") << "Function not implemented yet !" << std::endl;

  return 0.;
}



void ConeAreaFunction::DoParameterGradient(double x, double* paramGradient) const
{
//--- virtual function inherited from ROOT::Math::ParamFunction base class;
//    not implemented, because not neccessary, but needs to be defined to make code compile...
  edm::LogWarning("") << "Function not implemented yet !" << std::endl;
}