#include <Neg2LL.h>

Inheritance diagram for MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >:

Public Member Functions
virtual void	beginFit ()

virtual void	parametersChanged ()

virtual void	endFit ()

bool	init ()

virtual double	getPdf (unsigned int evtNumber)

virtual double	logPdf (unsigned int evtNumber)

virtual double	eventWeight (unsigned int evtNumber)

void	doGradient (unsigned int i, double pdfVal, double weight)

virtual double	getVal ()

virtual void	Gradient (std::vector< double > &grad)

virtual bool	useAnalyticGradient ()

virtual void	setUseAnalyticGradient (bool useAnalyticGradient)

virtual double	getNewVal ()

virtual	~Neg2LLClass ()

Public Member Functions inherited from MINT::Minimisable
	Minimisable (MinuitParameterSet *mps=0)

	Minimisable (const Minimisable &other)

virtual	~Minimisable ()

void	setPset (MinuitParameterSet *mps)

MinuitParameterSet *	getParSet ()

Public Member Functions inherited from MINT::IMinimisable
virtual	~IMinimisable ()

Protected Member Functions
	Neg2LLClass (PDF_TYPE &pdf, EVENTLIST_TYPE &erptr, MinuitParameterSet *mps=0)

	Neg2LLClass (const Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE > &other)

Protected Attributes
PDF_TYPE &	_pdf

EVENTLIST_TYPE &	_eventList

bool	_useAnalyticGradient

std::vector< double >	_grad

Private Attributes
int	_NCalls

Friends
class	Neg2LL

Detailed Description

template<typename PDF_TYPE, typename EVENTLIST_TYPE>
class MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >

Definition at line 54 of file Neg2LL.h.

Constructor & Destructor Documentation

◆ Neg2LLClass() [1/2]

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::Neg2LLClass	(	PDF_TYPE &	pdf,
		EVENTLIST_TYPE &	erptr,
		MinuitParameterSet *	mps = `0`
	)

inlineprotected

Definition at line 71 of file Neg2LL.h.

     : Minimisable(mps)
       , _NCalls(0)
       , _pdf(pdf)
       , _eventList(erptr)
       , _useAnalyticGradient(pdf.useAnalyticGradient())
       , _grad()
     { 
       init();
     }

◆ Neg2LLClass() [2/2]

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::Neg2LLClass ( const Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE > & other )

inlineprotected

Definition at line 83 of file Neg2LL.h.

     : Minimisable(other)
       , _NCalls(other._NCalls)
       , _pdf(other._pdf)
       , _eventList(other.erptr)
       , _useAnalyticGradient(other._pdf.useAnalyticGradient())
       , _grad()
       {
           init();
       }

◆ ~Neg2LLClass()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::~Neg2LLClass ( )

inlinevirtual

Definition at line 298 of file Neg2LL.h.

298 {}//if(0 != _grad) delete[] _grad;}

Member Function Documentation

◆ beginFit()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual void MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::beginFit ( )

inlinevirtual

Reimplemented from MINT::Minimisable.

Definition at line 108 of file Neg2LL.h.

                            {
       _pdf.beginFit();
     };

◆ doGradient()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

void MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::doGradient	(	unsigned int	i,
		double	pdfVal,
		double	weight
	)

inline

Definition at line 181 of file Neg2LL.h.

                                                                  {
       if(! _useAnalyticGradient) return;
 
       std::vector<double> gradPDF(this->getParSet()->size());
       _pdf.Gradient(_eventList[i], gradPDF,this->getParSet());
       for(unsigned int j=0; j < this->getParSet()->size(); j++){
     _grad.at(j)+= weight*gradPDF.at(j)/pdfVal;
       }
       return;
     }

◆ endFit()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual void MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::endFit ( )

inlinevirtual

Reimplemented from MINT::Minimisable.

Definition at line 115 of file Neg2LL.h.

                          {
       _pdf.endFit();
     };

◆ eventWeight()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual double MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::eventWeight ( unsigned int evtNumber )

inlinevirtual

Definition at line 173 of file Neg2LL.h.

                                                       {
       return MINT::getWeight(_eventList[evtNumber]);
       // trick: this is a template that will return one
       // for all event types, but evt.getWeight in case 
       // the event inherits from IWeightedEvent.
       // This template is included in IWeightedEvent.h
     }

◆ getNewVal()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual double MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::getNewVal ( )

inlinevirtual

Reimplemented from MINT::Minimisable.

Definition at line 292 of file Neg2LL.h.

                               {
       // forces re-calculation after parameter change
       parametersChanged();
       return getVal();
     }

