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

main()

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;
}