#include <CrossSectionHandler.h>

Public Member Functions
void	addParameters (std::vector< double > &initpar)
	Inputs the vars in a vector. More...

	CrossSectionHandler (const std::vector< double > &crossSection, const std::vector< int > &resfind)

unsigned int	parNum ()

std::vector< double >	relativeCrossSections (const double *variables, const std::vector< int > &resfind)
	Perform a variable transformation from N-1 to relative cross sections. More...

bool	releaseParameters (TMinuit &rmin, const std::vector< int > &resfind, const std::vector< int > &parfix, const int *ind, const int iorder, const unsigned int shift)
	Use the information in resfind, parorder and parfix to release the N-1 variables. More...

void	setParameters (double Start, double Step, double Mini, double Maxi, int ind, TString parname, const std::vector< double > &parCrossSection, const std::vector< int > &parCrossSectionOrder, const std::vector< int > &resfind)
	Initializes the arrays needed by Minuit. More...

Protected Member Functions
void	computeRelativeCrossSections (const std::vector< double > &crossSection, const std::vector< int > &resfind)

void	imposeConstraint ()
	Change of variables so that we move from N to N-1 variables using the constraint that Sum(x_i) = 1. More...

Protected Attributes
unsigned int	numberOfResonances_

unsigned int	parNum_

std::vector< double >	relativeCrossSectionVec_

std::vector< double >	vars_

Friends
class	TestCrossSectionHandler

Detailed Description

Definition at line 27 of file CrossSectionHandler.h.

Constructor & Destructor Documentation

◆ CrossSectionHandler()

CrossSectionHandler::CrossSectionHandler	(	const std::vector< double > &	crossSection,
		const std::vector< int > &	resfind
	)

inline

Definition at line 32 of file CrossSectionHandler.h.

       : parNum_(0), numberOfResonances_(resfind.size()) {
     // The number of parameters is the number of fitted resonances minus 1
     std::vector<int>::const_iterator it = resfind.begin();
     for (; it != resfind.end(); ++it) {
       if (*it != 0)
         ++parNum_;
     }
     if (parNum_ > 0)
       parNum_ = parNum_ - 1;
  
     vars_.resize(parNum_);
  
     computeRelativeCrossSections(crossSection, resfind);
     imposeConstraint();
   }

References computeRelativeCrossSections(), Cascade2_example_test_cff::crossSection, imposeConstraint(), parNum_, MuScleFitGenFilter_cfi::resfind, and vars_.

Member Function Documentation

◆ addParameters()

void CrossSectionHandler::addParameters ( std::vector< double > & initpar )

inline

Inputs the vars in a vector.

Definition at line 50 of file CrossSectionHandler.h.

                                                  {
     std::vector<double>::const_iterator it = vars_.begin();
     for (; it != vars_.end(); ++it) {
       initpar.push_back(*it);
     }
   }

References vars_.

Referenced by MuScleFit::duringFastLoop().

◆ computeRelativeCrossSections()

void CrossSectionHandler::computeRelativeCrossSections	(	const std::vector< double > &	crossSection,
		const std::vector< int > &	resfind
	)

inlineprotected

Initializes the relative cross sections for the range of resonances in [minRes, maxRes]. (note that both minRes and maxRes are included).
Also sets the lock on resonances. If only one of the resonances in the range is fitted its relative cross section will be 1 and it will not be fitted. If there are more than one only those that are fitted will have the relative cross section parameters unlocked during the fit.

Definition at line 167 of file CrossSectionHandler.h.

                                                                                                           {
     relativeCrossSectionVec_.clear();
     double normalization = 0.;
     for (unsigned int ires = 0; ires < resfind.size(); ++ires) {
       if (resfind[ires]) {
         normalization += crossSection[ires];
       }
     }
     if (normalization != 0.) {
       for (unsigned int ires = 0; ires < resfind.size(); ++ires) {
         if (resfind[ires]) {
           relativeCrossSectionVec_.push_back(crossSection[ires] / normalization);
         }
       }
     }
   }

