AbsCache.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief  Look up absolute attenuation constants
/// \author Christopher Backhouse - bckhouse@caltech.edu
////////////////////////////////////////////////////////////////////////

#include "Calibrator/func/AbsCache.h"
#include "CalibrationUtils/CalibUtil.h"

#ifdef NOVACMAKE
#include "Database/cxx/include/Table.h"
#else
#include "Database/Table.h"
#endif

#include "messagefacility/MessageLogger/MessageLogger.h"

#include "TString.h"

namespace calib
{
  //......................................................................
  AbsCache::AbsCache()
    : fGainSetting(0),
      fInitializedData(false), fInitializedMC(false)
  {
  }

  //......................................................................
  AbsCache::~AbsCache()
  {
  }

  //......................................................................
  double AbsCache::GetPECorrToGeVScale(novadaq::cnv::DetId det,
                                       int diblock,
                                       bool isData)
  {
    LoadFromVldDatabase(det, isData);

    const std::map<int, Record>& recs = isData ? fRecordsData : fRecordsMC;

    auto it = recs.find(diblock);
    if(it == recs.end()) return -1;
    const Record& rec = it->second;
    return rec.meuGeV / rec.meu;
  }

  //......................................................................
  void AbsCache::LoadFromVldDatabase(novadaq::cnv::DetId det, bool isData)
  {
    if(isData){
      if(fInitializedData) return;
      // Even if it goes wrong there's no point trying again
      fInitializedData = true;
    }
    else{
      if(fInitializedMC) return;
      fInitializedMC = true;
    }


    mf::LogInfo("AbsCache")
      << "Loading absolute energy constants for " << novadaq::cnv::DetInfo::GetName(det) << " from CSV... fReadEpochsFromCSV " << fReadEpochsFromCSV <<"\tisData\t" << isData << "\n" ;

    nova::dbi::Table tblConsts("Calibration/tables/CalibAbsConsts.xml");
    tblConsts.SetDetector(det);
    tblConsts.SetDataTypeMask(isData ? nova::dbi::kDataOnly : nova::dbi::kMCOnly);
    if(!fTag.empty()) tblConsts.SetTag(fTag);
    tblConsts.SetVerbosity(100);

    tblConsts.SetMinTSVld(1);
    tblConsts.SetMaxTSVld(100);

    bool ok = true;

    if(fUseCSVsFromUPS || !fCSVSource.empty()){
      std::string csvSource = fCSVSource;      
      if(fUseCSVsFromUPS){
        const char* ups_path = getenv("CALIBCSVS_CSV_PATH");
        assert(ups_path);
        const char* detStr = getDetString(det);
        const char* mcStr = isData ? "data" : "mc";

        if(fReadEpochsFromCSV) {
          //Wil now attempt to read the absolute calibration filename
          std::string prePattern=TString::Format("%s/%s/calib_abs_consts.%s.%s.%s", ups_path, fTag.c_str(),                 
                                                 detStr, mcStr, fTag.c_str()).Data();     
          std::string postPattern=TString::Format(".csv").Data();
          csvSource=getCSVFilenameByParsingDirectory(fRun,prePattern,postPattern);                
        }       
        else if (fUseEpochs) {
          GetEpochFromDB(det,isData);
          assert(!fEpoch.empty());
          csvSource = TString::Format("%s/%s/calib_abs_consts.%s.%s.%s.%s.csv",
                                      ups_path, fTag.c_str(), detStr,
                                      mcStr, fTag.c_str(), fEpoch.c_str()).Data();
        }
        else {
          if (!fGainSetting) 
            csvSource = TString::Format("%s/%s/calib_abs_consts.%s.%s.%s.csv",
                                        ups_path, fTag.c_str(),
                                        detStr, mcStr, fTag.c_str()).Data();
          else {
            csvSource = TString::Format("%s/%s/calib_abs_consts.%s.%s.%s.g%d.csv",
                                        ups_path, fTag.c_str(), detStr, mcStr, 
                                        fTag.c_str(), fGainSetting).Data();
          }
        }
      }
      
      mf::LogInfo("AbsCache") << "Loading absolute cache from "
                              << csvSource << std::endl;
      ok = ok && (tblConsts.LoadFromCSV(csvSource) > 0);
    }
    else{
      ok = ok && tblConsts.Load();
    }

    if(!ok){
      // No safe way to handle this
      mf::LogError("AbsCache") << "Unable to load absolute tables. Aborting"
                                 << std::endl;
      // I've definitely seen mf lose races with shutdown
      std::cerr << "Unable to load absolute tables. Aborting"
                << std::endl;
      abort();
    }

    const int meuCol    = tblConsts.GetColIndex("meu");
    const int meuErrCol = tblConsts.GetColIndex("meu_err");
    const int meuGeVCol = tblConsts.GetColIndex("meu_gev");

    const int Nconsts = tblConsts.NRow();
    for(int nconsts = 0; nconsts < Nconsts; ++nconsts){
      nova::dbi::Row* row = tblConsts.GetRow(nconsts);

      const int diblock = row->Channel();

      Record rec;

      ok = ok && row->Col(meuCol).Get(rec.meu);
      ok = ok && row->Col(meuErrCol).Get(rec.meuErr);
      ok = ok && row->Col(meuGeVCol).Get(rec.meuGeV);

      assert(ok);

      if(isData)
        fRecordsData[diblock] = rec;
      else
        fRecordsMC[diblock] = rec;
    } // end for nconsts
  }

  //......................................................................
  void AbsCache::GetEpochFromDB(int idet, bool isData)
  {
    nova::dbi::Table tbl("Calibration/tables/CalibAbsEpochs.xml");
    if (isData)
      tbl.SetDataTypeMask(nova::dbi::kDataOnly);
    else
      tbl.SetDataTypeMask(nova::dbi::kMCOnly);
    tbl.SetDetector(idet);
    tbl.SetTag(fEpochTag);
    tbl.SetMinTSVld(fRun);
    tbl.SetMaxTSVld(fRun);
    assert(tbl.Load());
    assert(tbl.NRow() == 1);


    //RJN does this table have a row for a default testbeam epoch??
    int epochIdx = tbl.GetColIndex("epoch");
    tbl.GetRow(0)->Col(epochIdx).Get(fEpoch);
  }
  


} // end namespace calib
////////////////////////////////////////////////////////////////////////