◆ getPdf()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual double MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::getPdf ( unsigned int evtNumber )

inlinevirtual

Definition at line 139 of file Neg2LL.h.

                                                  {
       bool dbThis=false;
       //if(dbThis) {
       //std::cout << "about to call _pdf.getVal() " 
       //<< "for event:\n " << _eventList[evtNumber]
       //<< std::endl;
       //}
       /*
       if(_eventList.size() <= evtNumber){
     std::cout << "getPdf called for non-existing event number "
           << evtNumber
           << "while _eventList.size() = " << _eventList.size()
           << "."
           << std::endl;
     throw "rubbish";
       }
       */
       double valPdf = _pdf.getVal(_eventList[evtNumber]);
       if(dbThis) std::cout << " that worked! the value is " 
                << valPdf << std::endl;
       if(valPdf <= 0){
           if(dbThis) std::cout << "ERROR in Neg2LLClass::logPdf()"
                  << " the pdf is " << valPdf
                  << " which is <= 0." 
                  << std::endl;
           return -9999.e20 * (1.0 + fabs(valPdf));
       }
       return valPdf;
     }

◆ getVal()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual double MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::getVal ( )

inlinevirtual

Implements MINT::Minimisable.

Definition at line 192 of file Neg2LL.h.

                            {
       _NCalls ++;
       bool verbose=false;
       bool dbThis=false;
       int printFreq = 100;
       printFreq =    100;
       if(_NCalls >   500) printFreq =   1000;
       if(_NCalls > 10000) printFreq =   5000;
       
       bool printout = (0 == _NCalls%printFreq) || _NCalls <= 1;
       printout |= dbThis;
       verbose  |= dbThis;
       
       double sum=0;
       
       if(verbose && printout){
           std::cout << "Neg2LLClass::getVal after " << _NCalls << " calls."
           << " pdf ptr is non zero - that's a start." 
           << std::endl;
       }
       double sumweights=0.0;
       double sumsquareweights=0.0;
         
 
 
       for(unsigned int i=0; i < _grad.size(); i++) _grad[i]= 0.;
       
       // this little thing takes care of things that
       // get initialised at the first call
       // (which we should eliminate, but for now
       // this it a workable work-around)
       // (needed for multithreading, only)
       //if(_eventList.empty()) return 0;
       //eventWeight(0);
       //getPdf(0);
 
       //#pragma omp parallel for reduction(+:sum, sumweights, sumsquareweights);
       for(unsigned int i=0; i < _eventList.size(); ++i){
 
           //EVENT_TYPE & evt( (*_eventList)[i] );
           // sum += logPdf((*_eventList)[i]);
           double weight     = _eventList[i].getWeight();//eventWeight(i);
           double pdfVal     = getPdf(i);
           double logPdfVal  = log(pdfVal);
           if(TMath::IsNaN(weight*logPdfVal))continue;
           sum              += weight*logPdfVal;
           sumweights       += weight;
           sumsquareweights += weight*weight;
           
           /*
           //std::cout << sum << std::endl;
           if(TMath::IsNaN(sum)){ std::cout << "ERROR for " << i << std::endl; 
               std::cout << weight << std::endl;
               std::cout << pdfVal << std::endl;
               std::cout << weight*logPdfVal << std::endl  << std::endl;
 
               std::cout << _eventList[i].getValueFromVector(0) << std::endl;
               std::cout << _eventList[i].getValueFromVector(1) << std::endl;
               std::cout << _eventList[i].getValueFromVector(2) << std::endl;
               std::cout << _eventList[i].getValueFromVector(3) << std::endl;
               std::cout << _eventList[i].getValueFromVector(4) << std::endl;
               std::cout << _eventList[i].getValueFromVector(5) << std::endl;
               std::cout << _eventList[i].getValueFromVector(6) << std::endl;
           throw ""; }
            */
       
       if(_useAnalyticGradient) doGradient(i, pdfVal, weight);
       /*
         omp didn't cope with the below:
       if(_useAnalyticGradient){
               _pdf.Gradient(_eventList[i],gradPDF,this->getParSet());
               for(unsigned int j=0; j < this->getParSet()->size(); j++){
                   _grad[j]+= weight*gradPDF[j]/pdfVal;
               }
           }
       */
       
       }
         
       for(unsigned int i=0; i < _grad.size(); i++) _grad[i]=-2. * _grad[i] * fabs(sumweights/sumsquareweights);
       
       
       if(printout){
     std::cout << "Neg2LLClass::getVal after " << _NCalls << " calls."
           << "for " << _eventList.size()
           << " events, I'm about to return " 
           << -2.0*sum*fabs(sumweights/sumsquareweights) << std::endl;
     std::cout   << "Sum of weights = " << sumweights << std::endl;
       }
       return -2.* sum*fabs(sumweights/sumsquareweights);
     }

