Interpolator.h

Go to the documentation of this file.

#ifndef INTERPOLATOR_H
#define INTERPOLATOR_H 

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <deque>
#include <map>
#include <utility>

using std::vector;
using std::deque;
using std::map;
using std::ifstream;
using std::istringstream;
using std::string;
using std::pair;

namespace Atlfast{
  
  // Interpolator is a class for doing linear interpolations
  // for a given quantity between points in any number of dimensions 
  // (ie.. efficiency between various eta,pT points would be 2 dimensions.
  // The input file must have a particular layout for Interpolator to
  // work (3 dimensional example):

  // pt eta phi                 <== Quantity names (optional)
  // 1                          <== 1st point in 1st dim.
  //   3                        <== 1st point in 2nd dim. (whitespace is ignored)
  //     12  23  34  45  56     <== All points in 3rd dim.
  //     0.4 0.5 0.6 0.7 0.8    <== Values of quantity at (1,3,12),(1,3,23),etc..
  //   4                        <== 2nd point in 2nd dim.
  //     12  23  34  45  56     <== All points in 3rd dim.
  //     0.1 0.2 0.4 0.5 0.6    <== Values of quantity at (1,4,12),(1,4,23),etc..
  //                            <== Empty lines are ignored
  // 2                          <== 2nd point in 1st dim.
  //   3                        <== 1st point in 2nd dim.
  //     12  23  34  45  56     <== All points in 3rd dim.
  //     0.1 0.2 0.3 0.2 0.1    <== Values of quantity at (2,3,12),(2,3,23),etc..
  //   4                        <== 2nd point in 2nd dim.
  //     12  23  34  45  56     <== All points in 3rd dim.
  //     0.6 0.9 0.7 0.1 0.1    <== Values of quantity at (2,4,12),(2,4,23),etc..

  // Points should be listed in ascending numerical order. For each dimension, 
  // Interpolator recursively makes a vector of Interpolators
  // corresponding to the next dimension down. Interpolation is performed by 
  // passing in a vector of values (in dimension order, ie.. (1st dim. value, 
  // 2nd dim. value, 3rd dim. value) ) to the 'interpolate' method. interpolate 
  // checks whether the values are in the range of held points and returns the
  // interpolation result if so, or zero if not. Each Interpolator holds a value
  // which is its point value in that Interpolator's dimension

  class Interpolator{
  public:
    Interpolator(string);
    double interpolate(deque<double>,bool performedchecks = false);
    double getValue(){return m_value;}
    void   setDefault(double);
    void   setDefault(int,double);
    void   setDefault(string,double);
    void   setDefault(int,double,double);
    void   setDefault(string,double,double);
    void   setContinuousBoundaries(){m_contBounds = true;}
    double getNearestValue(deque<double>);
    void   dump();
  private:
    Interpolator(double,ifstream&, int&, int&, vector<int>&, int&);
    void   Setup(ifstream&, int&, int&, vector<int>&, int&);
    void   findLimits(deque<pair<double,double> >&);
    void   nDimensionsToJump(ifstream&,int&,int&);
    bool   inLimits(deque<double>,double&);
    void   exitParseWithMessage(string, int, string);
    vector<pair<double,double> >   m_pairs;
    vector<Interpolator>           m_interpolators;
    double                         m_value;
    deque<pair<double,double> >    m_limits;
    deque<pair<double,double> >    m_defaults;
    map<string,int>                m_levelnames;
    bool                           m_contBounds;
  };
  
  // ClosestInterpolators is a binary predicate class to find the two adjacent 
  // Interpolators whose point values fall either side of an input value

  class ClosestInterpolators{
  public:
    ClosestInterpolators(double value);
    bool operator()(Interpolator&, Interpolator&);
  private:
    double m_value;
  };
  
  // ClosestDoublePairs is a binary predicate class to find the two adjacent 
  // pairs whose point values fall either side of an input value

  class ClosestDoublePairs{
  public:
    ClosestDoublePairs(double value);
    bool operator()(pair<double,double>&, pair<double,double>&);
  private:
    double m_value;
  };

}

#endif

---