/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/rntuple

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_rntuple
#define inlib_rntuple

// interfaces to read ntuple.

#include "scast"

#include <string>
#include <vector>

namespace inlib {
namespace read {

class icol {
public:
  virtual ~icol(){}
public:
  virtual void* cast(cid) const = 0;
  virtual cid id_cls() const = 0;
public:
  virtual const std::string& name() const = 0;
public:
  virtual void stop() {}
};
  
template <class T>
class icolumn : public virtual icol {
public:
  static cid id_class() {
    static const T s_v = T(); //do that for T = std::string.
    return _cid(s_v);
  }
public: //icol
  virtual void* cast(cid a_class) const {
    if(void* p = cmp_cast<icolumn>(this,a_class)) {return p;}
    else return 0;
  }
  virtual cid id_cls() const {return id_class();}
public:
  virtual ~icolumn(){}
public:
  virtual bool get_entry(T&) const = 0;
};

class intuple {
public:
  virtual ~intuple(){}
public:
  virtual void start() = 0;
  virtual bool next() = 0;
  virtual icol* find_icol(const std::string&) = 0;
  virtual const std::vector<icol*>& columns() const = 0;
public:
  virtual void stop() {}
public:
  template <class T>
  icolumn<T>* find_column(const std::string& a_name){
    read::icol* col = find_icol(a_name);
    if(!col) return 0;
    return inlib::id_cast<read::icol, icolumn<T> >(*col);
  }
};

}}

#include "typedefs"
#include "mnmx"

namespace inlib {
namespace read {

template <class T>
inline bool column_infos(intuple& a_ntu,
                         const icolumn<T>& a_col,
                         T& a_mn,T& a_mx,
                         T& a_S,T& a_S2,
                         inlib::uint64& a_count){
  a_mn = T();
  a_mx = T();
  a_S = T();
  a_S2 = T();
  a_count = 0;

  T v;

  a_ntu.start();
  if(a_ntu.next()){
    if(!a_col.get_entry(v)) {
      a_mn = T();
      a_mx = T();
      a_S = T();
      a_S2 = T();
      a_count = 0;
      return false;
    }
    a_mn = v;
    a_mx = v;
    a_S = v;
    a_S2 = v*v;
    a_count++;
  }

  while(a_ntu.next()){
    if(!a_col.get_entry(v)) {
      a_mn = T();
      a_mx = T();
      a_S = T();
      a_S2 = T();
      a_count = 0;
      return false;
    }
    a_mn = inlib::mn<T>(a_mn,v);
    a_mx = inlib::mx<T>(a_mx,v);
    a_S += v;
    a_S2 += v*v;
    a_count++;
  }

  return true;
}

}}

#include <cmath>
#include "cids"

namespace inlib {
namespace read {

inline bool mean_rms(intuple& a_ntu,
                     const icol& a_col,
                     double& a_mean,double& a_rms){
  a_mean = 0;
  a_rms = 0;
  typedef icolumn<int> icoli_t;
  typedef icolumn<float> icolf_t;
  typedef icolumn<double> icold_t;
  if(const icoli_t* ci = id_cast<icol, icoli_t >(a_col) ){
    int mn,mx,S,S2;
    uint64 count;
    if(!column_infos<int>(a_ntu,*ci,mn,mx,S,S2,count)) return false;
    if(!count) return false;
    a_mean = S/double(count);
    a_rms = ::sqrt(::fabs(S2/double(count)-a_mean*a_mean));
    return true;

  } else if(const icolf_t* cf = id_cast<icol, icolf_t >(a_col) ){
    float mn,mx,S,S2;
    uint64 count;
    if(!column_infos<float>(a_ntu,*cf,mn,mx,S,S2,count)) return false;
    if(!count) return false;
    a_mean = S/double(count);
    a_rms = ::sqrt(::fabs(S2/double(count)-a_mean*a_mean));
    return true;

  } else if(const icold_t* cd = id_cast<icol, icold_t >(a_col) ){
    double mn,mx,S,S2;
    uint64 count;
    if(!column_infos<double>(a_ntu,*cd,mn,mx,S,S2,count)) return false;
    if(!count) return false;
    a_mean = S/double(count);
    a_rms = ::sqrt(::fabs(S2/double(count)-a_mean*a_mean));
    return true;

  } else {
    return false;     
  }
}

}}

#endif