HitSubtract_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       HitSubtract
// Module Type: producer
// File:        HitSubtract_module.cc
//
// Generated at Mon May 30 08:42:27 2016 by Andrey Sheshukov using artmod
// from cetpkgsupport v1_08_07.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "DDTBaseDataProducts/HitList.h"
#include "DDTBaseDataProducts/HitSet.h"
#include <boost/algorithm/string.hpp>
#include <boost/tokenizer.hpp>
#include <exception>
#include <memory>
#include <string>
#include <vector>
#include <iomanip>

/// a class for expression parsing. 
//Example: expr="A+B-C+D-E" means that we take hits from A
class Expression {
    public:
        Expression(const std::string& expr){Parse(expr);}
        novaddt::HitSet Eval(const art::Event & e);
        const std::map<std::string,uint64_t>& GetStatistics(){return fSeenHits;}
    private:
        void Parse(const std::string& s);
        novaddt::HitSet fetchOne(const std::string& tag,const art::Event & e){
           auto handle=e.getValidHandle<novaddt::HitList>(tag);
           return novaddt::HitSet(*handle);
        };
        novaddt::HitSet fetchAll(const std::string& tag,const art::Event & e){
            novaddt::HitSet hits;
            auto handle=e.getValidHandle<std::vector<novaddt::HitList>>(tag);
            for(const auto& hitlist: *handle)
                hits.add(hitlist);
            return hits;
        };
        novaddt::HitSet fetch(const std::string& tag,const art::Event & e){
            if(boost::ends_with(tag,"[]")){
                return fetchAll(boost::erase_tail_copy(tag,2),e);
            }
            else
                return fetchOne(tag,e);
        }
    private:
        std::vector<std::string> fTokens;
        std::map<std::string,uint64_t> fSeenHits;
};

void Expression::Parse(const std::string& str){
    mf::LogInfo("HitSub expression")<<"parse string:\'"<<str<<"\'";

    boost::char_separator<char> sep{"", "-+"};
    boost::tokenizer<boost::char_separator<char>> tok{str, sep};
    for (std::string t : tok){
        boost::trim(t);
       fTokens.push_back(t);
    }
}

novaddt::HitSet Expression::Eval(const art::Event & e){
   novaddt::HitSet result;
   char next_op='+';
   auto stream=mf::LogDebug("HitSub eval");
   for(const auto& t: fTokens){
      if(t[0]=='-'||t[0]=='+'){next_op=t[0]; continue;}
      novaddt::HitSet hits=fetch(t,e);
      fSeenHits[t]+=hits.size();
      stream<<next_op<<" Hits["<<t<<"]= "<<hits.size()<<"\n";
      switch(next_op){
        case '-': result.subtract(hits); break;
        case '+': result.add(hits); break;
        default:  throw std::logic_error("Wrong operation:"+std::to_string(next_op));
      }
   }
   stream<<"Result="<<result.size();
   fSeenHits["result"]+=result.size();
   return result;
}

namespace novaddt {
  class HitSubtract;
}

class novaddt::HitSubtract : public art::EDProducer {
public:
  explicit HitSubtract(fhicl::ParameterSet const & p);
  // The destructor generated by the compiler is fine for classes
  // without bare pointers or other resource use.

  // Plugins should not be copied or assigned.
  HitSubtract(HitSubtract const &) = delete;
  HitSubtract(HitSubtract &&) = delete;
  HitSubtract & operator = (HitSubtract const &) = delete;
  HitSubtract & operator = (HitSubtract &&) = delete;

  // Required functions.
  void produce(art::Event & e) override;
  void endJob() override;
    

private:
    Expression fExpr;
    std::string fLabel;
};


novaddt::HitSubtract::HitSubtract(fhicl::ParameterSet const & p)
 :fExpr(p.get<std::string>("expr")),fLabel(p.get<std::string>("label"))
// Initialize member data here.
{
  // Call appropriate produces<>() functions here.
  produces<novaddt::HitList>(fLabel);
}

void novaddt::HitSubtract::produce(art::Event & e)
{
  // Implementation of required member function here.
  auto hitSet=fExpr.Eval(e);
  std::unique_ptr<novaddt::HitList>hits(new novaddt::HitList(hitSet.begin(),hitSet.end()));
  e.put(std::move(hits),fLabel);
}

void novaddt::HitSubtract::endJob(){
    auto stream = mf::LogInfo("HitSub statistics");
    auto stats = fExpr.GetStatistics();
    stream<<" Hits statistics: ";
    for(const auto &t: stats){
        stream<<"\n    "<<std::setw(25)<<t.first<<" = "<<std::setw(25)<<t.second;
    }
}

DEFINE_ART_MODULE(novaddt::HitSubtract)