ShowerProducedPtrsHolder.hh

Go to the documentation of this file.

//###################################################################
//### Name:        ShowerProducedPtrsHolder                       ###
//### Author:      Dominic Barker                                 ###
//### Date:        15.07.19                                       ###
//### Description: Class to holder the unique ptrs required to    ###
//###              produce data products. Used in                 ###
//###              LArPandoraModularShower and corresponding      ###
//###              tools.                                         ###
//###################################################################

#ifndef ShowerProducedPtrsHolder_HH
#define ShowerProducedPtrsHolder_HH

#include "larpandora/LArPandoraEventBuilding/LArPandoraShower/Algs/ShowerElementHolder.hh"

//Framework includes
#include "art/Framework/Principal/Event.h"
#include "art/Persistency/Common/PtrMaker.h"
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "cetlib_except/demangle.h"
#include "cetlib_except/exception.h"

namespace reco::shower {
  class ShowerUniqueProduerPtrBase;
  template <class T> class ShowerUniqueProductPtr;
  template <class T> class ShowerUniqueAssnPtr;
  class ShowerPtrMakerBase;
  template <class T> class ShowerPtrMaker;
  class ShowerProducedPtrsHolder;
}

#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <utility> // std::move()
#include <vector>

//Template to check if its an assn
template <class N>
struct is_assn { static const int value = 0; };

template  <class L, class R, class D>
struct is_assn<art::Assns< L, R, D > >{ static const int value = 1; };

//Template to carry the type becuase functions can't, annoyingly, be partially specialised
template <typename T>
struct type{};


//Base class for the class that holds the ptr.
class reco::shower::ShowerUniqueProduerPtrBase {

  public:

    virtual ~ShowerUniqueProduerPtrBase() noexcept = default;

    virtual void reset() = 0;

    virtual void AddDataProduct(const reco::shower::ShowerElementHolder& selement_holder, const std::string& Name) = 0;

    virtual void MoveToEvent(art::Event& evt) = 0;

    virtual std::string GetType() const = 0;
    virtual std::string GetInstanceName() const = 0;

    virtual int GetVectorPtrSize() const {return -1;}
};

//Class that holds a unique ptr for the product. This is what is stored in the map. The product is put into
//the event as a vector so the this holder maintains this unique ptr and the actions to manipulate it.
template <class T>
class reco::shower::ShowerUniqueProductPtr<std::vector<T> >: public reco::shower::ShowerUniqueProduerPtrBase{

  public:

    ShowerUniqueProductPtr<std::vector<T> >(const std::string& Instancename){
      ptr = 1;
      showeruniqueptr = std::make_unique<std::vector<T> >();
      InstanceName = Instancename;
    }

    //Get the unique ptr for the data product.
    std::unique_ptr<T>& GetPtr() {
      if(ptr){
        return showeruniqueptr;
      }
      else{
        throw cet::exception("ShowerUniqueProduerPtr") << "Element does not exist" << std::endl;
      }
    }

    void reset() override {
      showeruniqueptr.reset(new std::vector<T>());
    }

    //Add a data product on to the vector that will be added to the event.
    void AddDataProduct(const reco::shower::ShowerElementHolder& selement_holder, const std::string& Name) override {
      T product;
      if (!selement_holder.CheckElement(Name)){
        mf::LogError("ShowerProducedPtrsHolder") << "Trying to add data product: " << Name << ". This element does not exist in the element holder" << std::endl;
        return;
      }

      int err = selement_holder.GetElement(Name, product);
      if(err){
        mf::LogError("ShowerProducedPtrsHolder") << "Trying to add data product: " << Name << ". This element does not exist in the element holder" << std::endl;
        return;
      }
      showeruniqueptr->push_back(product);
      return;
    }

    //Final thing to do move to the event.
    void MoveToEvent(art::Event& evt) override {
      evt.put(std::move(showeruniqueptr),InstanceName);
    }

    //This returns the type of the undrlying element. It should be of the form std::unique_ptr<std::vector<T> >
    std::string GetType() const override {
      return cet::demangle_symbol(typeid(showeruniqueptr.get()).name());
    }

    //A user can set the instances name like an other producer module product. Get it using this.
    std::string GetInstanceName() const override {
      return InstanceName;
    }

    //Get the size of the std::vector. Usful for making assns.
    int GetVectorPtrSize() const override {
      return showeruniqueptr->size();
    }


