HyperBinningAlgorithms Class Reference

#include <HyperBinningAlgorithms.h>

Public Types
enum	Alg {   SMART, MINT, MINT_SMART, MINT_RANDOM,   SMART_RANDOM, LIKELIHOOD, SMART_LIKELIHOOD, SMART_MULTI,   FUNC_PHASE }

Public Member Functions
	HyperBinningAlgorithms (Alg algorithm)
void	addAlgOption (AlgOption option)
	Add an AlgOption which is passed to the binning algortihm. More...
HyperBinningMaker *	getHyperBinningMaker (HyperCuboid binningRange, HyperPointSet points)
	~HyperBinningAlgorithms ()

Private Member Functions
AlgOption	getOpt (AlgOption::OptionName name)
bool	optExist (AlgOption::OptionName name)

Private Attributes
std::vector< AlgOption >	_algOptions
Alg	_alg

Detailed Description

HyperPlot, Author: Sam Harnew, sam.h.nosp@m.arne.nosp@m.w@gma.nosp@m.il.c.nosp@m.om , Date: Dec 2015

This class is used to pick one of the binning algorithms (in HyperBinningMakers.h) and then sets any additional options that are passed as AlgOption's

Definition at line 134 of file HyperBinningAlgorithms.h.

Member Enumeration Documentation

Alg

enum HyperBinningAlgorithms::Alg

enum containing a list of the avalible binning algorithms

Enumerator
SMART
MINT
MINT_SMART
MINT_RANDOM
SMART_RANDOM
LIKELIHOOD
SMART_LIKELIHOOD
SMART_MULTI
FUNC_PHASE

Definition at line 139 of file HyperBinningAlgorithms.h.

{ SMART, MINT, MINT_SMART, MINT_RANDOM ,SMART_RANDOM, LIKELIHOOD, SMART_LIKELIHOOD, SMART_MULTI, FUNC_PHASE };

Constructor & Destructor Documentation

HyperBinningAlgorithms()

HyperBinningAlgorithms::HyperBinningAlgorithms

(

Alg

algorithm

)

Constuct a HyperBinningAlgorithms by selecting the algortihm you would like to use

Definition at line 293 of file HyperBinningAlgorithms.cpp.

                                                            :
  _alg(algorithm)
{
    
}

~HyperBinningAlgorithms()

HyperBinningAlgorithms::~HyperBinningAlgorithms

(

)

Destructor

Definition at line 424 of file HyperBinningAlgorithms.cpp.

                                               {

}

Member Function Documentation

addAlgOption()

void HyperBinningAlgorithms::addAlgOption

(

AlgOption

option

)

Add an AlgOption which is passed to the binning algortihm.

Definition at line 300 of file HyperBinningAlgorithms.cpp.

                                                         {
  _algOptions.push_back(option);
}

getHyperBinningMaker()

HyperBinningMaker * HyperBinningAlgorithms::getHyperBinningMaker	(	HyperCuboid	binningRange,
		HyperPointSet	points
	)

Get the HyperBinningMaker (the binning algorithm) with the chosen algorithm type, and with the chosen AlgOption's

