HyperHistogram.h

Go to the documentation of this file.

#ifndef HYPERHISTOGRAM_HH
#define HYPERHISTOGRAM_HH

// HyperPlot includes
#include "Mint/MessageService.h"
#include "Mint/HistogramBase.h"
#include "Mint/HyperFunction.h"
#include "Mint/HyperName.h"
#include "Mint/BinningBase.h"
#include "Mint/HyperBinning.h"
#include "Mint/HyperBinningDiskRes.h"
#include "Mint/HyperBinningAlgorithms.h"

// Root includes
#include "TRandom.h"

// std includes
#include <iostream>
#include <fstream>
#include <iomanip>

class HyperHistogram : public HistogramBase, public HyperFunction {

  protected:

  BinningBase* _binning; 
  HyperHistogram();
  
  //BinningBase& getBinning() { return (*_binning); }  /**< get the HyperVolumeBinning */


  public:
  
  HyperHistogram(
    const HyperCuboid&   binningRange, 
    const HyperPointSet& points, 

    HyperBinningAlgorithms::Alg alg = HyperBinningAlgorithms::MINT, 

    AlgOption opt0 = AlgOption::Empty(),
    AlgOption opt1 = AlgOption::Empty(),  
    AlgOption opt2 = AlgOption::Empty(),
    AlgOption opt3 = AlgOption::Empty(),
    AlgOption opt4 = AlgOption::Empty(),
    AlgOption opt5 = AlgOption::Empty(),
    AlgOption opt6 = AlgOption::Empty(),
    AlgOption opt7 = AlgOption::Empty(),
    AlgOption opt8 = AlgOption::Empty(),
    AlgOption opt9 = AlgOption::Empty()
  );
 
  HyperHistogram(const BinningBase& binning);
  HyperHistogram(TString filename, TString option = "MEMRES READ");
  HyperHistogram(std::vector<TString> filename);
  HyperHistogram(TString targetFilename, std::vector<TString> filename);

  HyperHistogram(const HyperHistogram& other);

  HyperHistogram& operator=(const HyperHistogram& other);

  int getDimension() const;
  
  void setNames( HyperName names );
  HyperName getNames() const;

  int  fill(const HyperPoint& coords, double weight);
  int  fill(const HyperPoint& coords);
  void fill(const HyperPointSet& points);

  virtual void merge( const HistogramBase& other );

  void merge( TString filenameother );

  
  int estimateCapacity(std::vector<TString> filename, TString binningType);


  //Project the HyperHistograms down into one dimension

  void project(TH1D* histogram, const HyperCuboid& cuboid, double content, int dimension) const;
  void project(TH1D* histogram, const HyperVolume& hyperVolume, double content, int dimension) const;
  TH1D project(int dim = 0, int bins = 100, TString name = "projection") const;
  
  void drawProjection    (TString path, int dim = 0, int bins = 100) const;
  void drawAllProjections(TString path, int bins) const;

  void compareProjection    (TString path, int dim, const HyperHistogram& other, int bins = 100) const;
  void compareAllProjections(TString path, const HyperHistogram& other, int bins = 100) const;

  

  HyperHistogram slice(std::vector<int> sliceDims, const HyperPoint& slicePoint) const;
  std::vector<HyperHistogram> slice(std::vector<int> sliceDims, const HyperPointSet& slicePoints) const;

  void draw2DSlice   (TString path, int sliceDimX, int sliceDimY, const HyperPoint& slicePoint, TString options = "") const;
  void draw2DSliceSet(TString path, int sliceDimX, int sliceDimY, int sliceSetDim, int nSlices, const HyperPoint& slicePoint, TString options = "") const;
  void draw2DSliceSet(TString path, int sliceDimX, int sliceDimY, int nSlices, const HyperPoint& slicePoint, TString options = "") const;
  void draw2DSliceSet(TString path, int nSlices, const HyperPoint& slicePoint, TString options = "") const;
  void drawRandom2DSlice(TString path, TRandom* random = gRandom, TString options = "") const;


  HyperCuboid getLimits() const;


  const BinningBase& getBinning() const { return (*_binning); }  
  virtual double getVal(const HyperPoint& point) const;
  std::vector<double> getVal(const HyperPointSet& points) const; 


  virtual double getBinVolume(int bin) const;

  void save(TString filename);

  TString getBinningType(TString filename);

  void load     (TString filename, TString option = "MEMRES READ");
  void loadEmpty(TString filename, TString option = "MEMRES READ", TString binningType = "HyperBinning");


  void setContentsFromFunc(const HyperFunction& func);
  
  void printFull() const;
  
  void saveToTxtFile(TString filename, bool incError = true) const;
  void saveToTxtFileNoLinks(TString filename, bool incError = true) const;


  void draw(TString path, TString options = "");
  void drawDensity(TString path, TString options = "");
  
  void mergeBinsWithSameContent();
  

  virtual ~HyperHistogram();

};


  //mutable double _nIntegrationsWtrick;
  //mutable double _nIntegrationsWOtrick;
  
  //void printOptimisationStatistics();
  //interpolation stuff
  //HyperPointSet makePointsAtGaussianExtremes(const HyperPoint& mean, const HyperPoint& sigmas, double sigma) const;
  //double intgrateGaussianOverHyperCuboid(const HyperPoint& mean , const HyperPoint& sigmas, const HyperCuboid& cuboid) const;
  //double intgrateGaussianOverHyperVolume(const HyperPoint& point, const HyperPoint& sigmas, const HyperVolume& volume) const;
  //double intgrateGaussianOverBin   (const HyperPoint& point, const HyperPoint& sigmas, int bin) const;
  //double gaussianKernal                 (const HyperPoint& point, const HyperPoint& sigmas) const;
  //HyperPoint findAdaptiveSigma(const HyperPoint& point, const HyperPoint& sigmas) const;
  //std::vector<int> findNHighestContributingKernalBins(const HyperPoint& point, const HyperPoint& sigmas, int n) const;
  //double adaptiveGaussianKernal(const HyperPoint& point, double smoothing = 1.0) const;
  //void reweightDatasetWithAdaptiveGaussianKernal(HyperPointSet& points, double smoothing = 1.0) const;



#endif