  private:

    //Element itself that is put into the art event.
    std::unique_ptr<std::vector<T> > showeruniqueptr;

    //bool to see if the element is set.
    bool ptr;

    //Name when saved into the the event default is ""
    std::string InstanceName;
};


//Class that holds a unique ptr for the association. This is what is stored in the map. The association is put into
//the event as a vector so the this holder maintains this unique ptr and the actions to manipulate it.
//I guess if the product if a product is unique to the event then this holder will deal with it.
//I have tried to be smart and I don't think it not being an association is a problem as
//long as the user is smart.
template <class T>
class reco::shower::ShowerUniqueAssnPtr: public reco::shower::ShowerUniqueProduerPtrBase{

  public:

    ShowerUniqueAssnPtr(const std::string& Instancename){
      ptr = 1;
      showeruniqueptr = std::make_unique<T>();
      InstanceName = Instancename;
    }

    //Get the ptr to the association.
    std::unique_ptr<T>& GetPtr() {
      if(ptr){
        return showeruniqueptr;
      }
      else{
        throw cet::exception("ShowerUniqueAssnPtr") << "Element does not exist" << std::endl;
      }
    }

    void reset() override {
      showeruniqueptr.reset(new T());
    }

    //place the association to the event.
    void MoveToEvent(art::Event& evt) override {
      evt.put(std::move(showeruniqueptr), InstanceName);
    }

    //Not need but the compiler complains if its not here.
    void AddDataProduct(const reco::shower::ShowerElementHolder& selement_holder, const std::string& Name) override {
      throw cet::exception("ShowerUniqueAssnPtr") << "The creator of this code has failed you. Please contact Dominic Bakrer" << std::endl;
    }

    //Get the type in form as a string. It should be the form of std::unique_ptr<art::Assn<T A, T1 B> >
    std::string GetType() const override {
      return cet::demangle_symbol(typeid(showeruniqueptr.get()).name());
    }

    //Get the Instance name that product will be saved as in the art::Event.
    std::string GetInstanceName() const override {
      return InstanceName;
    }


  private:

    //Actual Element the assn. This is put into the event.
    std::unique_ptr<T> showeruniqueptr;

    //bool to see if the element is filled.
    bool ptr;

    //Name when saved into the the event default is ""
    std::string InstanceName;
};


//Base class to hold the pointer makers. This interacts the with the module a little differently
//as the ptr makers do not work within the tools. The holds and the ptrmaker and provides set and
//get functions so that the usr can access art::Ptrs for the products of the module and associate
//them to other things.
class reco::shower::ShowerPtrMakerBase{

  public:

    virtual ~ShowerPtrMakerBase() noexcept = default;

    virtual bool CheckPtrMaker() const = 0;

    virtual void SetPtrMaker(art::Event& evt) = 0;

    virtual void Reset() = 0;

};

//Derived class - See above
template<class T>
class reco::shower::ShowerPtrMaker : public ShowerPtrMakerBase{

  public:


    ShowerPtrMaker(const std::string& Instancename){
      ptrmaker = nullptr;
      ptr = 0;
      InstanceName = Instancename;
    }

    //Check the ptr maker is ready to be used.
    bool CheckPtrMaker() const override {
      if(ptr){
        return true;
      }
      return false;
    }

    //Return the ptr maker. Probably never needed.
    art::PtrMaker<T>& GetPtrMaker(){
      if(ptr){
        if(ptrmaker == nullptr){
          throw cet::exception("ShowerPtrMaker") << "Ptr maker ptr is null" << std::endl;
        }
        return *ptrmaker;
      }
      throw cet::exception("ShowerPtrMaker") << "Trying to get a  ptrmaker that does not exists" << std::endl;
    }

    //Return the art ptr that the module produces corresponding the index iter
    art::Ptr<T> GetArtPtr(int iter) const {
      if(ptr){
        if(ptrmaker == nullptr){
          throw cet::exception("ShowerPtrMaker") << "Ptr maker ptr is null" << std::endl;
        }
        return (*ptrmaker)(iter);
      }
      throw cet::exception("ShowerPtrMaker") << "Trying to get a  ptrmaker that does not exists" << std::endl;
    }

