HyperBinningMaker.h

Go to the documentation of this file.

#ifndef HYPERBINNINGMAKER_HH
#define HYPERBINNINGMAKER_HH

// HyperPlot includes
#include "Mint/MessageService.h"
#include "Mint/HyperCuboid.h"
#include "Mint/HyperPointSet.h"
#include "Mint/HyperBinningMemRes.h"
#include "Mint/RootPlotter1D.h"
#include "Mint/RootPlotter2D.h"
#include "Mint/HyperFunction.h"

// Root includes
#include "TH1D.h"
#include "TH2D.h"
#include "TRandom3.h"
#include "TMath.h"

// std includes
#include <algorithm>
#include <sstream>

class HyperHistogram;


class HyperBinningMaker {

  private:
  
  HyperBinningMaker();

  protected:


  static bool s_printBinning; 
  //each bin has:
  //   o  a hyper cuboid defining it
  //   o  a set of data which is contained within it
  //   o  a status

  std::vector<HyperCuboid>        _hyperCuboids;          
  std::vector< std::vector<int> > _linkedBins;           
  std::vector<HyperPointSet>      _hyperPointSets;        
  std::vector<HyperPointSet>      _shadowHyperPointSets;  
  struct VolumeStatus{
      enum Type { DONE, CONTINUE };
  };

  std::vector<int>                _status;                
  std::vector< std::vector<int> >  _dimSpecificStatus;                
  std::vector<int>                _binningDimensions;     
  bool _shadowAdded;
  bool _useEventWeights;
  double _minimumBinContent;
  double _shadowMinimumBinContent;
  HyperPoint _minimumEdgeLength;
  TRandom* _random;
  bool _drawAlgorithm;
  TString _drawAlgorithmDir;
  int _iterationNum;
  HyperName _names;
  HyperFunction* _func;
  bool _snapToGrid;
  HyperPoint _gridMultiplier;
  public:
    
  HyperBinningMaker(const HyperCuboid& binningRange, const HyperPointSet& data);
  
  HyperBinningMaker(const HyperBinning& binning    , const HyperPointSet& data);


  /* ----------------------------------------------------------------*/

  virtual void makeBinning() = 0;
  /* ----------------------------------------------------------------*/

  //The following functions should be called before any binning 
  //binning algorithms commence.

  static void setOutputLevel(bool val){s_printBinning = val;}
  void setBinningDimensions(std::vector<int> dims){_binningDimensions = dims;}
  void addShadowHyperPointSet(const HyperPointSet& data);

  void setSeed(int seed);

  void useSnapToGrid(bool val);
  void setGridMultiplier(HyperPoint& multipliers);
  void setGridMultiplier(double multiplier);


  void useEventWeights(bool val = true){_useEventWeights = val;}
  void setMinimumBinContent(double val);
  void setShadowMinimumBinContent(double val);
  void setMinimumEdgeLength(double val);     
  void setMinimumEdgeLength(HyperPoint val);  
  
  void setHyperFunction(HyperFunction* fnc);  
  
  void drawAfterEachIteration(TString path);

  void updateFromExistingHyperBinning( const HyperBinning& binning );

  void setNames(HyperName names){_names = names;}
  /*----------------------------------------------------------------*/


  int& getGlobalVolumeStatus(int volumeNumber){return _status.at(volumeNumber);}
  int& getDimensionSpecificVolumeStatus(int volumeNumber, int dimension){return _dimSpecificStatus.at(volumeNumber).at(dimension);}

  const int& getGlobalVolumeStatus(int volumeNumber) const {return _status.at(volumeNumber);}
  const int& getDimensionSpecificVolumeStatus(int volumeNumber, int dimension) const {return _dimSpecificStatus.at(volumeNumber).at(dimension);}

  int getNumContinueBins(int dimension = -1) const;
  int getNumBins        () const;
  int getNumHyperVolumes() const;


  /*----------------------------------------------------------------*/
  
