RawDataDrawer.h

Go to the documentation of this file.

#ifndef EVD_RAWDATADRAWER_H
#define EVD_RAWDATADRAWER_H

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

#include <vector>
#ifndef __CINT__

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

#endif

class TH1F;
class TVirtualPad;
namespace art    { class Event;     }
namespace evdb   { class View2D;    }
namespace evdb   { class View3D;    }
namespace raw    { class RawDigit;  }
namespace lar {
  namespace util {
    template <typename T> class MinMaxCollector;
  }
}
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, evdb::View2D* view, unsigned int plane,
      bool bZoomToRoI = false
      );

/*     void RawDigit3D(const art::Event& evt, */
/*                  evdb::View3D*     view); */

    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:
    typedef struct {
      int    adc   = 0;  
      bool   good  = false; 
    } BoxInfo_t;
    
    typedef struct {
      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(); }
      
    } PadResolution_t; 
    
    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, 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