    //Set the ptr maker this is reset at the start of the event.
    void SetPtrMaker(art::Event& evt) override {
      ptrmaker.reset(new art::PtrMaker<T>(evt,InstanceName));
      ptr = 1;
    }

    void Reset() override {
      if(!ptr){
        throw cet::exception("ShowerPtrMaker") << "Trying to reset ptr but it has not been set in the first place. Please contatc Dom Barker" << std::endl;
      }
      ptrmaker.reset(nullptr);
      ptr = 0;
    }

  private:

    //The ptr maker itself. Used to make art::Ptrs to make assns.
    std::unique_ptr<art::PtrMaker<T> > ptrmaker;

    //The name of the data product which will be saved in the event. The ptr maker requires this.
    std::string InstanceName;

    //bool to tell if the ptr maker is ready to use or not.
    int ptr;
};

//Class that holds all the unique ptrs and the ptr makers. It is what the tools and module use
//to access the above class elements. The end user case will see the user not interact with this
// directly.
class reco::shower::ShowerProducedPtrsHolder {

  public:

    //Initialise the a unique ptr in the map. This will be added to the event.
    template <class T>
      int SetShowerUniqueProduerPtr(type<T>, const std::string& Name, const std::string& Instance=""){

        //Add to the assns
        if(showerassnPtrs.find(Name) != showerassnPtrs.end()){
          mf::LogWarning("ShowerProducedPtrsHolder") << "Trying to set Element: " << Name << ". This element has already been set. Please check." << std::endl;
          return 1;
        }

        //Check the same type has not already been set.
        if(!CheckForMultipleTypes(type<T>(), Name, Instance)){
          throw cet::exception("ShowerProducedPtrsHolder") << "Trying to set multiple objects with same type with no instance name or same instance name" << std::endl;
        }

        showerassnPtrs[Name] = std::make_unique<ShowerUniqueAssnPtr<T> >(Instance);
        return 0;
      }

    //Set the unique ptr. The unique ptr will be filled into the event.
    template <class T>
      int SetShowerUniqueProduerPtr(type<std::vector<T> >, const std::string& Name, const std::string& Instance=""){

        //Then add the products
        if(showerproductPtrs.find(Name) != showerproductPtrs.end()){
          mf::LogWarning("ShowerProducedPtrsHolder") << "Trying to set Element: " << Name << ". This element has already been set. Please check." << std::endl;
          return 1;
        }

        //Check the same type has not already been set.
        if(!CheckForMultipleTypes(type<std::vector<T> >(), Name, Instance)){
          throw cet::exception("ShowerProducedPtrsHolder") << "Trying to set multiple objects with same type with no instance name or same instance name" << std::endl;
        }

        if(showerPtrMakers.find(Name) != showerPtrMakers.end()){
          throw cet::exception("ShowerProducedPtrsHolder") << "PtrMaker already exist. It should not be set again" << std::endl;
        }
        showerPtrMakers[Name]   = std::make_unique<ShowerPtrMaker<T> >(Instance);
        showerproductPtrs[Name] = std::make_unique<ShowerUniqueProductPtr<std::vector<T > > >(Instance);
        return 0;
      }


    //Checks if the ptr exists
    bool CheckUniqueProduerPtr(const std::string& Name) const {
      if(showerproductPtrs.find(Name) != showerproductPtrs.end()){
        return true;
      }
      if(showerassnPtrs.find(Name) != showerassnPtrs.end()){
        return true;
      }
      return false;
    }

    //Reset the ptrs;
    void reset(){
      for(auto const& showerptr: showerproductPtrs){
        (showerptr.second)->reset();
      }
      for(auto const& showerptr: showerassnPtrs){
        (showerptr.second)->reset();
      }
    }

    //Add any data products that are produced by the module to the unique ptr it corresponds to
    //This is done by matching strings in the element holder and the ptr holder. Hence these
    //must match. This is a global command done in the module.
    void AddDataProducts(const reco::shower::ShowerElementHolder& selement_holder){
      for(auto const& showerproductPtr: showerproductPtrs){
        (showerproductPtr.second)->AddDataProduct(selement_holder, showerproductPtr.first);
      }
    }

    //Global command to move all products into the event. This is done in the module.
    void MoveAllToEvent(art::Event& evt){
      for(auto const& showerproductPtr: showerproductPtrs){
        (showerproductPtr.second)->MoveToEvent(evt);
      }
      for(auto const& showerassnPtr: showerassnPtrs){
        (showerassnPtr.second)->MoveToEvent(evt);
      }
    }

