What Names Must Match

Module Names

1. It must be in a file named MyClass_module.cc.
2. The build system will make this into a file named lib/libMyClass_module.so.
3. The module source file must look like:

   namespace mu2e {
   
     class MyClass : public art::EDAnalyzer {
   
     public:
       explicit MyClass(fhicl::ParameterSet const& pset);
       // Compiler generated d'tor is OK.
   
       void analyze( art::Event const& event );
   
     };
   
     MyClass::MyClass(fhicl::ParameterSet const& pset){
      // Body of the constructor. You can access information in the parameter set here.
     }
   
     void MyClass::analyze(art::Event const& event){
       mf::LogVerbatim("test")
         << "Hello, world. From analyze. "
         << event.id();
     }
   
   } // end namespace mu2e
   
   using mu2e::MyClass;
   DEFINE_ART_MODULE(MyClass);
         

   This example is for an analyzer. To create a producer or a filter module, you must inherit from either art::EDProducer or art::EDFilter. The last line invokes a macro that inserts additional code into the .so file ( for the experts: it inserts a factory method to produce an instance of the class and it inserts and auto-registration object that registers the factory method with art's module registry ).
4. To declare this module to the framework you need to have a fragment like the following in your .fcl file:
   

        physics :
        {
           analyzers:
           {
              looseCuts : { module_type  : MyClass }
   
              # Other analyzer modules listed here ...
           }
        }
        

   The string looseCuts is called a module label and is is defined below.
5. The previous item was for the case that your module is an analyzer. If it is a producer or filter, then the text in green needs to be either producers or filters.
6. When you put a data product into an event, the data provenance system records the module label of the module that did the put.

Module Labels

physics: {
  producers: {
    looseCuts: { module_type   : MyClass }
  }
}

1. The string looseCuts is refered to as the module module label; I have sometimes called this module "instance name" but the code refers to it as ModuleLabel.
2. The above fragment may be expaned to include additional arguments, that will be treated as the definition of a parameter set to be given to the object. For example,

        physics :
        {
           analyzers:
           {
              looseCuts :
              {
                 module_type  : MyClass
                 cutLevel : 1
              }
   
              tightCuts :
              {
                 module_type  : MyClass
                 cutLevel : 2
              }
   
           }
        }
        

   The parameter cutLevel is available to the contructor of MyClass via the fhicl::ParameterSet argument.
3. In this example two modules are defined, both are of type EDAnalzer and both are instances of the class MyClass. They are distinguished by having different values in the parameter sets and by having different module labels. The name cutLevel has no meaning to the framework: presumably it has meaning within MyClass.

Getting Information by Module Label

       #include "RecoDataProducts/inc/StrawHitCollection.hh"

       art::Handle<StrawHitCollection> hitsHandle;
       event.getByLabel("strawHitMaker",hitsHandle);
       StrawHitCollection const& hits = *hitsHandle;
     

1. the event contains no collection of StrawHits.
2. the event contains one or more collections of StrawHits but none were created by the module with the label strawHitMaker.
3. the event contains more than 1 collections of StrawHits made by the module with the label strawHitMaker.
4. the event contains data products made by the module with the label strawHitMaker but none of those data products are of type StrawHitCollection.

For beginners: the & in the following:

    StrawHitCollection const & hits = *hitsHandle;
 

There are other ways to get data products from an event.

Security, Privacy, Legal