Definition at line 306 of file HyperBinningAlgorithms.cpp.

                                                                                                             {
     
  int dim = binningRange.getDimension();

  HyperBinningMaker* binnningMaker = 0;
  
  int startDimension = 0;

  if (optExist(AlgOption::START_DIM    )) 
    startDimension = getOpt(AlgOption::START_DIM  ).getIntOpt();  
  
  int numPhaseBinPairs = 3;
  if (optExist(AlgOption::NUM_BIN_PAIRS    )) 
    numPhaseBinPairs = getOpt(AlgOption::NUM_BIN_PAIRS  ).getIntOpt();



  //Chose the binning algorithm

  if (_alg == SMART ) {
    binnningMaker = new HyperBinningMakerSmart(binningRange, points, startDimension);
  }
  if (_alg == MINT ) {
    binnningMaker = new HyperBinningMakerMint(binningRange, points, startDimension);
  }
  if (_alg == MINT_SMART ) {
    binnningMaker = new HyperBinningMakerMintSmart(binningRange, points, startDimension);
  }
  if (_alg == MINT_RANDOM ) {
    binnningMaker = new HyperBinningMakerMintRandomise(binningRange, points);
  }
  if (_alg == SMART_RANDOM ) {
    binnningMaker = new HyperBinningMakerSmartRandomise(binningRange, points);
  }
  if (_alg == LIKELIHOOD ) {
    binnningMaker = new HyperBinningMakerLikelihood(binningRange, points);
  }
  if (_alg == SMART_LIKELIHOOD ) {
    binnningMaker = new HyperBinningMakerSmartLikelihood(binningRange, points);
  }  
  if (_alg == SMART_MULTI) {
    binnningMaker = new HyperBinningMakerMultiSmart(binningRange, points, startDimension);
  }
  if (_alg == FUNC_PHASE) {
    HyperBinningMakerPhaseBinning* phaseBinningMaker = new HyperBinningMakerPhaseBinning(binningRange, 0);
    phaseBinningMaker->setNumBinPairs(numPhaseBinPairs);

    if (optExist(AlgOption::PHASE_BIN_EDGES    )) 
      phaseBinningMaker->setBinEdges( getOpt(AlgOption::PHASE_BIN_EDGES  ).getDoubleVectorOpt() );

    binnningMaker = dynamic_cast<HyperBinningMaker*>(phaseBinningMaker);
  }
  //Now set the options


  if (optExist(AlgOption::RAND_SEED    )) 
    binnningMaker->setSeed  ( getOpt(AlgOption::RAND_SEED  ).getIntOpt() );

  if (optExist(AlgOption::USE_WEIGHTS  )) 
    binnningMaker->useEventWeights( getOpt(AlgOption::USE_WEIGHTS).getBoolOpt() );

  if (optExist(AlgOption::BINNING_DIMS )) 
    binnningMaker->setBinningDimensions( getOpt(AlgOption::BINNING_DIMS).getIntVectorOpt() );

  if (optExist(AlgOption::FUNC )) 
    binnningMaker->setHyperFunction( getOpt(AlgOption::FUNC).getFuncOpt() );

  if (optExist(AlgOption::MIN_BIN_WIDTH )){
    //can provide either a double or a HyperPoint here.

    HyperPoint widthsA = getOpt(AlgOption::MIN_BIN_WIDTH).getHyperPointOpt();
    double     widthsB = getOpt(AlgOption::MIN_BIN_WIDTH).getDoubleOpt    (); 
    if ( widthsA.getDimension() == 0 ) widthsA = HyperPoint(dim, widthsB);
    binnningMaker->setMinimumEdgeLength(widthsA);
  }

  if (optExist(AlgOption::USE_SHADOW_DATA )) 
    binnningMaker->addShadowHyperPointSet( getOpt(AlgOption::USE_SHADOW_DATA).getHyperPointSetOpt() );

  if (optExist(AlgOption::MIN_BIN_CONTENT )) 
    binnningMaker->setMinimumBinContent( getOpt(AlgOption::MIN_BIN_CONTENT).getDoubleOpt() );

  if (optExist(AlgOption::MIN_SHADOW_BIN_CONTENT )) 
    binnningMaker->setShadowMinimumBinContent( getOpt(AlgOption::MIN_BIN_CONTENT).getDoubleOpt() );

  if (optExist(AlgOption::DRAW_ALGORITHM )) 
    binnningMaker->drawAfterEachIteration( getOpt(AlgOption::DRAW_ALGORITHM).getStringOpt() );

  if (optExist(AlgOption::AXIS_NAMES )) 
    binnningMaker->setNames( getOpt(AlgOption::AXIS_NAMES).getHyperNameOpt() );
  
  if (optExist(AlgOption::SNAP_TO_GRID )){
    binnningMaker->useSnapToGrid( getOpt(AlgOption::SNAP_TO_GRID).getBoolOpt() );
  }

  if (optExist(AlgOption::GRID_MULTIPLIER )){

    HyperPoint valA = getOpt(AlgOption::GRID_MULTIPLIER).getHyperPointOpt();    
    int        valB = getOpt(AlgOption::GRID_MULTIPLIER).getIntOpt       ();

    if (valA.getDimension() != 0){
      binnningMaker->setGridMultiplier(valA);
    }
    else{
      binnningMaker->setGridMultiplier(valB);
    }
  }

  if (optExist(AlgOption::START_BINNING) ){
    binnningMaker->updateFromExistingHyperBinning( *getOpt(AlgOption::START_BINNING).getHyperBinningOpt() );
  }
  
  return binnningMaker;

}

getOpt()

AlgOption HyperBinningAlgorithms::getOpt ( AlgOption::OptionName  name )

private

look through the list of AlgOption's and see if one with a specific OptionName exsits. If so, return it, if not return the OptionName EMTPY

Definition at line 274 of file HyperBinningAlgorithms.cpp.

                                                                {

  for (unsigned i = 0; i < _algOptions.size(); i++) {
    if (_algOptions.at(i).getOptionName() == name) return _algOptions.at(i);
  }

  return AlgOption::Empty(); 
}

optExist()

bool HyperBinningAlgorithms::optExist ( AlgOption::OptionName  name )

private

look through the list of AlgOption's and see if one with a specific OptionName exsits.

Definition at line 285 of file HyperBinningAlgorithms.cpp.

                                                             {

  return getOpt(name).isEmpty() == 0;

}

Member Data Documentation

_alg

Alg HyperBinningAlgorithms::_alg

private

the algorithm (e.g. HyperBinningMakerMint) that will be used in a particular instance of the class

Definition at line 147 of file HyperBinningAlgorithms.h.

_algOptions

std::vector<AlgOption> HyperBinningAlgorithms::_algOptions

private

list of options that will be given to the HyperBinningMaker

Definition at line 144 of file HyperBinningAlgorithms.h.

---

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

• Mint/HyperBinningAlgorithms.h
• src/Mojito/Chi2Test/HyperBinningAlgorithms.cpp