EventMultiSplitter.cpp

Go to the documentation of this file.

#include "cafe/EventMultiSplitter.hpp"
#include "cafe/Config.hpp"
#include "cafe/Stat.hpp"
#include "cafe/PermuterBase.hpp"

#include <stdexcept>

#include "TClass.h"
#include "TMethodCall.h"
#include "TROOT.h"

ClassImp(cafe::EventMultiSplitter)

using namespace std;

namespace cafe {
  EventMultiSplitter::EventMultiSplitter (const char *name)
  : Controller (name), _perm(0), _local_stat(0)
  {
        Config cfg (name);


        std::string permClassName (cfg.get("PermuterObject", "bogus"));
        std::string permName (cfg.get("PermuterName", "bogus"));

        if (permClassName == "bogus") {
          throw runtime_error ("EventMultiSplitter's parameter permClassName wasn't set!");
        }

        if(TClass *cl = gROOT->GetClass (permClassName.c_str())) {
          if(cl->GetMethodWithPrototype(permClassName.c_str(),"const char *") != 0) {
                TMethodCall call;
                call.InitWithPrototype(cl, permClassName.c_str(), "const char *");
                call.ResetParam();
                call.SetParam((Long_t )permName.c_str());
                Long_t ret (0);
                call.Execute(ret);
                _perm = reinterpret_cast<PermuterBase*> (ret);
          } else {
                throw runtime_error ("Class " + permClassName + " doesn't have a ctor with a string argument!");
          }
        } else {
          throw runtime_error ("ROOT doesn't know about class " + permClassName + "! EventMultiSplitter can't make it!");
        }


        _local_stat = new Stat (name, true);
        _local_stat->begin();
  }

  EventMultiSplitter::~EventMultiSplitter (void)
  {
        delete _perm;
        delete _local_stat;
  }

  bool EventMultiSplitter::processEvent (Event &event)
  {

        _local_stat->chain();


        EventMultiSplitter::callback cb (*this, event);
        _perm->permuteEvent (cb);


        _local_stat->unchain();

        return true;
  }

  void EventMultiSplitter::finish(void)
  {
        _local_stat->finish();
        Controller::finish();
  }

  void EventMultiSplitter::processPermutation (double weight, Event &event)
  {

        event.clear ("StatPointer");
        _local_stat->processEvent (event);
        _local_stat->inheritWeights();


        _local_stat->applyWeight (name(), weight);


        Controller::processEvent (event);


        _local_stat->eventEnd();
  }


  EventMultiSplitter::callback::callback (EventMultiSplitter &splitter, Event &event)
        : _event (event), _splitter (splitter)
  {
  }

  void EventMultiSplitter::callback::operator () (double weight)
  {
        _splitter.processPermutation (weight, _event);
  }
}

---