Flatten.cc File Reference

#include "Flatten.h"
#include "SetEvent.h"
#include "TClassTable.h"
#include "TClass.h"
#include "TDictionary.h"
#include "TDictAttributeMap.h"
#include "TProtoClass.h"
#include "TSystem.h"
#include "TParameter.h"
#include "../NumuReco/TrackAlgo.h"

Go to the source code of this file.

Functions
std::vector< std::string >	ProcessClass (TClass *tclass, const std::string &prefix)
std::string	ClasstoNTupleName (const std::string &classname, const std::string &prefix)
	DECLARE_SBN_POSTPROCESSOR (ana::SBNOsc::Flatten)

Function Documentation

std::string ClasstoNTupleName	(	const std::string &	classname,
		const std::string &	prefix
	)

Definition at line 71 of file Flatten.cc.

                                                                                 {
  DictFuncPtr_t classdict = gClassTable->GetDict(classname.c_str());
  std::vector<std::string> var_names = ProcessClass(classdict(), prefix);
  std::string ret;
  for (unsigned i = 0; i < var_names.size(); i++) {
    ret += var_names[i];
    if (i < var_names.size() -1) ret += ":";
  }
  return ret;
}

DECLARE_SBN_POSTPROCESSOR

(

ana::SBNOsc::Flatten

)

std::vector<std::string> ProcessClass	(	TClass *	tclass,
		const std::string &	prefix
	)

Definition at line 14 of file Flatten.cc.

                                                                           {
  std::vector<std::string> ret;
  TList *members = tclass->GetListOfDataMembers();
  TIterator *m_iterator = members->MakeIterator();
  TObject *obj;
  while ((obj = m_iterator->Next()) != NULL) {
    TDataMember *member = (TDataMember *)obj;
    TDataType *basic_type = member->GetDataType();
    if (basic_type != NULL) {
      // only accept floats
      assert(basic_type->GetType() == kFloat_t);
      // check if array
      if (member->GetArrayDim() == 0) {
        // not array -- just add
        ret.push_back(prefix + "." + std::string(obj->GetName()));
      }
      else {
        // sort through array
        unsigned max_ind = 1;
        for (unsigned i = 0; i < member->GetArrayDim(); i++) {
          max_ind = max_ind * member->GetMaxIndex(i);
        }
        for (unsigned i = 0; i < max_ind; i++) {
          std::vector<unsigned> each_ind(member->GetArrayDim(), 0);
          unsigned ind = i;
          for (int j = member->GetArrayDim()-1; j >= 0; j--) {
            unsigned this_i = ind % member->GetMaxIndex(j);
            each_ind[j] = this_i;
            ind = ind / member->GetMaxIndex(j);
          }
          std::string base = prefix + "." + std::string(obj->GetName()); 
          for (unsigned ind: each_ind) base += ("." + std::to_string(ind));
          ret.push_back(base);
        }
      } 

    }
    // no enums in TNtuple
    assert(!member->IsEnum());
    // no pointers in TNtuple
    assert(!member->IsaPointer());
    // no containers in TNtuple
    assert(!member->IsSTLContainer());
    // if not basic -- descend
    if (!member->IsBasic()) {
      DictFuncPtr_t next = gClassTable->GetDict(member->GetTypeName());
      if (next == NULL) {
        std::cout << "Missing dictionary for class type: " << member->GetTypeName() << std::endl;
        assert(next != NULL);
      }
      std::vector<std::string> this_ret = ProcessClass(next(), prefix + "." + std::string(obj->GetName()));
      ret.insert(ret.end(), this_ret.begin(), this_ret.end());
    }
  }
  return ret;
}