JMultiFunction2D.cc File Reference

Example program to create 2D function interpolator from multi-dimensional interpolator. More...

#include <string>
#include <iostream>
#include <iomanip>
#include <cmath>
#include "TRandom3.h"
#include "TMath.h"
#include "JTools/JMapList.hh"
#include "JTools/JFunction1D_t.hh"
#include "JTools/JFunctionalMap_t.hh"
#include "JTools/JConstantFunction1D.hh"
#include "JTools/JMultiFunction.hh"
#include "JTools/JQuantile.hh"
#include "JTools/JToolsToolkit.hh"
#include "Jeep/JTimer.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Example program to create 2D function interpolator from multi-dimensional interpolator.

Author

mdejong

Definition in file JMultiFunction2D.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 45 of file JMultiFunction2D.cc.

{
  using namespace std;
  using namespace JPP;

  int         numberOfEvents;
  int         numberOfBins;
  double      precision;
  int         debug;

  try {

    JParser<> zap("Example program to create 2D function interpolator from multi-dimensional interpolator.");

    zap['n'] = make_field(numberOfEvents)   = 1000;
    zap['N'] = make_field(numberOfBins)     = 11;
    zap['e'] = make_field(precision)        = 1.0e-14;
    zap['d'] = make_field(debug)            = 3;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }

  ASSERT(numberOfEvents > 0);

  const double xmin = -1.0;
  const double xmax = +1.0;
  const double dx   = (xmax - xmin) / (numberOfBins - 1);

  typedef JSplineFunction1D<JSplineElement2D<double, double>, JCollection> JFunction1D_t;
  typedef JFunction1D_t::abscissa_type                                     abscissa_type;
  typedef JFunction1D_t::value_type                                        value_type;

  typedef JMAPLIST<JPolint1FunctionalMap>::maplist                         JMaplist1D_t;
  typedef JMultiFunction<JFunction1D_t, JMaplist1D_t>                      JFunction2D_t;

  typedef JConstantFunction1D<abscissa_type, JMap<abscissa_type, JCollection<value_type> > >    JCollection2D_t;

  typedef JMAPLIST<JPolint1FunctionalMap,
                   JPolint1FunctionalMap,
                   JPolint1FunctionalMap,
                   JPolint1FunctionalMap>::maplist                         JMaplist4D_t;

  typedef JMAPLIST<JPolint1FunctionalMap,
                   JPolint1FunctionalMap,
                   JPolint1FunctionalMap>::maplist                         JMaplist3D_t;

  JMultiFunction<JFunction1D_t,   JMaplist4D_t>  g5;
  JMultiFunction<JCollection2D_t, JMaplist3D_t>  h5;

  for (double x0 = xmin; x0 < xmax + 0.5*dx; x0 += dx) {
    for (double x1 = xmin; x1 < xmax + 0.5*dx; x1 += dx) {
      for (double x2 = xmin; x2 < xmax + 0.5*dx; x2 += dx) {
        for (double x3 = xmin; x3 < xmax + 0.5*dx; x3 += dx) {
          for (double x4 = xmin; x4 < xmax + 0.5*dx; x4 += dx) {
            g5[x0][x1][x2][x3][x4] = f5(x0,x1,x2,x3,x4);
            h5[x0][x1][x2][x3][x4] = f5(x0,x1,x2,x3,x4);
          }
        }
      }
    }
  }

  g5.compile();
  h5.compile();


  const double x0 = +0.15;
  const double x1 = -0.25;
  const double x2 =  0.25;
    
  JFunction2D_t g2;

  JTimer timer("3D interpolator");

  timer.start();

  for (int i = 0; i != 100; ++i) {
    copy(h5(x0,x1,x2), g2);      // put interpolated data into 2D functional object
  }

  timer.stop();
  timer.print(cout, 1.0/100, micro_t);

  g2.compile();

  JTimer t2("2D interpolator");
  JTimer t5("5D interpolator");

  JQuantile Q2("2D interpolator");
  JQuantile Q5("5D interpolator");
    
  // mini buffer to reduce overhead in timer

  const int N = 100;

  double x[N];
  double y[N];
  double z[N];
  double v[N];
  double w[N];

  for (int i = 0; i != numberOfEvents; ++i) {

    for (int __i = 0; __i != N; ++__i) {

      const double x3 = gRandom->Uniform(xmin, xmax);
      const double x4 = gRandom->Uniform(xmin, xmax);

      x[__i] = x3;
      y[__i] = x4;
      z[__i] = f5(x0,x1,x2,x3,x4);
    }

    t2.start();

    for (int __i = 0; __i != N; ++__i) {
      v[__i] = g2(x[__i], y[__i]);
    }

    t2.stop();

    t5.start();

    for (int __i = 0; __i != N; ++__i) {
      w[__i] = g5(x0,x1,x2,x[__i],y[__i]);
    }

    t5.stop();

    for (int __i = 0; __i != N; ++__i) {
      Q2.put(v[__i] - z[__i]);
      Q5.put(w[__i] - z[__i]);
    }
  }

  if (debug >= notice_t) {

    Q2.print(cout);
    Q5.print(cout, false);
      
    t2.print(cout, 1.0 / (N * numberOfEvents), nano_t);
    t5.print(cout, 1.0 / (N * numberOfEvents), nano_t);
  }

  ASSERT(fabs(Q2.getMean()  - Q5.getMean())  <= precision);
  ASSERT(fabs(Q2.getSTDev() - Q5.getSTDev()) <= precision);

  return 0;
}