References Cascade2_example_test_cff::crossSection, ires, PostProcessor_cff::normalization, relativeCrossSectionVec_, and MuScleFitGenFilter_cfi::resfind.

Referenced by CrossSectionHandler(), and setParameters().

◆ imposeConstraint()

void CrossSectionHandler::imposeConstraint ( )

inlineprotected

Change of variables so that we move from N to N-1 variables using the constraint that Sum(x_i) = 1.

Definition at line 185 of file CrossSectionHandler.h.

                           {
     if (parNum_ > 0) {
       for (unsigned int iVar = 0; iVar < parNum_; ++iVar) {
         vars_[iVar] = relativeCrossSectionVec_[iVar + 1] / relativeCrossSectionVec_[iVar];
       }
     }
   }

References parNum_, relativeCrossSectionVec_, and vars_.

Referenced by CrossSectionHandler(), and setParameters().

◆ parNum()

unsigned int CrossSectionHandler::parNum ( )

inline

Definition at line 121 of file CrossSectionHandler.h.

121 { return parNum_; }

References parNum_.

Referenced by MuScleFitUtils::massProb(), and MuScleFitUtils::minimizeLikelihood().

◆ relativeCrossSections()

std::vector<double> CrossSectionHandler::relativeCrossSections	(	const double *	variables,
		const std::vector< int > &	resfind
	)

inline

Perform a variable transformation from N-1 to relative cross sections.

Definition at line 124 of file CrossSectionHandler.h.

                                                                                                   {
     // parNum_ is 0 in two cases:
     // 1) if only one resonance is being fitted, in which case the relative cross section is
     // fixed to one and there is no need to recompute it
     // 2) if no resonance is being fitted, in which case all the relative cross sections will
     // be set to 0.
     // In both cases there is no need to make the transformation of variables.
     if (parNum_ != 0) {
       double* partialProduct = new double[numberOfResonances_];
       double norm = 0.;
       // Loop on all relative cross sections (that are parNum_+1)
       for (unsigned int i = 0; i < parNum_ + 1; ++i) {
         partialProduct[i] = std::accumulate(variables, variables + i, 1., std::multiplies<double>());
         norm += partialProduct[i];
       }
       for (unsigned int i = 0; i < parNum_ + 1; ++i) {
         relativeCrossSectionVec_[i] = partialProduct[i] / norm;
       }
       delete[] partialProduct;
     }
  
     std::vector<double> allRelativeCrossSections;
     std::vector<int>::const_iterator it = resfind.begin();
     int smallerVectorIndex = 0;
     for (; it != resfind.end(); ++it) {
       if (*it == 0) {
         allRelativeCrossSections.push_back(0.);
       } else {
         allRelativeCrossSections.push_back(relativeCrossSectionVec_[smallerVectorIndex]);
         ++smallerVectorIndex;
       }
     }
  
     return allRelativeCrossSections;
   }

References mps_fire::i, numberOfResonances_, parNum_, relativeCrossSectionVec_, MuScleFitGenFilter_cfi::resfind, and L1TEGammaDiff_cfi::variables.

Referenced by MuScleFitUtils::massProb(), and MuScleFitUtils::minimizeLikelihood().

◆ releaseParameters()

bool CrossSectionHandler::releaseParameters	(	TMinuit &	rmin,
		const std::vector< int > &	resfind,
		const std::vector< int > &	parfix,
		const int *	ind,
		const int	iorder,
		const unsigned int	shift
	)

inline

Use the information in resfind, parorder and parfix to release the N-1 variables.

Definition at line 97 of file CrossSectionHandler.h.

                                                    {
     // Find the number of free cross section parameters in this iteration
     unsigned int freeParNum = 0;
     for (unsigned int ipar = 0; ipar < numberOfResonances_; ++ipar) {
       if ((parfix[shift + ipar] == 0) && (ind[shift + ipar] <= iorder) && (resfind[ipar] == 1)) {
         ++freeParNum;
       }
     }
     if (freeParNum > 0) {
       freeParNum = freeParNum - 1;
       // Free only the first (freeParNum-1) of the N-1 variables
       for (unsigned int i = 0; i < freeParNum; ++i) {
         rmin.Release(shift + i);
       }
       return true;
     }
     return false;
   }

