AttenCache.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief   Helper for AttenCurve
/// \author bckhouse@caltech.edu
/// \date   
////////////////////////////////////////////////////////////////////////
#ifndef CALIB_ATTENCACHE_H
#define CALIB_ATTENCACHE_H

#include <map>
#include <set>
#include <string>

#include "NovaDAQConventions/DAQConventions.h"
#include "GeometryObjects/OfflineChan.h"

namespace geo{class GeometryBase; class PlaneGeo;}

namespace calib
{
  class AttenCurve;

  class AttenCache
  {
  public:
    AttenCache( bool is_data, int brightness_bin );
    virtual ~AttenCache();

    /// Return an AttenCurve object matching your parameters, or NULL
    /// if there isn't one in the database. Do not delete the resulting object,
    /// they are cached internally.
    const AttenCurve* ForData(const geo::GeometryBase* geom,
                              geo::OfflineChan chan);
    const AttenCurve* ForMC(const geo::GeometryBase* geom,
                            geo::OfflineChan chan, bool maskUncalibratedChannels);

    void SetCSVSource(const std::string& path){ fCSVSourceDir = path; }

    void UseCSVsFromUPS(bool use = true) {fUseCSVsFromUPS = use;}

    void SetTag(const std::string& tag) {fTag = tag;}

    std::string GetTag() {return fTag;}

    void SetUseEpochs(bool b) { fUseEpochs = b; }

    bool UseEpochs() {return fUseEpochs;}
    
    void SetEpoch(const std::string& epoch) {fEpoch = epoch;}
    void SetEpochTag( const std::string& tag) {fEpochTag = tag;}

    std::string Epoch() {return fEpoch;}
    std::string EpochTag() { return fEpochTag; }
    void GetEpochFromDB(int idet, bool forceData = false);

    void ReadEpochsFromCSV(bool readEpochs=true) {fReadEpochsFromCSV=readEpochs;}
    
    
    void SetRun(int run) { fRun = run; }
    int Run() { return fRun; }

    void SetGainSetting(int g) {fGainSetting = g;}
    int  GainSetting() {return fGainSetting;}

    void Reinit();
    
  protected:
    // Loading curves from the database as required is too slow (latency).
    // Instead, just read the whole detector in and cache it.

    void Add(AttenCurve* res);

    class Key_t
    {
    public:
      Key_t(int d, geo::OfflineChan chan) : fDet(d), fChan(chan) {}
      bool operator<(const Key_t& rhs) const;
    protected:
      int fDet;
      geo::OfflineChan fChan;
    };

    /// NULL if entry isn't in the cache. Do not delete the returned pointer.
    const AttenCurve* Get(Key_t key) const;

    std::string GetCSVPath(novadaq::cnv::DetId det, bool points, bool forceData = false);

    void LoadFromDatabase(const geo::GeometryBase* geom);
    
    void LoadFromDatabaseUncalibratedMask(const geo::GeometryBase* geom);

    /// Deal with averaged constants etc
    Key_t TranslateChannelData(geo::OfflineChan chan,
                               const geo::GeometryBase* geom) const;
    /// Deal with merged views, muon catcher, etc
    Key_t TranslateChannelMC(geo::OfflineChan chan,
                             const geo::GeometryBase* geom) const;

    /// Get the view for the current combination of view and plane (x,y,mux, or muy)
    int GetView(int plane, const geo::GeometryBase* geom) const;

    const geo::PlaneGeo* RepresentativePlane(const geo::GeometryBase* geom,
                                             int view,
                                             bool& inMuonCatcher) const;

    std::string fCSVSourceDir;
    bool fUseCSVsFromUPS;
    bool fUseEpochs;
    int fRun;
    std::string fTag;
    std::string fEpoch;
    std::string fEpochTag;

    bool fReadEpochsFromCSV;  //Needs to have fRun set

    // Whether we have (attempted to) read from db or csv yet
    bool fInitializedData;
    bool fInitializedMC;
    bool fInitializedUncalibratedMask;

    int fGainSetting;
    int fBrightnessBin;

    bool fIsData; ///< this is a cache for data calibrations or not

    std::map<Key_t, AttenCurve*> fMapData;
    std::map<Key_t, AttenCurve*> fMapMC;
    std::set<Key_t> fMapUncalibratedMask;

    std::set<int> fDiblocks; ///< Diblocks with calibrations
  };

} // end namespace calib

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