    bool CheckAllProducedElements(reco::shower::ShowerElementHolder& selement_holder) const {
      bool checked = true;
      for(auto const& showerproductPtr: showerproductPtrs){
        if(showerproductPtr.first == "shower"){continue;}
        checked *= selement_holder.CheckElement(showerproductPtr.first);
      }
      return checked;
    }


    //This returns the unique ptr. This is a legacy code.
    template <class T>
      T& GetPtr(const std::string& Name){
        auto const showerproductPtrsIt = showerproductPtrs.find(Name);
        if(showerproductPtrsIt != showerproductPtrs.end()){
          reco::shower::ShowerUniqueProductPtr<T>* prod = dynamic_cast<reco::shower::ShowerUniqueProductPtr<T> *>(showerproductPtrsIt->second.get());
          return prod->GetPtr();
        }

        auto const showerassnPtrsIt = showerassnPtrs.find(Name);
        if(showerassnPtrsIt != showerassnPtrs.end()){
          reco::shower::ShowerUniqueAssnPtr<T>* assn = dynamic_cast<reco::shower::ShowerUniqueAssnPtr<T> *>(showerassnPtrsIt->second.get());
          return assn->GetPtr();
        }

        throw cet::exception("ShowerProducedPtrsHolder") << "Trying to get Ptr for: " << Name << " but Element does not exist" << std::endl;
      }

    //Wrapper so that the use the addSingle command for the association. Add A and B to the association just
    //as if add single add.
    template <class T, class A, class B>
      void AddSingle(A& a, B& b, const std::string& Name){
        auto const showerassnPtrsIt = showerassnPtrs.find(Name);
        if(showerassnPtrsIt == showerassnPtrs.end()){
          throw cet::exception("ShowerProducedPtrsHolder") << "Trying to get the association: " << Name << "Element does not exist" << std::endl;
        }
        if(!is_assn<T>::value){
          throw cet::exception("ShowerProducedPtrsHolder") << "Element type  is not an assoication please only use this for assocations" << std::endl;
        }
        reco::shower::ShowerUniqueAssnPtr<T>* assnptr = dynamic_cast<reco::shower::ShowerUniqueAssnPtr<T> *>(showerassnPtrsIt->second.get());
        if(assnptr == nullptr){
          throw cet::exception("ShowerProducedPtrsHolder") << "Failed to cast back. Maybe you got the type wrong or you are accidently accessing a differently named product" << std::endl;
        }

        T* assn = dynamic_cast<T*>(assnptr->GetPtr().get());
        if(assn == nullptr){
          throw cet::exception("ShowerProducedPtrsHolder")  << "Something went wrong trying to cast tothe assn. Maybe the name: " << Name << " exists but its not an assn" << std::endl;
        }

        assn->addSingle(a,b);
        return;
      }

    //Initialise the ptr makers. This is done at the the start of the module.
    void SetPtrMakers(art::Event& evt){
      for(auto const&  showerPtrMaker:  showerPtrMakers){
        if(showerPtrMakers.find(showerPtrMaker.first) == showerPtrMakers.end()){
          throw cet::exception("ShowerProducedPtrsHolder") << "PtrMaker was empty. This is concerning" << std::endl;
        }
        showerPtrMakers[showerPtrMaker.first]->SetPtrMaker(evt);
      }
    }

    //Wrapper to access a particle PtrMaker. This is legacy as is not used.
    template <class T>
      art::PtrMaker<T>& GetPtrMaker(const std::string& Name){
        auto const showerPtrMakersIt = showerPtrMakers.find(Name);
        if(showerPtrMakersIt == showerPtrMakers.end()){
          throw cet::exception("ShowerProducedPtrsHolder") << "PtrMaker does not exist" << std::endl;
        }
        else{
          if(!showerPtrMakersIt->second->CheckPtrMaker()){
            throw cet::exception("ShowerProducedPtrsHolder") << "PtrMaker is not set" << std::endl;
          }
          reco::shower::ShowerPtrMaker<T>* ptrmaker = dynamic_cast<reco::shower::ShowerPtrMaker<T> *>(showerassnPtrs[Name].get());
          return ptrmaker->GetPtrMaker();
        }
      }

