DemoModule_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief   The simplest job module possible to illustrate the essential
///          features of a job module
/// \author  $Author: gsdavies $
////////////////////////////////////////////////////////////////////////
// C/C++ includes
#include <cmath>
#include <iostream>
#include <string>
#include <vector>

// ROOT includes
#include "TH1F.h"

// Framework includes
#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/Services/Optional/TFileService.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

// NOvASoft includes
#include "RecoBase/CellHit.h"


///package to illustrate how to write modules
namespace demo {
  class DemoModule : public art::EDProducer {
    public:
      explicit DemoModule(fhicl::ParameterSet const& pset); // Required! explicit tag tells the compiler this is not a copy constructor      
      ~DemoModule();                        
      
      // Optional, read/write access to event
      void produce(art::Event& evt); 

      // Optional if you want to be able to configure from event display, for example
      void reconfigure(const fhicl::ParameterSet& pset);

      // Optional use if you have histograms, ntuples, etc you want around for every event
      void beginJob();
      
    private:
      ///< Sample configurable module parameters
      int              fInt;    
      std::vector<int> fVecInt;
      float            fFloat;  
      double           fDouble; 
      std::string      fInputModuleLabel; ///> label for module that made the data products you need for this module 
      TH1F*            fHisto;            ///> a histogram 

    };
}

////////////////////////////////////////////////////////////////////////
// note it is convention to NOT declare ANY "using namespace xxx" here
// especially "using namespace std"
namespace demo
{
  //.......................................................................
  DemoModule::DemoModule(fhicl::ParameterSet const& pset) 
  {
    //======================================================================
    // This is the constructor "nova" will use to create your module.
    //
    // Modules use configurations which have the same name as the
    // module. The variable "version" sets which version of this
    // configuration to use. Users are required to supply a configuration
    // called "default" but other versions ("test" eg.) are allowed.
    //
    // Which version to use is set at run time by the job description XML
    // file.
    //======================================================================

    this->reconfigure(pset);
    
    // tell the module what it is making as this is a EDProducer
    produces< std::vector<int> >();

    // Be noisy to demonstrate what's happening
    mf::LogInfo("DemoModule") << " DemoModule::DemoModule()\n";
  }

  //......................................................................
  DemoModule::~DemoModule()
  {
    //======================================================================
    // Clean up any memory allocated by your module
    //======================================================================
  }

  //......................................................................
  void DemoModule::reconfigure(const fhicl::ParameterSet& pset)
  {
    // Keep everything lined up for clarity (stylistic)
    fInt              = pset.get< int              >("MyInt");
    fVecInt           = pset.get< std::vector<int> >("MyVectorInt");
    fFloat            = pset.get< float            >("MyFloat");
    fDouble           = pset.get< double           >("MyDouble");
    fInputModuleLabel = pset.get< std::string      >("MyInputModuleLabel");
  }
      
  //......................................................................
  void DemoModule::beginJob()
  {
    //
    // Book histograms, ntuples, initialize counts etc., etc., ...
    //
    art::ServiceHandle<art::TFileService> tfs;

    fHisto = tfs->make<TH1F>("fHisto",
                             "Histo Title;x-axis title (units);y-axis title (units)",
                             100,0.,100.);
    
  }

  //......................................................................
  void DemoModule::produce(art::Event& evt)
  {
    //======================================================================
    // Called for every event. "Reco" implies that you are adding
    // information to the event
    //======================================================================
    mf::LogInfo("DemoModule") << "DemoModule::Reco()"
                              << "\n"
                              << "New Reco Event "; 

    //  get rb::CellHit from the event
    art::Handle< std::vector<rb::CellHit> > digitcol;
    evt.getByLabel(fInputModuleLabel, digitcol);
    art::PtrVector<rb::CellHit> digits;
    for(unsigned int i = 0; i < digitcol->size(); ++i){
      art::Ptr<rb::CellHit> dig(digitcol, i);
      digits.push_back(dig);
    }

    // make the collection of ints we want to store
    std::unique_ptr< std::vector<int> > adccol(new std::vector<int>);

    // fill a histogram with the size of each MCTruth
    for(unsigned int i = 0; i < digits.size(); ++i){
      adccol->push_back( digits[i]->ADC() );
      fHisto->Fill( digits[i]->ADC() );
    }

    // put the collection of adc values into the event
    evt.put(std::move(adccol));

    // maybe I really wanted to still keep that collection around for later 
    // use in a const fashion. Then I could have done
    // art::OrphanHandle< std::vector<int> > adcoh = evt.put(adccol);      
    
    return;
  }

} // end namespace demo
////////////////////////////////////////////////////////////////////////
namespace demo
{
  DEFINE_ART_MODULE(DemoModule)
}