References mps_fire::i, iorder, numberOfResonances_, MuScleFitGenFilter_cfi::resfind, and edm::shift.

Referenced by MuScleFitUtils::minimizeLikelihood().

◆ setParameters()

void CrossSectionHandler::setParameters	(	double *	Start,
		double *	Step,
		double *	Mini,
		double *	Maxi,
		int *	ind,
		TString *	parname,
		const std::vector< double > &	parCrossSection,
		const std::vector< int > &	parCrossSectionOrder,
		const std::vector< int > &	resfind
	)

inline

Initializes the arrays needed by Minuit.

Definition at line 58 of file CrossSectionHandler.h.

                                                     {
     computeRelativeCrossSections(parCrossSection, resfind);
     imposeConstraint();
  
     double thisStep[] = {0.001, 0.001, 0.001, 0.001, 0.001};
     TString thisParName[] = {"cross section var 1",
                              "cross section var 2",
                              "cross section var 3",
                              "cross section var 4",
                              "cross section var 5"};
     double thisMini[] = {0., 0., 0., 0., 0.};
     double thisMaxi[] = {1000., 1000., 1000., 1000., 1000.};
  
     // This is used to unlock the parameters in a given order. It is not
     // a TMinuit parameter, but a MuScleFit parameter.
     for (unsigned int iPar = 0; iPar < numberOfResonances_; ++iPar) {
       ind[iPar] = parCrossSectionOrder[iPar];
     }
  
     if (parNum_ > 0) {
       for (unsigned int iPar = 0; iPar < parNum_; ++iPar) {
         Start[iPar] = vars_[iPar];
         Step[iPar] = thisStep[iPar];
         Mini[iPar] = thisMini[iPar];
         Maxi[iPar] = thisMaxi[iPar];
         parname[iPar] = thisParName[iPar];
       }
     }
   }

References computeRelativeCrossSections(), imposeConstraint(), numberOfResonances_, parNum_, MuScleFitGenFilter_cfi::resfind, and vars_.

Referenced by MuScleFitUtils::minimizeLikelihood().

Friends And Related Function Documentation

◆ TestCrossSectionHandler

friend class TestCrossSectionHandler

friend

Definition at line 29 of file CrossSectionHandler.h.

Member Data Documentation

◆ numberOfResonances_

unsigned int CrossSectionHandler::numberOfResonances_

protected

Definition at line 197 of file CrossSectionHandler.h.

Referenced by relativeCrossSections(), releaseParameters(), and setParameters().

◆ parNum_

unsigned int CrossSectionHandler::parNum_

protected

Definition at line 196 of file CrossSectionHandler.h.

Referenced by CrossSectionHandler(), imposeConstraint(), parNum(), relativeCrossSections(), and setParameters().

◆ relativeCrossSectionVec_

std::vector<double> CrossSectionHandler::relativeCrossSectionVec_

protected

Definition at line 194 of file CrossSectionHandler.h.

Referenced by computeRelativeCrossSections(), imposeConstraint(), and relativeCrossSections().

◆ vars_

std::vector<double> CrossSectionHandler::vars_

protected

Definition at line 195 of file CrossSectionHandler.h.

Referenced by addParameters(), CrossSectionHandler(), imposeConstraint(), and setParameters().

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ CrossSectionHandler()

Member Function Documentation

◆ addParameters()

◆ computeRelativeCrossSections()

◆ imposeConstraint()

◆ parNum()

◆ relativeCrossSections()

◆ releaseParameters()

◆ setParameters()

Friends And Related Function Documentation

◆ TestCrossSectionHandler

Member Data Documentation

◆ numberOfResonances_

◆ parNum_

◆ relativeCrossSectionVec_

◆ vars_