RawDataDrawer.h

Go to the documentation of this file.

#ifndef EVD_RAWDATADRAWER_H
#define EVD_RAWDATADRAWER_H

namespace fhicl {
  class ParameterSet;
}

#include "larcoreobj/SimpleTypesAndConstants/geo_types.h" // geo::PlaneID

#include <vector>

#ifndef __CINT__
#include "larevt/CalibrationDBI/Interface/ChannelStatusProvider.h" // lariov::ChannelStatusProvider::Status_t
#endif

namespace art {
  class Event;
}

class TH1F;
class TVirtualPad;
namespace detinfo {
  class DetectorPropertiesData;
}
namespace evdb {
  class View2D;
}
namespace raw {
  class RawDigit;
}
namespace util {
  class PlaneDataChangeTracker_t;
} // namespace util

namespace evd {

  namespace details {
    class RawDigitCacheDataClass;
    class CellGridClass;
    typedef ::util::PlaneDataChangeTracker_t CacheID_t;
  } // namespace details

  class RawDataDrawer {
  public:
    RawDataDrawer();
    ~RawDataDrawer();

    void RawDigit2D(art::Event const& evt,
                    detinfo::DetectorPropertiesData const& detProp,
                    evdb::View2D* view,
                    unsigned int plane,
                    bool bZoomToRoI = false);

    void FillQHisto(const art::Event& evt, unsigned int plane, TH1F* histo);

    void FillTQHisto(const art::Event& evt, unsigned int plane, unsigned int wire, TH1F* histo);

    double StartTick() const { return fStartTick; }
    double TotalClockTicks() const { return fTicks; }

    void ExtractRange(TVirtualPad* pPad, std::vector<double> const* zoom = nullptr);

    void SetDrawingLimits(float low_wire, float high_wire, float low_tdc, float high_tdc);

    int GetRegionOfInterest(int plane, int& minw, int& maxw, int& mint, int& maxt);

    void ResetRegionOfInterest();

    bool hasRegionOfInterest(geo::PlaneID::PlaneID_t plane) const;

    void GetChargeSum(int plane, double& charge, double& convcharge);

  private:
    struct BoxInfo_t {
      int adc = 0;       
      bool good = false; 
    };

    struct PadResolution_t {
      unsigned int width = 0;  // width of pad in pixels
      unsigned int height = 0; // heigt of pad in pixels

      bool isFilled() const { return (width != 0) && (height != 0); }

      operator bool() const { return isFilled(); }

    }; 

    class OperationBaseClass;
    class ManyOperations;
    class BoxDrawer;
    class RoIextractorClass;

    // Since this is a private facility, we indulge in non-recommended practises
    // like friendship; these classes have the ability to write their findings
    // directly into RawDataDrawer; the alternative would be to have an
    // interface writing that information exposed to the public, that has the
    // draw back that we completely lose control on who can use it.
    // Other solutions might be also possible...
    // but this is already more complicated than needed.
    friend class BoxDrawer;
    friend class RoIextractorClass;

    // Never use raw pointers. Unless you are dealing with CINT, that is.
    evd::details::RawDigitCacheDataClass* digit_cache;

#ifndef __CINT__
    void Reset(art::Event const& event);

    void GetRawDigits(art::Event const& evt);

    bool ProcessChannelWithStatus(lariov::ChannelStatusProvider::Status_t channel_status) const;
#endif // __CINT__

    double fStartTick; 
    double fTicks;     

    std::vector<int> fWireMin; 
    std::vector<int> fWireMax; 
    std::vector<int> fTimeMin; 
    std::vector<int> fTimeMax; 

    std::vector<double> fRawCharge;       
    std::vector<double> fConvertedCharge; 

    PadResolution_t PadResolution; 

    details::CacheID_t* fCacheID; 

    // TODO with ROOT 6, turn this into a std::unique_ptr()
    details::CellGridClass* fDrawingRange; 

    void DrawRawDigit2D(art::Event const& evt, evdb::View2D* view, unsigned int plane);

    void GetRawDigits(art::Event const& evt, details::CacheID_t const& new_timestamp);

    // Helper functions for drawing
    bool RunOperation(art::Event const& evt, OperationBaseClass* operation);
    void QueueDrawingBoxes(evdb::View2D* view,
                           geo::PlaneID const& pid,
                           std::vector<BoxInfo_t> const& BoxInfo);
    void RunDrawOperation(art::Event const& evt,
                          detinfo::DetectorPropertiesData const& detProp,
                          evdb::View2D* view,
                          unsigned int plane);
    void RunRoIextractor(art::Event const& evt, unsigned int plane);
    void SetDrawingLimitsFromRoI(geo::PlaneID::PlaneID_t plane);
    void SetDrawingLimitsFromRoI(geo::PlaneID const pid) { SetDrawingLimitsFromRoI(pid.Plane); }

    static std::vector<raw::RawDigit> const EmptyRawDigits;

  }; // class RawDataDrawer

}

#endif