SliceNavigator.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// \file   SliceNavigator_service.cc
// \brief  Look up products dependent on the current slice
// \author Christopher Backhouse - bckhouse@caltech.edu
////////////////////////////////////////////////////////////////////////

#ifndef EVD_SLICENAVIGATOR_H
#define EVD_SLICENAVIGATOR_H

#include <vector>
#include <string>

#include "fhiclcpp/ParameterSet.h"
#include "art/Framework/Services/Registry/ActivityRegistry.h"
#include "art/Framework/Services/Registry/ServiceMacros.h"
#include "nuevdb/EventDisplayBase/Reconfigurable.h"

#include "RecoBase/Cluster.h"

namespace evd
{
  /// Look up products dependent on the current slice
  class SliceNavigator : evdb::Reconfigurable
  {
  public:
    explicit SliceNavigator(const fhicl::ParameterSet& pset,
                            art::ActivityRegistry& reg);
    ~SliceNavigator();

    void reconfigure(const fhicl::ParameterSet& pset) override;
    void preBeginRun(art::Run const & r);
    void postProcessEvent(const art::Event& evt);

    template<class T> size_t
    GetProducts(const art::Event&      evt,
                const std::string&     which,
                const std::string&     instance,
                std::vector<const T*>& prods);

    template<class T> size_t
    GetProducts(const art::Event&      evt,
                const std::string&     whichTrack,
                const std::string&     whichMichel,
                const std::string&     instance,
                std::vector<const T*>& prods);

    bool FullEventMode() const;
    void SetFullEventMode(bool mode);

    void Previous();
    void Next();
    int CurrentSlice() const;
    int CurrentSliceIndex() const;

    void SetCurrentSlice(int slice);
    int MaxSlice() const;
    std::vector<const rb::Cluster*> SlicesToNavigate( const art::Event& evt);

    void GetBounds(const art::Event& evt,
                   double& xmin, double& xmax,
                   double& ymin, double& ymax,
                   double& zmin, double& zmax,
                   double trimfrac = 0);

    void GetBox(const art::Event& evt,
                   double& xmin, double& xmax,
                   double& ymin, double& ymax,
                   double& zmin, double& zmax,
                   double trimfrac = 0);

    bool DimHits() const {return fDimHits;}
    bool DimOthers() const {return fDimOthers;}
    
    int fAutoAdvanceInterval;      ///< Wait time in milliseconds
    std::string fAutoPrintPattern; ///< Pattern for constructing filename
    int fAutoPrintMax;             ///< How many events to print (zero = disable printing)
    
    int fAutoPrintCount;

  protected:
    template<class T> size_t
    GetProductsImpl(const art::Event&      evt,
                    const std::string&     which,
                    const std::string&     instance,
                    std::vector<const T*>& prods);

    template<class T> size_t
    GetProductsImplFull(const art::Event&      evt,
                        const std::string&     which,
                        const std::string&     instance,
                        std::vector<const T*>& prods);

    template<class T> size_t
    GetProductsImplPart(const art::Event&      evt,
                        const std::string&     which,
                        const std::string&     instance,
                        std::vector<const T*>& prods);

    void ParseModuleInstanceString(std::string & mod,
                                   std::string & inst);
    
    std::string stringReplace(std::string &s,
                              const std::string &toReplace,
                              const std::string &replaceWith);
    
    int fRun;
    
    bool fFilterResults; ///< Only navigate slices that aren't filtered out
    bool fDimHits;
    bool fDimOthers;
    std::string fSliceLabel;
    std::string fCellHitLabel;
    std::string fSliceInstance;
    std::string fCellHitInstance;
    bool fFullEvent;
    int fCurrentSlice; ///< Index into \ref fSlicesToNavigate
    int fMaxSliceId;
    std::vector<int> fSlicesToNavigate;

    std::vector<art::Ptr<rb::Cluster>> fSlices;
    art::PtrVector<rb::CellHit> fAllHits;

    int fInitialSlice; ///< -1 afterwards
  };
}

DECLARE_ART_SERVICE(evd::SliceNavigator, LEGACY)

#endif
////////////////////////////////////////////////////////////////////////