  //These functions are common to all the HyperBinning makers
  //and used to divide bins and update their status, and check that
  //the resulting bins are OK.

  int  split(int volumeNumber, int dimension, double splitPoint);

  HyperCuboid splitBelowPoint(int dim, double splitPoint, const HyperCuboid& original, bool noSnapToGrid = false) const;
  HyperCuboid splitAbovePoint(int dim, double splitPoint, const HyperCuboid& original, bool noSnapToGrid = false) const;

  double getSumOfWeights(const HyperPointSet& hyperPointSet) const;
  double getWeight(const HyperPoint& hyperPoint) const;              //Will return 1 if _useEventWeights is false. If not, get event weight 0.
  bool isValidBinningDimension(int dimension);
  virtual bool passFunctionCriteria(HyperCuboid& cuboid1, HyperCuboid& cuboid2);

  HyperPointSet filterHyperPointSet(const HyperPointSet& hyperPointSet, const HyperCuboid& hyperCuboid, bool print = false) const;

  void addBin(const HyperCuboid& hyperCuboid, const HyperPointSet& hyperPointSet, const HyperPointSet& shadowHyperPointSet, int status);

  void setDimSpecStatusFromMinBinWidths (int volumeNumber);
  void updateGlobalStatusFromDimSpecific(int volumeNumber);
  
  bool snapToGrid(const HyperCuboid& cuboid, int dimension, double& splitCoord) const;
  
  /* ----------------------------------------------------------------*/
  
  virtual void startedAlgorithm();
  virtual void startedIteration();  

  void drawCurrentState(TString path) const;

  virtual void finishedIteration();  
  virtual void finishedAlgorithm();

  
  /* ----------------------------------------------------------------*/
  
  // These functions can be used to get a 
  // HyperBinningHistogram of the current state 

  HyperBinningMemRes getHyperVolumeBinning() const;
  HyperHistogram* getHyperBinningHistogram() const;
  HyperHistogram* getShadowHyperBinningHistogram() const;
  HyperHistogram* getRatioHyperBinningHistogram() const;

  virtual ~HyperBinningMaker();


  /********************* NON ESSENTIAL ************************/


  double countEventsBelowSplitPoint(int binNumber, int dimension, double splitPoint) const;
  double countEventsInHyperCuboid(const HyperPointSet& hyperPointSet, const HyperCuboid& hyperCuboid) const;
  double countShadowEventsBelowSplitPoint(int binNumber, int dimension, double splitPoint) const;
  
  //split the bin in a chosen dimension to give a chosen fraction of events in the resulting bin
  double findSmartSplitPoint(int binNumber, int dimension, double dataFraction) const;

  int smartSplit   (int binNumber, int dimension, double dataFraction);
  int smartSplitAll(int dimension, double dataFraction); 
  int smartSplitAllRandomise(double dataFraction = 0.5);


  int smartMultiSplit(int binNumber, int dimension, int parts);
  int smartMultiSplit(int binNumber, int dimension);
  int smartMultiSplitAll(int dimension);


  double findSmartSplitPointInt(int binNumber, int dimension, double dataFraction) const;

  int smartSplitInt(int binNumber, int dimension, double dataFraction);
  int smartSplitAllInt(int dimension, double dataFraction);

  int splitAll(int dimension, double splitPoint);
  int splitAllRandomise(double splitPoint = 0.5);




  //Likelihood shit

  int likelihoodSplit(int binNumber);
  int likelihoodSplitAll();

  int smartLikelihoodSplit(int binNumber);
  int smartLikelihoodSplitAll();

  void  getSplitToMinNeg2LLH(double& split, double& sig, int binNumber, int dimension, bool useConstraints = true);

  void  getDimWithLargestSplitSignificance(int& dim, double& split, int binNumber, bool useConstraints = true);

  TH1D* scanSig(int binNumber, int dimension, int nbins, bool useConstraints = true);

  double neg2LLH(int binNumber, int dimension, double splitPoint, bool useConstraints = true);
  double nullNeg2LLH(int binNumber);





};



#endif