◆ Gradient()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual void MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::Gradient ( std::vector< double > & grad )

inlinevirtual

Reimplemented from MINT::IMinimisable.

Definition at line 284 of file Neg2LL.h.

                                                   {
       grad=_grad;
       //for(unsigned int i=0; i < _grad.size(); i++) grad[i]=_grad[i];
     }    

◆ init()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

bool MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::init ( )

inline

Definition at line 119 of file Neg2LL.h.

                {
       // just a place holder
       bool dbThis=true;
       if(dbThis){
           std::cout << "Neg2LLClass: I got initialised with an event list with "
           << _eventList.size() << " events." << std::endl;
           std::cout << "Neg2LLClass: with pointer: " << &_eventList << std::endl;
           //if(_eventList.size() > 0){
           // std::cout << "The first one is:\n"
           //        << _eventList[0]
           //        << std::endl;
           //}
           
       }
       //_grad= new Double_t[this->getParSet()->size()];  
       _grad.resize(this->getParSet()->size());  
       for(unsigned int i=0; i < _grad.size(); i++) _grad[i]= 0.;
       return true;
     }

◆ logPdf()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual double MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::logPdf ( unsigned int evtNumber )

inlinevirtual

Definition at line 169 of file Neg2LL.h.

                                                  {
       return log(getPdf(evtNumber));
     }

◆ parametersChanged()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual void MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::parametersChanged ( )

inlinevirtual

Reimplemented from MINT::Minimisable.

Definition at line 111 of file Neg2LL.h.

                                     {
       _pdf.parametersChanged();
     };

◆ setUseAnalyticGradient()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual void MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::setUseAnalyticGradient ( bool useAnalyticGradient )

inlinevirtual

Reimplemented from MINT::IMinimisable.

Definition at line 290 of file Neg2LL.h.

290 { _useAnalyticGradient = useAnalyticGradient;}

MINT::Neg2LLClass::_useAnalyticGradient

bool _useAnalyticGradient

Definition: Neg2LL.h:63

MINT::Neg2LLClass::useAnalyticGradient

virtual bool useAnalyticGradient()

Definition: Neg2LL.h:289

◆ useAnalyticGradient()

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

virtual bool MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::useAnalyticGradient ( )

inlinevirtual

Reimplemented from MINT::IMinimisable.

Definition at line 289 of file Neg2LL.h.

289 {return _useAnalyticGradient;}

MINT::Neg2LLClass::_useAnalyticGradient

bool _useAnalyticGradient

Definition: Neg2LL.h:63

Friends And Related Function Documentation

◆ Neg2LL

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

friend class Neg2LL

friend

Definition at line 55 of file Neg2LL.h.

Member Data Documentation

◆ _eventList

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

EVENTLIST_TYPE& MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::_eventList

protected

Definition at line 62 of file Neg2LL.h.

◆ _grad

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

std::vector<double> MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::_grad

protected

Definition at line 64 of file Neg2LL.h.

◆ _NCalls

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

int MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::_NCalls

private

Definition at line 57 of file Neg2LL.h.

◆ _pdf

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

PDF_TYPE& MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::_pdf

protected

Definition at line 61 of file Neg2LL.h.

◆ _useAnalyticGradient

template<typename PDF_TYPE, typename EVENTLIST_TYPE>

bool MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >::_useAnalyticGradient

protected

Definition at line 63 of file Neg2LL.h.

The documentation for this class was generated from the following file:

Mint/Neg2LL.h

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Friends

Detailed Description

template<typename PDF_TYPE, typename EVENTLIST_TYPE> class MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >

Constructor & Destructor Documentation

◆ Neg2LLClass() [1/2]

◆ Neg2LLClass() [2/2]

◆ ~Neg2LLClass()

Member Function Documentation

◆ beginFit()

◆ doGradient()

◆ endFit()

◆ eventWeight()

◆ getNewVal()

◆ getPdf()

◆ getVal()

◆ Gradient()

◆ init()

◆ logPdf()

◆ parametersChanged()

◆ setUseAnalyticGradient()

◆ useAnalyticGradient()

Friends And Related Function Documentation

◆ Neg2LL

Member Data Documentation

◆ _eventList

◆ _grad

◆ _NCalls

◆ _pdf

◆ _useAnalyticGradient

template<typename PDF_TYPE, typename EVENTLIST_TYPE>
class MINT::Neg2LLClass< PDF_TYPE, EVENTLIST_TYPE >