    //Wrapper to return to the the user the art ptr corresponding the index iter
    template <class T>
      art::Ptr<T> GetArtPtr(const std::string& Name, const int& iter) const {
        auto const showerPtrMakersIt = showerPtrMakers.find(Name);
        if(showerPtrMakersIt == showerPtrMakers.end()){
          throw cet::exception("ShowerProducedPtrsHolder") << "PtrMaker does not exist for " << Name << " Did you initialise this? "  << std::endl;
        }
        else{
          if(!showerPtrMakersIt->second->CheckPtrMaker()){
            throw cet::exception("ShowerProducedPtrsHolder") << "PtrMaker is not set. This is an issue for the devlopment team me. Contact Dom Barker" << std::endl;
          }
          reco::shower::ShowerPtrMaker<T>* ptrmaker = dynamic_cast<reco::shower::ShowerPtrMaker<T> *>(showerPtrMakersIt->second.get());
          if(ptrmaker == nullptr){
            throw cet::exception("ShowerProducedPtrsHolder") << "Failed to cast back. Maybe you got the type wrong or you are accidently accessing a differently named product" << std::endl;
          }
          return ptrmaker->GetArtPtr(iter);
        }
      }

    //Legacy not used.
    void ResetPtrMakers(){
      for(auto const& showerPtrMaker: showerPtrMakers){
        (showerPtrMaker.second)->Reset();
      }
    }

    //Return the size of the std::vector of the data object with the unique name string.
    int GetVectorPtrSize(const std::string& Name) const {
      auto const showerproductPtrsIt = showerproductPtrs.find(Name);
      if(showerproductPtrsIt != showerproductPtrs.end()){
        return showerproductPtrsIt->second->GetVectorPtrSize();
      }
      throw cet::exception("ShowerProducedPtrsHolder") << "Product: " << Name << " has not been set in the producers map" << std::endl;
    }

    //Print the type, the element name and the instance name
    void PrintPtr(const std::string& Name) const {
      auto const showerproductPtrsIt = showerproductPtrs.find(Name);
      if(showerproductPtrsIt != showerproductPtrs.end()){
        const std::string Type     = showerproductPtrsIt->second->GetType();
        const std::string InstanceName = showerproductPtrsIt->second->GetInstanceName();
        std::cout << "Element Name: " << Name << " Instance Name: " << InstanceName <<  " Type: " << Type << std::endl;
        return;
      }
      auto const showerassnPtrsIt = showerassnPtrs.find(Name);
      if(showerassnPtrsIt != showerassnPtrs.end()){
        const std::string Type      = showerassnPtrsIt->second->GetType();
        const std::string InstanceName  = showerassnPtrsIt->second->GetInstanceName();
        std::cout << "Element Name: " << Name << " Instance Name: " << InstanceName <<  " Type: " << Type << std::endl;
        return;
      }
      mf::LogError("ShowerProducedPtrsHolder") << "Trying to print Element: " << Name << ". This element does not exist in the element holder" << std::endl;
      return;
    }


    //This function will print out all the pointers and there types for the user to check.
    void PrintPtrs() const {

      unsigned int maxname = 0;
      for(auto const& showerprodPtr: showerproductPtrs){
        if(showerprodPtr.first.size() > maxname){
          maxname = showerprodPtr.first.size();
        }
      }
      for(auto const& showerassnPtr: showerassnPtrs){
        if(showerassnPtr.first.size() > maxname){
          maxname = showerassnPtr.first.size();
        }
      }

      std::map<std::string,std::pair<std::string,std::string> > Type_showerprodPtrs;
      std::map<std::string,std::pair<std::string,std::string> > Type_showerassnPtrs;
      for(auto const& showerprodPtr: showerproductPtrs){
        const std::string Type         = (showerprodPtr.second)->GetType();
        const std::string InstanceName = (showerprodPtr.second)->GetInstanceName();
        Type_showerprodPtrs[showerprodPtr.first] = std::make_pair(InstanceName,Type);
      }
      for(auto const& showerassnPtr: showerassnPtrs){
        const std::string Type         = (showerassnPtr.second)->GetType();
        const std::string InstanceName = (showerassnPtr.second)->GetInstanceName();
        Type_showerassnPtrs[showerassnPtr.first] = std::make_pair(InstanceName,Type);
      }

      unsigned int maxtype     = 0;
      unsigned int maxinstname = 0;
      for(auto const& Type_showerprodPtr: Type_showerprodPtrs){
        if(Type_showerprodPtr.second.second.size() > maxtype){
          maxtype = Type_showerprodPtr.second.second.size();
        }
        if(Type_showerprodPtr.second.first.size() > maxinstname){
          maxinstname = Type_showerprodPtr.second.first.size();
        }
      }
      for(auto const& Type_showerassnPtr: Type_showerassnPtrs){
        if(Type_showerassnPtr.second.second.size() > maxtype){
          maxtype = Type_showerassnPtr.second.second.size();
        }
        if(Type_showerassnPtr.second.first.size() > maxinstname){
          maxinstname = Type_showerassnPtr.second.first.size();
        }
      }

      unsigned int n = maxname + maxtype + maxinstname + 51;
      std::cout << std::left << std::setfill('*') << std::setw(n-1) << "**" <<std::endl;
      std::cout << "Unique Ptrs that are added to the event" << std::endl;
      std::cout << std::left << std::setfill('*') << std::setw(n-1) << "**" <<std::endl;
      for(auto const& Type_showerprodPtr: Type_showerprodPtrs){
        std::cout << std::left << std::setfill(' ') << std::setw(21) << "* Data Product Name: " << std::setw(maxname) << Type_showerprodPtr.first;
        std::cout << std::left << std::setfill(' ') << " * Instance Name: " << std::setw(maxinstname) << Type_showerprodPtr.second.first;
        std::cout << std::left << std::setfill(' ') << " * Type: " << std::setw(maxtype) << Type_showerprodPtr.second.second <<  " *" << std::endl;
      }
      for(auto const& Type_showerassnPtr: Type_showerassnPtrs){
        std::cout << std::left << std::setfill(' ') << std::setw(maxname) << std::setw(21)  << "* Association Name: " << std::setw(maxname) << Type_showerassnPtr.first;
        std::cout << std::left << std::setfill(' ') << " * Instance Name: " << std::setw(maxinstname) << Type_showerassnPtr.second.first;
        std::cout << std::left << std::setfill(' ') << " * Type: " << std::setw(maxtype) <<  Type_showerassnPtr.second.second<< " *" << std::endl;
      }
      std::cout << std::left << std::setfill('*') << std::setw(n-1) << "**" <<std::endl;
      std::cout << std::setfill(' ');
      std::cout << std::setw(0);
      return;
    }



  private:

    //Function to check that a data product does not already exist with the same instance name
    template <class T>
      bool CheckForMultipleTypes(type<T>, const std::string& Name, const std::string& Instance) const {

        //Check the a product of the same does not exist without a different instance name
        for(auto const& assn: showerassnPtrs){
          reco::shower::ShowerUniqueAssnPtr<T>* assnptr = dynamic_cast<reco::shower::ShowerUniqueAssnPtr<T> *>(assn.second.get());
          if(assnptr != nullptr){
            if(assnptr->GetInstanceName() == Instance){return false;}
          }
        }
        return true;
      }

    //Function to check that a data product does not already exist with the same instance name
    template <class T>
      bool CheckForMultipleTypes(type<std::vector<T> >, const std::string& Name, const std::string& Instance) const{

        //Check the a product of the same does not exist without a different instance name
        for(auto const& product: showerproductPtrs){
          reco::shower::ShowerUniqueProductPtr<std::vector<T > >* prod = dynamic_cast<reco::shower::ShowerUniqueProductPtr<std::vector<T> > *>(product.second.get());
          if(prod != nullptr){
            if(prod->GetInstanceName() == Instance){return false;}
          }
        }
        return true;
      }



    //Holder of the data objects of type std::vector<T> that will be saved in the events.
    std::map<std::string,std::unique_ptr<reco::shower::ShowerUniqueProduerPtrBase > > showerproductPtrs;

    //Holder of the data objects of type T that will be saved into the events. I think these will only be assns.
    std::map<std::string,std::unique_ptr<reco::shower::ShowerUniqueProduerPtrBase > > showerassnPtrs;

    //Holder of the ptrMakers whcih make the art::Ptrs of the data objects that lie in showerproductPtrs.
    std::map<std::string,std::unique_ptr<reco::shower::ShowerPtrMakerBase> > showerPtrMakers;
};



#endif