calib::Calibrator Class Reference

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-04-18/Calibrator/art/Calibrator.h"

Public Types
using	Parameters = art::ServiceTable< CalibratorParams >

Public Member Functions
	Calibrator (const Parameters &params, art::ActivityRegistry &reg)
	~Calibrator ()
void	preEvent (art::Event const &evt, art::ScheduleContext)
void	postBeginRun (art::Run const &run)
TTimeStamp	GetTimeStamp () const
rb::CellHit	MakeCellHit (const rawdata::RawDigit *rawdigit)
float	GetPE (rb::CellHit const &)
float	GetPE (const rawdata::RawDigit *rawdigit)
float	GetTNS (const rawdata::RawDigit *rawdigit, bool &goodTime, double *maxadc=0)
rb::RecoHit	MakeRecoHit (rb::CellHit const &cellhit, double w)
rb::RecoHit	MakeRecoHit (rb::CellHit const &cellhit, double *xyz)
double	GetT (rb::CellHit const &cellhit, double const &dist_to_readout)
double	GetPECorr (rb::CellHit const &cellhit, double w)
double	GetTimeRes (rb::CellHit const &cellhit)
double	GetAttenScale (rb::CellHit const &cellhit, double w)
	for PE->PECorr conversion More...
double	GetAttenScale (const calib::AttenCurve *curve, double const &minW, double const &maxW, double &w)
double	GetDriftScale (rb::CellHit const &cellhit)
	Part of the PE->PECorr conversion. More...
double	GetPECorrToGeVScale (rb::CellHit const &cellhit)
double	GetGeVToMIPScale (rb::CellHit const &cellhit)
	For GeV->MIP conversion. More...
double	GetGeVToCalorimetricScale () const
	For use by RecoBase classes. More...
double	GetShowerEnergy (TVector3 const &start, TVector3 const &stop, double const &totalGeV)
	Estimate of true shower energy, adapted from RecoJMShower. More...
bool	GetAttenCurve (int const &plane, int const &cell, bool const &is_realdata, const calib::AttenCurve *&, double &minW, double &maxW) const
double	GetTimingOffset (unsigned int const &plane, unsigned int const &cell, bool const &isData)
	Get the timing offset for a given plane, cell. Useful downstream to check calibration. More...
double	SystematicUncertaintyScale (geo::View_t const &view, unsigned short const &plane, double const &w)
calib::EFEBType	getFebType (novadaq::cnv::DetId det, const rawdata::RawDigit *dig)
std::string	GetAttenCSVPath ()
std::string	GetAbsConstsCSVPath ()
std::string	GetTimingConstsCSVPath ()
std::string	GetDriftConstsCSVPath ()
CalibratorParams	GetCalibratorParams ()

Protected Attributes
CalibratorParams	fParams

Private Member Functions
rb::RecoHit	MakeRecoHit (rb::CellHit const &cellhit, double &w, double *xyz)
	Helper function for the two public MakeRecoHit methods. More...
void	EnsureTimingCacheVldTime ()
double	GetAdcPerPE (const rawdata::RawDigit *dig)
	Helper function for GetPE() More...
float	GetPE (rb::CellHit const &, const double peakadc)
	Get PE when we have already calculated the peakadc through a call to GetTNS. More...
float	GetPE (const rawdata::RawDigit *rawdigit, const double peakadc)

Private Attributes
TTimeStamp	fCurrTimeStamp
	current time stamp More...
int	fCalibrateMode
std::string	fShapeTableFilenameFDMC
	Root file ADCShapeFitTable will load from. More...
std::string	fShapeTableFilenameFDData
std::string	fShapeTableFilenameNDMC
std::string	fShapeTableFilenameNDData
ADCShapeFitTable *	fShapeTable
ADCShapeFitTable *	fShapeTable5TB
	FEBv5 table for TestBeam (fShapeTable will be FEBv4) More...
AttenCache *	fAttenCacheData
	Data attenutation corrections. More...
std::vector< AttenCache * >	fAttenCacheMC
	MC attenutation corrections indexed by fiber brightness. More...
DriftCache *	fDriftCache
AbsCache *	fAbsCache
TimingCache *	fTimingCache
bool	fTimingCacheVldTimeSet
	Is fTimingCache set to the right time? More...
int	fCurrentRun
std::string	fTag
double	fGain
TF1 *	fXFunction
TF1 *	fXMuCFunction
TF1 *	fYFunction
art::ServiceHandle< cmap::CMap >	fCMap
art::ServiceHandle< geo::Geometry >	fGeom
art::ServiceHandle< photrans::FiberBrightness >	fFibBrightness
art::ServiceHandle< nova::dbi::RunHistoryService >	fRH
unsigned int	fStatsNumCalibrated
	Number of calibrated hits returned. More...
unsigned int	fStatsNumUncalibrated
	Number of uncalibrated hits returned. More...
unsigned int	fStatsNumAveraged
	Number of hits from uncalibrated diblocks using averaged calibrations. More...

Detailed Description

Definition at line 273 of file Calibrator.h.

Member Typedef Documentation

using calib::Calibrator::Parameters = art::ServiceTable<CalibratorParams>

Definition at line 276 of file Calibrator.h.

Constructor & Destructor Documentation

calib::Calibrator::Calibrator	(	const Parameters &	params,
		art::ActivityRegistry &	reg
	)

Definition at line 41 of file Calibrator_service.cc.

References calib::CalibratorParams::AbsConstsCSVPath, calib::CalibratorParams::AbsEpochTag, calib::CalibratorParams::CalibrationMode, calib::CalibratorParams::DriftConstsCSVPath, calib::CalibratorParams::DriftCSV, calib::CalibratorParams::DriftEpochTag, fAbsCache, fCalibrateMode, fDriftCache, fGain, cet::search_path::find_file(), fParams, fShapeTableFilenameFDData, fShapeTableFilenameFDMC, fShapeTableFilenameNDData, fShapeTableFilenameNDMC, fTag, fTimingCache, calib::CalibratorParams::Gain, fhicl::ParameterSet::get(), art::ServiceTable< T >::get_PSet(), postBeginRun(), preEvent(), calib::TimingCache::ReadEpochsFromCSV(), calib::AbsCache::ReadEpochsFromCSV(), calib::CalibratorParams::ReadEpochsFromCSV, calib::DriftCache::SetCSVFile(), calib::TimingCache::SetCSVSource(), calib::AbsCache::SetCSVSource(), calib::DriftCache::SetCSVSource(), calib::TimingCache::SetEpochTag(), calib::DriftCache::SetEpochTag(), calib::AbsCache::SetEpochTag(), calib::TimingCache::SetTag(), calib::AbsCache::SetTag(), calib::DriftCache::SetTag(), calib::TimingCache::SetUseEpochs(), calib::DriftCache::SetUseEpochs(), calib::AbsCache::SetUseEpochs(), art::ActivityRegistry::sPostBeginRun, art::ActivityRegistry::sPreProcessEvent, string, calib::CalibratorParams::Tag, calib::CalibratorParams::TimingConstsCSVPath, calib::CalibratorParams::TimingEpochTag, calib::CalibratorParams::TimingTag, calib::CalibratorParams::UseAbsEpochs, calib::TimingCache::UseCSVsFromUPS(), calib::AbsCache::UseCSVsFromUPS(), calib::DriftCache::UseCSVsFromUPS(), calib::CalibratorParams::UseCSVsFromUPS, calib::CalibratorParams::UseDriftEpochs, and calib::CalibratorParams::UseTimingEpochs.

  : fParams(params())
    ,fCurrTimeStamp(0)
    , fCalibrateMode(0)
    , fShapeTable(nullptr)
    , fShapeTable5TB(nullptr)
    , fAttenCacheData(new AttenCache(true, -1))  // is data, no bin number
    , fDriftCache(new DriftCache)
    , fAbsCache(new AbsCache)
    , fTimingCache(new TimingCache)
    , fTimingCacheVldTimeSet(false)
    , fGain(-1)
    , fXFunction(nullptr)
    , fXMuCFunction(nullptr)
    , fYFunction(nullptr)
    , fStatsNumCalibrated(0)
    , fStatsNumUncalibrated(0)
    , fStatsNumAveraged(0)
  {
    // AttenCacheMC is initialized in postBeginRun
    // when number of brightness bins is known


    // Fix up the filename by looking in the search path
    cet::search_path sp("FW_SEARCH_PATH");
    std::string calibrate_mode = fParams.CalibrationMode();
    if (calibrate_mode == "default") fCalibrateMode = 0;
    else fCalibrateMode = 1;
    fhicl::ParameterSet fPSetFiles = params.get_PSet().get<fhicl::ParameterSet>(calibrate_mode);

    sp.find_file(fPSetFiles.get< std::string >("ShapeTableFilenameFDMC"),   fShapeTableFilenameFDMC);
    sp.find_file(fPSetFiles.get< std::string >("ShapeTableFilenameFDData"), fShapeTableFilenameFDData);
    sp.find_file(fPSetFiles.get< std::string >("ShapeTableFilenameNDMC"),   fShapeTableFilenameNDMC);
    sp.find_file(fPSetFiles.get< std::string >("ShapeTableFilenameNDData"), fShapeTableFilenameNDData);

    if(fShapeTableFilenameFDMC.empty()   ||
        fShapeTableFilenameFDData.empty() ||
        fShapeTableFilenameNDMC.empty()   ||
        fShapeTableFilenameNDData.empty())
      throw cet::exception("Calibrator")
        << "Cannot find at least one shape table file: "
        << "\nFDMC:   " << fShapeTableFilenameFDMC
        << "\nFDData: " << fShapeTableFilenameFDData
        << "\nNDMC:   " << fShapeTableFilenameNDMC
        << "\nNDData: " << fShapeTableFilenameNDData
        << "\n";


    // Special fcl parameters
    fTag  = fParams.Tag();  // will be typing this a lot
    fGain = fParams.Gain(); // fGain may need to be reset 


    // Set tags and paths for Absolute, Timing, and Drift Calib
    //   Atten is set in postBeginRun
    fAbsCache->SetCSVSource(fParams.AbsConstsCSVPath());
    fAbsCache->UseCSVsFromUPS(fParams.UseCSVsFromUPS());
    fAbsCache->SetTag(fParams.Tag());
    fAbsCache->SetUseEpochs(fParams.UseAbsEpochs());
    fAbsCache->SetEpochTag(fParams.AbsEpochTag());
    fAbsCache->ReadEpochsFromCSV(fParams.ReadEpochsFromCSV());
    //
    fTimingCache->SetCSVSource(fParams.TimingConstsCSVPath());
    fTimingCache->UseCSVsFromUPS(fParams.UseCSVsFromUPS());
    fTimingCache->SetTag(fParams.TimingTag());
    fTimingCache->SetUseEpochs(fParams.UseTimingEpochs());
    fTimingCache->SetEpochTag(fParams.TimingEpochTag());
    fTimingCache->ReadEpochsFromCSV(fParams.ReadEpochsFromCSV());
    //
    fDriftCache->SetCSVSource(fParams.DriftConstsCSVPath());
    fDriftCache->SetCSVFile(fParams.DriftCSV());
    fDriftCache->SetUseEpochs(fParams.UseDriftEpochs());
    fDriftCache->SetTag(fParams.Tag());
    fDriftCache->SetEpochTag(fParams.DriftEpochTag());
    fDriftCache->UseCSVsFromUPS(fParams.UseCSVsFromUPS());


    reg.sPreProcessEvent.watch(this, &Calibrator::preEvent);
    reg.sPostBeginRun.watch(this, &Calibrator::postBeginRun);
  }

calib::Calibrator::~Calibrator

(

)

Definition at line 124 of file Calibrator_service.cc.

References plot_validation_datamc::c, fAbsCache, fAttenCacheData, fAttenCacheMC, fDriftCache, fShapeTable, fShapeTable5TB, fStatsNumAveraged, fStatsNumCalibrated, fStatsNumUncalibrated, fTimingCache, makeTrainCVSamples::int, and calib::ADCShapeFitTable::TableHitFraction().

  {
    if(fShapeTable){
      // Expecting about 95%
      mf::LogInfo("Calibrator") << "ADCShapeFitTable hit rate was "
        << int(100*fShapeTable->TableHitFraction())
        << "%";
      delete fShapeTable;
    }
    if(fShapeTable5TB){
      // Expecting about 95%
      mf::LogInfo("Calibrator") << "ADCShapeFitTable v5 (TB only) hit rate was "
                                << int(100*fShapeTable5TB->TableHitFraction())
                                << "%";
      delete fShapeTable5TB;
    }

    // NumCalibrated includes NumAveraged
    const unsigned int numRet = fStatsNumCalibrated+fStatsNumUncalibrated;
    if(numRet > 0){
      // Hopefully around 1%
      mf::LogInfo("Calibrator")
        << "Provided " << numRet << " RecoHits, of which "
        << ((1000*fStatsNumUncalibrated)/numRet)*.1 << "% were uncalibrated and "
        << ((1000*fStatsNumAveraged)/numRet)*.1 << "% were average constants.";
    }

    for(AttenCache* c: fAttenCacheMC) delete c;
    delete fAttenCacheData;
    delete fDriftCache;
    delete fAbsCache;
    delete fTimingCache;
  }

Member Function Documentation

void calib::Calibrator::EnsureTimingCacheVldTime ( )

private

Definition at line 995 of file Calibrator_service.cc.

References DEFINE_ART_SERVICE, geo::GeometryBase::DetId(), fGeom, fTimingCache, fTimingCacheVldTimeSet, rh, calib::TimingCache::SetVldTime(), nova::dbi::RunHistory::TStart(), and nova::dbi::RunHistory::TStop().

Referenced by GetTimingOffset(), and MakeCellHit().

  {
    if(fTimingCacheVldTimeSet) return;

    // use run history to improve database performance.  Apparently asking the
    // run object start and end time was not producing the same result for each
    // subrun and so the cacheing performance of the timing calibration table
    // was poor, clogging the system.
    art::ServiceHandle<nova::dbi::RunHistoryService> rh;
    fTimingCache->SetVldTime(fGeom->DetId(),
        rh->TStart(),
        rh->TStop());

    fTimingCacheVldTimeSet = true;
  }

std::string calib::Calibrator::GetAbsConstsCSVPath ( )

inline

Definition at line 386 of file Calibrator.h.

References cet::getenv().

Referenced by calib::CalibAna::endJob().

{return (fParams.UseCSVsFromUPS()) ? getenv("CALIBCSVS_CSV_PATH") : fParams.AbsConstsCSVPath();}

double calib::Calibrator::GetAdcPerPE ( const rawdata::RawDigit *  dig )

private

Helper function for GetPE()

Definition at line 413 of file Calibrator_service.cc.

References geo::GeometryBase::DetId(), fGain, fGeom, getFebType(), and calib::kFEB4p1.

Referenced by GetPE().

  {
    const int maxadc = (1<<12)-1; // 4095

    // FEB 4.1
    if(getFebType(fGeom->DetId(),dig)==calib::kFEB4p1)
       return fGain*maxadc/217000.;

    // FEB 5.2
    return fGain*maxadc/204800.;
  }

std::string calib::Calibrator::GetAttenCSVPath ( )

inline

Definition at line 385 of file Calibrator.h.

References cet::getenv().

Referenced by calib::CalibAna::endJob().

{return (fParams.UseCSVsFromUPS()) ? getenv("CALIBCSVS_CSV_PATH") : fParams.AttenCSVPath();}

bool calib::Calibrator::GetAttenCurve	(	int const &	plane,
		int const &	cell,
		bool const &	is_realdata,
		const calib::AttenCurve *&	curve,
		double &	minW,
		double &	maxW
	)		const

Given plane, cell and whether the data is real, get attenuation curve and Max w for the plane

Definition at line 843 of file Calibrator_service.cc.

References geo::PlaneGeo::Cell(), om::cerr, om::cout, geo::GeometryBase::DetId(), allTimeWatchdog::endl, fAttenCacheData, fAttenCacheMC, fFibBrightness, fGeom, geo::GeometryBase::FirstPlaneInMuonCatcher(), calib::AttenCache::ForData(), fParams, fTag, art::ServiceHandle< T, SCOPE >::get(), photrans::FiberBrightness::getBrightnessIndex(), geo::CellGeo::HalfL(), MECModelEnuComparisons::i, makeTrainCVSamples::int, calib::AttenCurve::IsCalibrated(), novadaq::cnv::kNEARDET, geo::kX, calib::CalibratorParams::MaskUncalibratedChannelsInMC, geo::GeometryBase::Plane(), and geo::PlaneGeo::View().

Referenced by calib::FindOutliers::endRun(), and GetAttenScale().

  {
    const geo::OfflineChan offline_channel(plane, cell);

    unsigned int fbBin = fFibBrightness->getBrightnessIndex(plane,cell);
    if( fbBin >= fAttenCacheMC.size() ){
      std::cerr << "Brightness bin " << fbBin << " too high.";
      std::abort();
    }

    //make sure not to mask uncalibrated mc in perfect mc
    bool maskUncalibratedChannels = fParams.MaskUncalibratedChannelsInMC();
    if(fCurrentRun < 1e4 || fCurrentRun >= 1e6){
      maskUncalibratedChannels = false;
    }

    if(fTag == "v1"   || fTag == "v2"   ||
       fTag == "v3"   || fTag == "v3.1" ||
       fTag == "v4"   || fTag == "v5"   ||
       fTag == "v5.1" || fTag == "v6"   ){
      std::cout << "Calibrator: tag is too old: " << fTag << std::endl;
      abort();
    }

    bool isNDMCX = ( fGeom->DetId() == novadaq::cnv::kNEARDET       &&
                     plane >= int(fGeom->FirstPlaneInMuonCatcher()) &&
                     (fGeom->Plane(plane)->View() == geo::kX)       );

    //make sure not to mask the ND muon catcher x planes after v6 where we have forced the fit to converge
    if(isNDMCX){
      maskUncalibratedChannels = false;
    }

    if(is_realdata)
      curve = fAttenCacheData     ->ForData(fGeom.get(), offline_channel);
    else
      curve = fAttenCacheMC[fbBin]->ForMC(fGeom.get(), offline_channel, maskUncalibratedChannels);
    if(!curve) return false;

    // allow poor calibration quality in the ND muon catcher x planes after v6
    // where we have used LOWESS to force fits to work in spite of the attenuation fit
    if(!curve->IsCalibrated() && !isNDMCX) return false;

    // Clamp given w-coordinate into the detector to avoid bad behaviour of the
    // attenuation function.
    maxW = fGeom->Plane(plane)->Cell(cell)->HalfL();
    minW = -fGeom->Plane(plane)->Cell(cell)->HalfL();

    //check to see if we're in the nd muon catcher and therefore have an asymmetric cell
    if(fGeom->DetId() == novadaq::cnv::kNEARDET &&
        plane >= int(fGeom->FirstPlaneInMuonCatcher())){
      int i = 0;
      const geo::PlaneGeo* regularPlane = fGeom->Plane(i);
      while(regularPlane->View() != fGeom->Plane(plane)->View())
        regularPlane = fGeom->Plane(++i);
      const geo::CellGeo* regularCell = regularPlane->Cell(cell);
      // Assume that the cells are aligned on the floor
      minW = -regularCell->HalfL();
      maxW = (2 * maxW) - regularCell->HalfL();
    }

    return true;
  }

double calib::Calibrator::GetAttenScale	(	rb::CellHit const &	cellhit,
		double	w
	)

for PE->PECorr conversion

Definition at line 765 of file Calibrator_service.cc.

References rb::CellHit::Cell(), calib::CalibratorParams::CellByCellCalibRandomOffset, calib::CalibratorParams::CellByCellCalibRandomOffsetHighResolution, calib::CalibratorParams::CellByCellCalibRandomOffsetSeed, calib::AttenCurve::chan, fParams, fStatsNumAveraged, GetAttenCurve(), makeTrainCVSamples::int, rawdata::RawDigit::IsRealData(), geo::OfflineChan::Plane(), rb::CellHit::Plane(), scale, and calib::CalibratorParams::UseCellByCellCalibRandomOffset.

Referenced by calib::DriftResponseCalc::FillPeCorrHits(), GetPECorr(), and calib::AttenuationFit::writeResults().

  {

    const calib::AttenCurve* curve = 0;
    double                   maxW  = 0.0;
    double                   minW  = 0.0;

    if(!GetAttenCurve(cellhit.Plane(),
          cellhit.Cell(),
          cellhit.IsRealData(),
          curve,
          minW,
          maxW)) return -1;

    if(curve->chan.Plane() >= 1000) ++fStatsNumAveraged;

    double scale = 1.0;

    //set random scaling factor for systematic studies at either the resolution of the cell or per cm in the cell around
    //a gaussian with a sigma set at the fParams.CellByCellCalibRandomOffset()
    if(fParams.UseCellByCellCalibRandomOffset()){
      if(fParams.CellByCellCalibRandomOffsetHighResolution()){
        int wInt = (int) w;
        if(wInt == 0){
          wInt = 9999;
        }
        TRandom3 *noiseGenerator = new TRandom3(fParams.CellByCellCalibRandomOffsetSeed()*(cellhit.Plane()+1)*(cellhit.Cell()+1)*wInt);
        scale = noiseGenerator->Gaus(1, fParams.CellByCellCalibRandomOffset());
        delete noiseGenerator;
      }
      else{
        TRandom3 *noiseGenerator = new TRandom3(fParams.CellByCellCalibRandomOffsetSeed()*(cellhit.Plane()+1)*(cellhit.Cell()+1));
        scale=noiseGenerator->Gaus(1, fParams.CellByCellCalibRandomOffset());
        delete noiseGenerator;
      }
    }

    return scale * GetAttenScale(curve, minW, maxW, w);
  }

double calib::Calibrator::GetAttenScale	(	const calib::AttenCurve *	curve,
		double const &	minW,
		double const &	maxW,
		double &	w
	)

Definition at line 807 of file Calibrator_service.cc.

References ana::assert(), geo::GeometryBase::DetId(), fGeom, fTag, novadaq::cnv::kFARDET, novadaq::cnv::kNDOS, novadaq::cnv::kNEARDET, novadaq::cnv::kTESTBEAM, extractScale::mean, and calib::AttenCurve::MeanPEPerCmAt().

  {

    if(w < minW) w = minW;
    if(w > maxW) w = maxW;

    const double mean = curve->MeanPEPerCmAt(w, fTag);

    if(mean <= 0) return -1;

    // The goal of this factor is to make PECorrs approximately the same size
    // as PEs. But the exact values are terrible historical accident. If we
    // decide to clean this up in future calibration versions we can do so and
    // then condition this on the tag version.

    //RJN These numbers don't actually matter they are the value the relative
    //calibration is normalised to... the absolute takes this factor out.
    double pecorrscale = 0;
    switch(fGeom->DetId()){
    case novadaq::cnv::kNDOS:    pecorrscale = 75.00; break;
    case novadaq::cnv::kNEARDET: pecorrscale = 37.51; break;
    case novadaq::cnv::kFARDET:  pecorrscale = 39.91; break;
    case novadaq::cnv::kTESTBEAM: pecorrscale = 39.91; break;
    default:
      assert(0 && "Unknown detector");
    }

    const double factor = pecorrscale/mean;

    return factor;
  }

CalibratorParams calib::Calibrator::GetCalibratorParams ( )

inline

Definition at line 389 of file Calibrator.h.

Referenced by calib::CalibAna::endJob().

{return fParams;}

std::string calib::Calibrator::GetDriftConstsCSVPath ( )

inline

Definition at line 388 of file Calibrator.h.

References cet::getenv().

Referenced by calib::CalibAna::endJob().

{return (fParams.UseCSVsFromUPS()) ? getenv("CALIBCSVS_CSV_PATH") : fParams.DriftConstsCSVPath();}

double calib::Calibrator::GetDriftScale

(

rb::CellHit const &

cellhit

)

Part of the PE->PECorr conversion.

Definition at line 913 of file Calibrator_service.cc.

References rb::CellHit::Cell(), fDriftCache, fParams, calib::DriftCache::GetFactor(), rawdata::RawDigit::IsRealData(), rb::CellHit::Plane(), and calib::CalibratorParams::UseDrift.

Referenced by GetPECorr().

  {
    if (!fParams.UseDrift()) return 1;

    // MC doesn't drift
    if(!cellhit.IsRealData()) return 1;

    return fDriftCache->GetFactor(cellhit.Plane(),
                                  cellhit.Cell());

  }

calib::EFEBType calib::Calibrator::getFebType	(	novadaq::cnv::DetId	det,
		const rawdata::RawDigit *	dig
	)

Definition at line 744 of file Calibrator_service.cc.

References ana::assert(), rawdata::RawDigit::DaqChannel(), febshutoff_auto::dcm, fCMap, daqchannelmap::DAQChannelMap::getDCM(), novadaq::cnv::kFARDET, calib::kFEB4p1, calib::kFEB5p2, novadaq::cnv::kNEARDET, novadaq::cnv::kTESTBEAM, and cmap::dataprov::CMap::Map().

Referenced by GetAdcPerPE(), GetTimeRes(), and GetTNS().

  {
    switch(det) {
    case novadaq::cnv::kFARDET: return kFEB4p1;
    case novadaq::cnv::kNEARDET: return kFEB5p2;
    case novadaq::cnv::kTESTBEAM: 
      {
        const uint32_t dcm = fCMap->Map()->getDCM(dig->DaqChannel());
        //RJN magic number panic this magic number came from 
        //MergeTBDaqCollections_module.cc 
        if(dcm==3)
           return kFEB5p2;
        return kFEB4p1;

      }
    default:
      assert (!"The default case of getFebType switch was reached.");
      return kFEB4p1;
    }       
  }

double calib::Calibrator::GetGeVToCalorimetricScale

(

)

const

For use by RecoBase classes.

Conversion from TotalGeV to CalorimetricEnergy. Takes account of dead material and threshold effects in an averaged fashion. Makes no sense to apply to individual hits. You probably don't want to use this, you probably want to look at functions of your RecoBase object.

Definition at line 946 of file Calibrator_service.cc.

Referenced by rb::Cluster::CalorimetricEnergy().

  {
    // From Kanika's study: docdb 11528
    //
    // Could vary by detector or calibration version etc. We have all that
    // information available here. If it gets complicated enough may need to
    // come from database. For now it's a single number, and there's a
    // reasonable chance it might never need to change.
    return 1.78;
  }

double calib::Calibrator::GetGeVToMIPScale

(

rb::CellHit const &

cellhit

)

For GeV->MIP conversion.

Definition at line 926 of file Calibrator_service.cc.

Referenced by MakeRecoHit().

  {
    // MIPs for one GeV times one cell in z in NOvA scintillator
    return 94.62;
  }

float calib::Calibrator::GetPE

(

rb::CellHit const &

ch

)

Definition at line 407 of file Calibrator_service.cc.

Referenced by calib::TestParticleCorrections::analyze(), GetPE(), and MakeCellHit().

  {
    return this->GetPE(&ch);
  }

float calib::Calibrator::GetPE

(

const rawdata::RawDigit *

rawdigit

)

Definition at line 432 of file Calibrator_service.cc.

References GetAdcPerPE(), and GetTNS().

  {
    // PE comes from the value determined as a side-effect of the timing fit,
    // the best-fit height of the curve when t0 is at its best value.

    // Doesn't matter whether or not timing fit suceeds, good fallbacks are in
    // place.
    bool junk;
    double peakadc;
    GetTNS(dig, junk, &peakadc);

    return peakadc/GetAdcPerPE(dig);
  }

float calib::Calibrator::GetPE ( rb::CellHit const &  ch, const double  peakadc  )

private

Get PE when we have already calculated the peakadc through a call to GetTNS.

Definition at line 401 of file Calibrator_service.cc.

References GetPE().

  {
    return this->GetPE(&ch, peakadc);
  }

float calib::Calibrator::GetPE ( const rawdata::RawDigit *  rawdigit, const double  peakadc  )

private

Definition at line 426 of file Calibrator_service.cc.

References GetAdcPerPE().

  {
    return peakadc/GetAdcPerPE(dig);
  }

double calib::Calibrator::GetPECorr	(	rb::CellHit const &	cellhit,
		double	w
	)

Definition at line 692 of file Calibrator_service.cc.

References GetAttenScale(), GetDriftScale(), rb::CellHit::PE(), rb::CellHit::Plane(), scale, SystematicUncertaintyScale(), rb::CellHit::View(), and w.

Referenced by calib::MuondEdx::getPECorr(), calib::DetRespDrift::getPECorr(), calib::MuonTrackHits::getPECorr(), calib::MuondEdxAna::getPECorr(), calib::CalibAna::GetPECorr(), MakeRecoHit(), jmshower::JMTrackMerge::produce(), lem::GenFromLib::readNext(), and slid::NuEEnergyAlg::VertexEnergy().

  {
    const double attenFactor = GetAttenScale(cellhit, w);
    if(attenFactor <= 0) return -1;

    const double driftFactor = GetDriftScale(cellhit);
    if(driftFactor <= 0) return -1;

    // get any scale applied for systematic uncertainties as set by the
    // input parameters
    auto scale = this->SystematicUncertaintyScale(cellhit.View(), cellhit.Plane(), w);

    return cellhit.PE() * attenFactor * driftFactor * scale;
  }

double calib::Calibrator::GetPECorrToGeVScale

(

rb::CellHit const &

cellhit

)

Definition at line 933 of file Calibrator_service.cc.

References rb::CellHit::Cell(), geo::GeometryBase::DetId(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), fAbsCache, fCMap, fGeom, daqchannelmap::DAQChannelMap::getDiBlock(), calib::AbsCache::GetPECorrToGeVScale(), rawdata::RawDigit::IsRealData(), cmap::dataprov::CMap::Map(), and rb::CellHit::Plane().

Referenced by calib::MuonTrackHits::getPECorrToGeV(), calib::MuondEdxAna::getPECorrToGeV(), calib::CalibAna::GetPECorrToMeV(), and MakeRecoHit().

  {
    const daqchannelmap::lchan lchan = fCMap->Map()->encodeLChan(fGeom->DetId(),
        chit.Plane(),
        chit.Cell());
    const daqchannelmap::dchan dchan = fCMap->Map()->encodeDChan(lchan);

    return fAbsCache->GetPECorrToGeVScale(fGeom->DetId(),
        fCMap->Map()->getDiBlock(dchan),
        chit.IsRealData());
  }

double calib::Calibrator::GetShowerEnergy	(	TVector3 const &	start,
		TVector3 const &	stop,
		double const &	totalGeV
	)

Estimate of true shower energy, adapted from RecoJMShower.

Accounts for dead material and threshold effects that can't be done at the individual cell level. Pass in the TVectors and energy explicitly rather than the rb::Track object to avoid a circular dependency with RecoBase

Definition at line 958 of file Calibrator_service.cc.

  {//now only for electron
    double ecor =  5.66050e-01;//for dead material correction

    double avgx = (start.X()+stop.X())/2.;
    double avgy = (start.Y()+stop.Y())/2.;
    double poscor = 1.0+7.00279e-05*avgx+6.91714e-05*avgy;//for position correction

    return totalGeV/(ecor*poscor);
  }

double calib::Calibrator::GetT	(	rb::CellHit const &	cellhit,
		double const &	dist_to_readout
	)

Definition at line 638 of file Calibrator_service.cc.

References rb::CellHit::TNS().

Referenced by MakeRecoHit().

                                          {
    // This needs to be calibrated and put in a DB table
    Double_t speedOfFiberTransport = 15.3; // cm/ns, "first principles" calib.
    // Differs from c/n due to zigzag
    // paths down fiber.  But, this
    // value may be way off (10%? 30%?).
    return (cellhit.TNS() - (dist_to_readout / speedOfFiberTransport) );
  }

double calib::Calibrator::GetTimeRes

(

rb::CellHit const &

cellhit

)

Definition at line 709 of file Calibrator_service.cc.

References geo::GeometryBase::DetId(), fGeom, getFebType(), rb::CellHit::GoodTiming(), calib::kFEB4p1, rb::CellHit::PE(), cet::pow(), and HandyFuncs::stdev().

Referenced by slicer::S4DParamCalc::analyze(), zcl::FmmTrackerAna::analyze(), zcl::FmmTrackerValidation::analyze(), slicer::SlicerAna::analyze(), tf::TimingFitAlg::HoughFit(), and slicer::Slicer4D::produce().

  {
    double pe = cellhit.PE();
    //This is a fit for the timing resolution as a function of PE.  
    //For FD single point data this is derived by plotting the time difference between 
    //pairs of hits within a DCM on a cosmic track.  More information is in docdb-11571

    double stdev = 144.0; //simple assumption of 500ns/sqrt(12)
    //RJN more FEB4 vs FEB5

    if(getFebType(fGeom->DetId(),&cellhit)==calib::kFEB4p1) {
       //Far detector style electronics
       if (cellhit.GoodTiming()){
          stdev = 231594.0/(2267.16+pow(pe,2.01011)) + 9.55689;   //2014-10-13 fit, multipoint readout from data, docdb-12122, with 460 ns rise time
       }
       else {
          stdev = 848357.0/(5734.75+pow(pe,2.20060)) + 142.221; //2014-06-13 fit, from data
      }
    }
    else  {
       //Near detector style electronics
      if (cellhit.GoodTiming()){
        stdev = 2229.53/(77.0043+pow(pe,1.22743)) + 4.89355; //2014-09-15 fit from data with 140 ns rise time, 4.5 us fall time
      }
      //TODO:  ND single point timing resolution needs to be updated.  Currently simulation and data are all in
      //multipoint.  For now take the FD singlpe point resolution and dived by 4 since the sampling is 4 times as fast
      else {
        stdev = 6136470.0/(185518.0+pow(pe,2.92360)) + 31.6071; //2014-09-15 singe point fit of data
      }
    }

    return stdev;

  }

TTimeStamp calib::Calibrator::GetTimeStamp ( ) const

inline

Definition at line 285 of file Calibrator.h.

References getBrightness::cell, fillBadChanDBTables::det, NDAPDHVSetting::plane, febshutoff_auto::start, POTSpillRate::view, and w.

{ return fCurrTimeStamp; }

std::string calib::Calibrator::GetTimingConstsCSVPath ( )

inline

Definition at line 387 of file Calibrator.h.

References cet::getenv().

Referenced by calib::CalibAna::endJob().

{return (fParams.UseCSVsFromUPS()) ? getenv("CALIBCSVS_CSV_PATH") : fParams.TimingConstsCSVPath();}

double calib::Calibrator::GetTimingOffset	(	unsigned int const &	plane,
		unsigned int const &	cell,
		bool const &	isData
	)

Get the timing offset for a given plane, cell. Useful downstream to check calibration.

Definition at line 972 of file Calibrator_service.cc.

References getBrightness::cell, geo::GeometryBase::DetId(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), EnsureTimingCacheVldTime(), fCMap, fCurrTimeStamp, fGeom, fParams, fTimingCache, daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), calib::TimingCache::GetOffset(), cmap::dataprov::CMap::Map(), PandAna.reco_validation.add_data::offset, NDAPDHVSetting::plane, and calib::CalibratorParams::UseTimingOffsets.

Referenced by calib::TimingCalibration::produce().

  {
    const daqchannelmap::lchan lchan = fCMap->Map()->encodeLChan(fGeom->DetId(),
        plane,
        cell);
    const daqchannelmap::dchan dchan = fCMap->Map()->encodeDChan(lchan);

    double offset = 0.0;
    //check if timing offsets should be added in, 
    if (fParams.UseTimingOffsets()){
      EnsureTimingCacheVldTime();
      offset = fTimingCache->GetOffset(fCMap->Map()->getDCM(dchan),
          fCMap->Map()->getDiBlock(dchan),
          fCurrTimeStamp.GetSec(),
          isData);
    }

    return offset;
  }

float calib::Calibrator::GetTNS	(	const rawdata::RawDigit *	rawdigit,
		bool &	goodTime,
		double *	maxadc = 0
	)

Parameters

goodTime	Did the timing fit go well?
maxadc	Internal hook for use of GetPE

Definition at line 447 of file Calibrator_service.cc.

References rawdata::RawDigit::ADC(), ana::assert(), om::cout, fillBadChanDBTables::det, geo::GeometryBase::DetId(), allTimeWatchdog::endl, fCalibrateMode, fGeom, plot_validation_datamc::fname, fShapeTable, fShapeTable5TB, fShapeTableFilenameFDData, fShapeTableFilenameFDMC, fShapeTableFilenameNDData, fShapeTableFilenameNDMC, getFebType(), daqdataformats::NanoSliceVersionConvention::getNPretriggeredSamples(), daqdataformats::NanoSliceVersionConvention::getNSamples(), rawdata::RawDigit::IsMC(), calib::kFEB4p1, calib::kFEB5p2, novadaq::cnv::kTESTBEAM, rawdata::RawDigit::NADC(), string, rawdata::RawDigit::TDC(), calib::ADCShapeFitTable::TNS(), and rawdata::RawDigit::Version().

Referenced by GetPE(), MakeCellHit(), and comi::Cana::produce().

  {
    // Allows the rest of the function to assume maxadc is writeable
    double junk;
    if(!maxadc) maxadc = &junk;

    const int det = fGeom->DetId();

    if(dig->IsMC() &&
       dig->Version() == 0 &&
       dig->NADC() == 3){
      std::cout << "Calibrator: Unable to handle old-style RawDigit" << std::endl;
      abort();
    }

    static daqdataformats::NanoSliceVersionConvention conv;

    const unsigned int nSamples = conv.getNSamples(dig->Version());
    assert(dig->NADC() == nSamples);


    const double peakToBaselineOffset = getFebType(fGeom->DetId(),dig)==calib::kFEB4p1 ? 96 : 24;

    
    const double tns0 = (dig->TDC()-peakToBaselineOffset)*15.625;

    // Version zero means this is a single DCS point
    if(dig->Version() == 0){
      goodTime = false;
      *maxadc = dig->ADC(); // Make sure this gets set reasonably
      // Simply convert the time stored in TDC to nanoseconds
      return tns0;
    }

    // Otherwise we can do the timing fit
    const unsigned int nPretrig = conv.getNPretriggeredSamples(dig->Version());

    // Need to have enough points to be able to see back to the baseline
    assert(nPretrig >= 3);
    // Also need enough points to see up to the peak
    assert(nSamples >= 4);

    
    // Create TB lookup tables (need 2 - one for each FEB version)
    if (det == novadaq::cnv::kTESTBEAM){
      if (!fShapeTable || !fShapeTable5TB){
        std::string fname4;
        std::string fname5;
        if(dig->IsMC()){
          fname4 = fShapeTableFilenameFDMC;
          fname5 = fShapeTableFilenameNDMC;
        }
        else{
          fname4 = fShapeTableFilenameFDData;
          fname5 = fShapeTableFilenameNDData;
        }
        fShapeTable = new ADCShapeFitTable(fname4, false, dig->IsMC(), fCalibrateMode);
        fShapeTable5TB = new ADCShapeFitTable(fname5, true, dig->IsMC(), fCalibrateMode);
      }
    }

    //RJN we will need to change this switch from detector type to FEB type
    //may need to make bespoke tables for testbeam
    // Create lookup table if required
    if(!fShapeTable){
      const bool isFEB5p2 = getFebType(fGeom->DetId(),dig)==calib::kFEB5p2;
      std::string fname;
      if(isFEB5p2){
        if(dig->IsMC()){
          fname = fShapeTableFilenameNDMC;
        }
        else{
          fname = fShapeTableFilenameNDData;
        }
      }
      else{
        if(dig->IsMC()){
          fname = fShapeTableFilenameFDMC;
        }
        else{
          fname = fShapeTableFilenameFDData;
        }
      }
      fShapeTable = new ADCShapeFitTable(fname, isFEB5p2, dig->IsMC(), fCalibrateMode);
    }

    // Figure out which sample is the baseline sample (ie the one combined
    // with the peak in the DCS calculation).
    const int baseIdx = nPretrig - 3;
    double tns = -1;
    // ShapeTable expects points in order, baseline subtracted
    if ( det == novadaq::cnv::kTESTBEAM && getFebType(fGeom->DetId(),dig)==calib::kFEB5p2 ){
      tns = fShapeTable5TB->TNS(tns0,
                                dig->ADC(baseIdx + 1) - dig->ADC(baseIdx),
                                dig->ADC(baseIdx + 2) - dig->ADC(baseIdx),
                                dig->ADC(baseIdx + 3) - dig->ADC(baseIdx),
                                *maxadc,
                                goodTime,
                                junk);
    }
    else {
      tns = fShapeTable->TNS(tns0,
                             dig->ADC(baseIdx + 1) - dig->ADC(baseIdx),
                             dig->ADC(baseIdx + 2) - dig->ADC(baseIdx),
                             dig->ADC(baseIdx + 3) - dig->ADC(baseIdx),
                             *maxadc,
                             goodTime,
                             junk);
    }
    return tns;
  }

rb::CellHit calib::Calibrator::MakeCellHit

(

const rawdata::RawDigit *

rawdigit

)

Definition at line 354 of file Calibrator_service.cc.

References rawdata::RawDigit::ADC(), rb::CellHit::Cell(), geo::GeometryBase::DetId(), daqchannelmap::DAQChannelMap::encodeDChan(), daqchannelmap::DAQChannelMap::encodeLChan(), EnsureTimingCacheVldTime(), rawdata::RawDigit::fADC, fCMap, fCurrTimeStamp, fGeom, fParams, fTimingCache, cmap::dataprov::CMap::GetCell(), daqchannelmap::DAQChannelMap::getDCM(), daqchannelmap::DAQChannelMap::getDiBlock(), calib::TimingCache::GetOffset(), GetPE(), cmap::dataprov::CMap::GetPlane(), GetTNS(), rawdata::RawDigit::IsRealData(), calib::CalibratorParams::MakeSinglePointCellHits, cmap::dataprov::CMap::Map(), PandAna.reco_validation.add_data::offset, rb::CellHit::Plane(), geo::GeometryBase::Plane(), rawdata::RawDigit::SetADC(), rb::CellHit::SetCell(), rb::CellHit::SetPE(), rb::CellHit::SetPlane(), rb::CellHit::SetTNS(), rawdata::RawDigit::SetVersion(), rb::CellHit::SetView(), calib::CalibratorParams::UseTimingOffsets, and rawdata::RawDigit::Version().

Referenced by bsf::BremShowerFilter::filter(), MergeDaqCollections::MergeDaqCollections::produce(), calhit::CalHit::produce(), murem::MuonRemove::produce(), and lem::GenFromLib::readNext().

  {
    // Copy of the hit that's modified to look like single-point data
    rawdata::RawDigit digSingle = *rawdigit;
    if(fParams.MakeSinglePointCellHits() && rawdigit->Version() != 0){
      digSingle.SetVersion(0);
      digSingle.fADC.clear();
      digSingle.SetADC(0, rawdigit->ADC());

      // Rest of function uses modified hit in place of argument provided
      rawdigit = &digSingle;
    }

    rb::CellHit chit(*rawdigit);

    // new info
    chit.SetCell  (fCMap->GetCell(rawdigit));
    chit.SetPlane (fCMap->GetPlane(rawdigit));
    chit.SetView  (fGeom->Plane(chit.Plane())->View());
    bool goodTime;
    double peakadc;
    const double tns = GetTNS(rawdigit, goodTime, &peakadc);

    const daqchannelmap::lchan lchan = fCMap->Map()->encodeLChan(fGeom->DetId(),
        chit.Plane(),
        chit.Cell());
    const daqchannelmap::dchan dchan = fCMap->Map()->encodeDChan(lchan);

    //check if timing offsets should be added in, 
    if (fParams.UseTimingOffsets()){
      EnsureTimingCacheVldTime();
      const double offset = fTimingCache->GetOffset(fCMap->Map()->getDCM(dchan),
          fCMap->Map()->getDiBlock(dchan),
          fCurrTimeStamp.GetSec(),
          chit.IsRealData());
      chit.SetTNS(tns+offset, goodTime);
    }
    else{
      chit.SetTNS(tns, goodTime);
    }

    chit.SetPE(GetPE(rawdigit, peakadc));

    return chit;
  }

rb::RecoHit calib::Calibrator::MakeRecoHit	(	rb::CellHit const &	cellhit,
		double	w
	)

Definition at line 568 of file Calibrator_service.cc.

References calib::GetXYZD(), rb::CellHit::OfflineChan(), and w.

Referenced by calib::TestParticleCorrections::analyze(), mcchk::MonopoleAna::analyze(), calib::AssessCalib::analyze(), zcl::FmmTrackerAna::analyze(), zcl::FmmTrackerValidation::analyze(), rockmuon::NDRockMuon::analyze(), remid::ReMIdDedxRock::analyze(), remid::ReMIdDedxFD::analyze(), remid::ReMIdDedxStudies::analyze(), bpfit::BPFTmvaTrainer::analyze(), bpfit::BreakPointProtonAna::analyze(), ncs::Xeff::analyze(), ncs::ROCKMRE::analyze(), slid::LIDTraining::analyze(), ncs::NCAna::analyze(), fuzz::ViewMatchAlg::CalcEnergyProfile(), nerd::ViewMatchAlg::CalcEnergyProfile(), slid::NuEEnergyAlg::CellEnergy(), bpfit::dEdxCalculator::computeDEDX(), caf::FillHadClustVars(), caf::FillSliceVars(), jmshower::RecoJMShower::GetRVPStats(), slid::NuEEnergyAlg::HadronicDepEnergy(), rvp::RecVarPID::MakeRecoHit(), xnue::XnuePID::MakeRecoHit(), ncs::GenieTruth::MakeRecoHit(), ncs::Xbeam::MakeRecoHit(), ncs::Xeff::MakeRecoHit(), ncs::ROCKMRE::MakeRecoHit(), ncs::NCAna::MakeRecoHit(), MakeRecoHit(), nuesand::FillNueSandbox::produce(), lem::Preselection::produce(), presel::NuePresel::produce(), zcl::SMMCluster::produce(), zcl::FMMTracker::produce(), jmshower::NueSel::produce(), jmshower::NueSelLID::produce(), bpfit::BPFEnergyEstimator::produce(), remid::RecoMuon::produce(), bpfit::BPFEnergyEstimatorOnly::produce(), rb::Cluster::RecoHit(), jmshower::RecoJMShower::RecoShowers(), lem::LEMSummarizer::SliceToLEMInput(), rb::Cluster::TotalGeVFastClusterOnly(), and slid::NuEEnergyAlg::VertexEnergy().

  {
    Double_t xyzd[4];
    GetXYZD(cellhit.OfflineChan(), w, xyzd);
    return MakeRecoHit(cellhit, w, xyzd);
  }

rb::RecoHit calib::Calibrator::MakeRecoHit	(	rb::CellHit const &	cellhit,
		double *	xyz
	)

Definition at line 577 of file Calibrator_service.cc.

References geo::kX, MakeRecoHit(), rb::CellHit::View(), and w.

  {
    double w = xyz[0];
    if(cellhit.View() == geo::kX) w = xyz[1];

    return MakeRecoHit(cellhit, w, xyz);
  }

rb::RecoHit calib::Calibrator::MakeRecoHit ( rb::CellHit const &  cellhit, double &  w, double *  xyz  )

private

Helper function for the two public MakeRecoHit methods.

Definition at line 588 of file Calibrator_service.cc.

References ana::assert(), fStatsNumCalibrated, fStatsNumUncalibrated, GetGeVToMIPScale(), GetPECorr(), GetPECorrToGeVScale(), GetT(), MF_LOG_ERROR, rb::RecoHit::SetGeV(), rb::RecoHit::SetMIP(), rb::RecoHit::SetPECorr(), rb::RecoHit::SetT(), rb::RecoHit::SetX(), rb::RecoHit::SetY(), and rb::RecoHit::SetZ().

  {
    rb::RecoHit rhit;

    rhit.SetX(xyz[0]);
    rhit.SetY(xyz[1]);
    rhit.SetZ(xyz[2]);

    rhit.SetT(GetT(chit, xyz[3]));

    // Set hit up uncalibrated in case we don't fill it below
    rhit.SetPECorr(-1);
    rhit.SetMIP   (-1);
    rhit.SetGeV   (-1);

    if(std::isnan(w)){
      MF_LOG_ERROR("Calibrator")
        << "W position provided is NaN. This hit will be uncalibrated.";
    }

    const double peCorr = std::isnan(w) ? -1 : GetPECorr(chit, w);

    assert(!std::isnan(peCorr));
    assert(!std::isinf(peCorr));

    if(peCorr > 0){
      rhit.SetPECorr(peCorr);
      const double gevPerPECorr = GetPECorrToGeVScale(chit);
      if(gevPerPECorr > 0){
        const double gev = peCorr * gevPerPECorr;
        rhit.SetGeV(gev);
        rhit.SetMIP(gev * GetGeVToMIPScale(chit));
        ++fStatsNumCalibrated;
      }
      else{
        // Uncalibrated
        rhit.SetPECorr(-1);
        ++fStatsNumUncalibrated;
      }
    }
    else{
      ++fStatsNumUncalibrated;
    }

    return rhit;
  }

void calib::Calibrator::postBeginRun

(

art::Run const &

run

)

Definition at line 175 of file Calibrator_service.cc.

References ana::assert(), calib::CalibratorParams::AttenCSVPath, calib::CalibratorParams::AttenEpochTag, b, om::cerr, nova::dbi::RunHistory::DetGainSetting(), geo::GeometryBase::DetId(), allTimeWatchdog::endl, fAbsCache, fAttenCacheData, fAttenCacheMC, fCurrentRun, fDriftCache, fFibBrightness, fGain, fGeom, fParams, fTag, fTimingCache, fTimingCacheVldTimeSet, fXFunction, fXMuCFunction, fYFunction, calib::AbsCache::GainSetting(), calib::AttenCache::GainSetting(), MECModelEnuComparisons::i, novadaq::cnv::kNEARDET, photrans::FiberBrightness::NumberBrightnessBins(), calib::AttenCache::ReadEpochsFromCSV(), calib::CalibratorParams::ReadEpochsFromCSV, calib::AbsCache::Reinit(), calib::AttenCache::Reinit(), rh, art::DataViewImpl::run(), runNovaSAM::runNum, nova::dbi::RunHistory::RunNumber(), calib::AttenCache::SetCSVSource(), calib::TimingCache::SetEpoch(), calib::AbsCache::SetEpoch(), calib::AttenCache::SetEpoch(), calib::AttenCache::SetEpochTag(), calib::AbsCache::SetGainSetting(), calib::AttenCache::SetGainSetting(), calib::DriftCache::SetRun(), calib::TimingCache::SetRun(), calib::AbsCache::SetRun(), calib::AttenCache::SetRun(), calib::AttenCache::SetTag(), calib::AttenCache::SetUseEpochs(), string, calib::CalibratorParams::UseAttenEpochs, calib::AttenCache::UseCSVsFromUPS(), calib::CalibratorParams::UseCSVsFromUPS, calib::CalibratorParams::UseDrift, calib::TimingCache::UseEpochs(), calib::AbsCache::UseEpochs(), calib::AttenCache::UseEpochs(), calib::CalibratorParams::UseGainSetting4Abs, calib::CalibratorParams::UseGainSetting4Atten, calib::CalibratorParams::UseXFunction, calib::CalibratorParams::UseYFunction, calib::CalibratorParams::Xg100FunctionForm, calib::CalibratorParams::Xg100FunctionParams, calib::CalibratorParams::Xg140FunctionForm, calib::CalibratorParams::Xg140FunctionParams, calib::CalibratorParams::XMuCg100FunctionForm, calib::CalibratorParams::XMuCg100FunctionParams, calib::CalibratorParams::Yg100FunctionForm, calib::CalibratorParams::Yg100FunctionParams, calib::CalibratorParams::Yg140FunctionForm, and calib::CalibratorParams::Yg140FunctionParams.

Referenced by Calibrator().

  {
    fAbsCache->Reinit();

    // New run. We need to update the TimingCache VldTime. But don't do it
    // until someone actually accesses TimingCache, just make a note. Avoids
    // accessing RunHistory when we don't have to, especially in case of
    // generation jobs where it will actually fail.
    fTimingCacheVldTimeSet = false;
    fCurrentRun=run.run();

    if(fFibBrightness->NumberBrightnessBins()>1)
      mf::LogInfo("Calibrator") << "Cacheing MC attenuation correction for each of " 
                                << fFibBrightness->NumberBrightnessBins() 
                                << " fiber brightness bins.";
    
    fAttenCacheData->SetTag         ( fTag                     );
    fAttenCacheData->SetUseEpochs   ( fParams.UseAttenEpochs() );
    fAttenCacheData->SetEpochTag    ( fParams.AttenEpochTag()  );
    fAttenCacheData->UseCSVsFromUPS ( fParams.UseCSVsFromUPS() );
    fAttenCacheData->SetCSVSource   ( fParams.AttenCSVPath()   );
    if( fAttenCacheData->UseEpochs() ) {
      fAttenCacheData->SetRun(fCurrentRun);
      fAttenCacheData->SetEpoch(" "); 
    }
    //RJN addition to avoid epoch reading
    fAttenCacheData->ReadEpochsFromCSV( fParams.ReadEpochsFromCSV() );
    fAttenCacheData->Reinit();

    // Initialize MC AttenCaches, indexed by
    //  fiber brightness if brightness is modeled.
    bool AttenCacheMCEmpty = fAttenCacheMC.empty();
    for(size_t b=0; b<fFibBrightness->NumberBrightnessBins(); b++){
        
      // Initialize AttenCaches only in the first postBeginRun...
      //  done in postBeginRun so number of brightness bins known
      if(AttenCacheMCEmpty){

        // when brightness is not modelled, let AttenCache know with -1
        if( fFibBrightness->NumberBrightnessBins() <= 1 )
          fAttenCacheMC.emplace_back(new AttenCache(false, -1)); // not data, no bin number
        else
          fAttenCacheMC.emplace_back(new AttenCache(false, int(b))); // not data, bin b
        
        fAttenCacheMC[b]->SetTag         ( fTag                     );
        fAttenCacheMC[b]->SetUseEpochs   ( fParams.UseAttenEpochs() );
        fAttenCacheMC[b]->SetEpochTag    ( fParams.AttenEpochTag()  );
        fAttenCacheMC[b]->UseCSVsFromUPS ( fParams.UseCSVsFromUPS() );
        fAttenCacheMC[b]->SetCSVSource   ( fParams.AttenCSVPath()   );  
        fAttenCacheMC[b]->ReadEpochsFromCSV( fParams.ReadEpochsFromCSV() );
      }
      
      // ...but do reinit and set run/epoch every run
      if( fAttenCacheMC[b]->UseEpochs() ) {
        fAttenCacheMC[b]->SetRun(fCurrentRun);
        fAttenCacheMC[b]->SetEpoch(" "); 
      }
      fAttenCacheMC[b]->Reinit();
    } // every bin


    if (fParams.UseDrift()) {
      // using RunHistory to set validity time range for drift correction
      art::ServiceHandle<nova::dbi::RunHistoryService> rh;
      int runNum = rh->RunNumber();
      // load from either CSV or DB
      fDriftCache->SetRun(fGeom->DetId(),runNum);
    }


    if (fAbsCache->UseEpochs()) {
      fAbsCache->SetRun(fCurrentRun);
      fAbsCache->SetEpoch(" ");      
    }

    if (fTimingCache->UseEpochs()) {
      fTimingCache->SetRun(fCurrentRun);
      fTimingCache->SetEpoch(" ");
    }

    if (fParams.UseGainSetting4Atten() || fParams.UseGainSetting4Abs()) {
      art::ServiceHandle<nova::dbi::RunHistoryService> rh;      
      int gainSetting = rh->DetGainSetting();
      if (fParams.UseGainSetting4Abs() && 
          (gainSetting != fAbsCache->GainSetting())) {
        fAbsCache->Reinit();
        fAbsCache->SetGainSetting(gainSetting);
      }
      // reinit MC cahces
      for(size_t b=0; b<fAttenCacheMC.size(); b++){
        if (fParams.UseGainSetting4Atten() &&
            (gainSetting != fAttenCacheMC[b]->GainSetting())) {
          fAttenCacheMC[b]->Reinit();
          fAttenCacheMC[b]->SetGainSetting(gainSetting);
        }
      } // for each brightness bin

      // reinit data cache
      if (fParams.UseGainSetting4Atten() &&
          (gainSetting != fAttenCacheData->GainSetting())) {
        fAttenCacheData->Reinit();
        fAttenCacheData->SetGainSetting(gainSetting);
      }
    }


    art::ServiceHandle<nova::dbi::RunHistoryService> rh;
    if(fGain < 0) // Signal to look in the DB
      fGain = rh->DetGainSetting();

    if(fGain <= 0) { // something's not right
      std::cerr << "Failed to get gain from DB.  Aborting" << std::endl;
      abort();
    }


    // Get the right functional form based off of gain
    std::string         XFunctionForm,   XMuCFunctionForm,   YFunctionForm;
    std::vector<double> XFunctionParams, XMuCFunctionParams, YFunctionParams;
    if( fGain==100 ){
      XFunctionForm   = fParams.Xg100FunctionForm();
      XFunctionParams = fParams.Xg100FunctionParams();
      YFunctionForm   = fParams.Yg100FunctionForm();
      YFunctionParams = fParams.Yg100FunctionParams();
    }
    else if( fGain==140 ){ 
      XFunctionForm   = fParams.Xg140FunctionForm();
      XFunctionParams = fParams.Xg140FunctionParams();
      YFunctionForm   = fParams.Yg140FunctionForm();
      YFunctionParams = fParams.Yg140FunctionParams();       
    }
    else if( fParams.UseXFunction() || fParams.UseYFunction() ){
      std::cerr << "Unexpected gain, no shape functions, aborting" << std::endl;
      abort();
    }
    if(fGeom->DetId() == novadaq::cnv::kNEARDET){
      if( fGain==100 ){
        XMuCFunctionForm   = fParams.XMuCg100FunctionForm();
        XMuCFunctionParams = fParams.XMuCg100FunctionParams();
      } else {
        std::cerr << "Unexpected gain in ND, no shape functions, aborting" << std::endl;
        abort();
      }
    }

    // Initialize PECorr shift functions if configured
    if (fParams.UseXFunction()){
      fXFunction = new TF1("x_function", XFunctionForm.c_str(), -900, 900);
      assert(fXFunction);
      for (size_t i = 0; i < XFunctionParams.size(); ++i){
        fXFunction->SetParameter(i, XFunctionParams[i]);
      }

      // shift Muon Catcher separately if nonempty MuC function string
      if(XMuCFunctionForm!=""){
        fXMuCFunction = new TF1("x_mc_function", XMuCFunctionForm.c_str(), -900, 900);
        assert(fXMuCFunction);
        for (size_t i = 0; i < XMuCFunctionParams.size(); ++i){
          fXMuCFunction->SetParameter(i, XMuCFunctionParams[i]);
        }
      }

    }
    if (fParams.UseYFunction()){
      fYFunction = new TF1("y_function", YFunctionForm.c_str(), -900, 900);
      assert(fYFunction);
      for (size_t i = 0; i < YFunctionParams.size(); ++i){
        fYFunction->SetParameter(i, YFunctionParams[i]);
      }
    }

  } // end postBeginRun

void calib::Calibrator::preEvent	(	art::Event const &	evt,
		art::ScheduleContext
	)

Definition at line 159 of file Calibrator_service.cc.

References fCurrTimeStamp, art::DataViewImpl::time(), and art::Timestamp::value().

Referenced by Calibrator().

  {
    // use the art::Timestamp to create the fCurrTrimeStamp value
    unsigned long long int tsval = evt.time().value();

    // taking it apart
    // the masking isn't strictly necessary *if* "long" is truly 32bits
    // but this can vary w/ compiler/platform
    const unsigned long int mask32 = 0xFFFFFFFFUL;
    time_t lup = ( tsval >> 32 ) & mask32;
    int llo = tsval & mask32;
    TTimeStamp tts(lup, llo);
    fCurrTimeStamp = tts;
  }

double calib::Calibrator::SystematicUncertaintyScale	(	geo::View_t const &	view,
		unsigned short const &	plane,
		double const &	w
	)

Method to determine the systematic uncertainty scale factor to apply when those options are turned on. This function should only be called by code wishing to check the behavior of the systematic scaling, it is not useful outside of the Calibrator service otherwise

Definition at line 649 of file Calibrator_service.cc.

References geo::GeometryBase::DetId(), calib::CalibratorParams::DriftGradient, calib::CalibratorParams::DriftReference, nova::dbi::RunHistory::Duration(), fGeom, geo::GeometryBase::FirstPlaneInMuonCatcher(), fParams, fXFunction, fXMuCFunction, fYFunction, makeTrainCVSamples::int, novadaq::cnv::kNEARDET, geo::kX, geo::kY, rh, scale, calib::CalibratorParams::SimulateDrift, nova::dbi::RunHistory::TStart(), calib::CalibratorParams::UseXFunction, and calib::CalibratorParams::UseYFunction.

Referenced by GetPECorr().

  {
    double scale = 1.0;

    // scaling in the X view
    if(view == geo::kX && fParams.UseXFunction()){

      //RJN this will do the wrong thing for the TestBeam.... but who cares
      // if there is a seperate muon catcher function, use it
      if( fXMuCFunction                                   &&
          fGeom->DetId() == novadaq::cnv::kNEARDET        &&
          plane >= int(fGeom->FirstPlaneInMuonCatcher())  ){
        scale *= fXMuCFunction->Eval(w);
      }
      else {
        scale *= fXFunction->Eval(w);
      }
    }

    // scaling in the Y view
    if(view == geo::kY && fParams.UseYFunction()) scale *= fYFunction->Eval(w);

    // if simulating detector drift 
    if (fParams.SimulateDrift()) {
      art::ServiceHandle<nova::dbi::RunHistoryService> rh;
      int time = rh->TStart() + (0.5*rh->Duration()); // set to midpoint of run;
      double yDiff = 3.17098e-8 * (time - fParams.DriftReference()); // Amount of drift in years
      //std::cout << "Drifting " << yDiff << " years with respect to nominal." << std::endl;
      double drift = 1 - (fParams.DriftGradient()*yDiff);
      double calCorrection = 1/drift;
      //std::cout << "Calculated drift of " << drift
      //  << " from nominal, with inverse shift " << calCorrection
      //  << " applied to calibration. Scale corrected from " << scale << " to ";
      scale *= calCorrection;
      //std::cout << scale << std::endl;
    } 

    return scale;
  }

Member Data Documentation

AbsCache* calib::Calibrator::fAbsCache

private

Definition at line 411 of file Calibrator.h.

Referenced by Calibrator(), GetPECorrToGeVScale(), postBeginRun(), and ~Calibrator().

AttenCache* calib::Calibrator::fAttenCacheData

private

Data attenutation corrections.

Definition at line 408 of file Calibrator.h.

Referenced by GetAttenCurve(), postBeginRun(), and ~Calibrator().

std::vector< AttenCache* > calib::Calibrator::fAttenCacheMC

private

MC attenutation corrections indexed by fiber brightness.

Definition at line 409 of file Calibrator.h.

Referenced by GetAttenCurve(), postBeginRun(), and ~Calibrator().

int calib::Calibrator::fCalibrateMode

private

Definition at line 397 of file Calibrator.h.

Referenced by Calibrator(), and GetTNS().

art::ServiceHandle<cmap::CMap> calib::Calibrator::fCMap

private

Definition at line 443 of file Calibrator.h.

Referenced by getFebType(), GetPECorrToGeVScale(), GetTimingOffset(), and MakeCellHit().

int calib::Calibrator::fCurrentRun

private

get the current run to make sure that we know if we have perfect MC

Definition at line 414 of file Calibrator.h.

Referenced by postBeginRun().

TTimeStamp calib::Calibrator::fCurrTimeStamp

private

current time stamp

Definition at line 395 of file Calibrator.h.

Referenced by GetTimingOffset(), MakeCellHit(), and preEvent().

DriftCache* calib::Calibrator::fDriftCache

private

Definition at line 410 of file Calibrator.h.

Referenced by Calibrator(), GetDriftScale(), postBeginRun(), and ~Calibrator().

art::ServiceHandle<photrans::FiberBrightness> calib::Calibrator::fFibBrightness

private

Definition at line 445 of file Calibrator.h.

Referenced by GetAttenCurve(), and postBeginRun().

double calib::Calibrator::fGain

private

Definition at line 434 of file Calibrator.h.

Referenced by Calibrator(), GetAdcPerPE(), and postBeginRun().

art::ServiceHandle<geo::Geometry> calib::Calibrator::fGeom

private

Definition at line 444 of file Calibrator.h.

Referenced by EnsureTimingCacheVldTime(), GetAdcPerPE(), GetAttenCurve(), GetAttenScale(), GetPECorrToGeVScale(), GetTimeRes(), GetTimingOffset(), GetTNS(), MakeCellHit(), postBeginRun(), and SystematicUncertaintyScale().

CalibratorParams calib::Calibrator::fParams

protected

Definition at line 392 of file Calibrator.h.

Referenced by Calibrator(), GetAttenCurve(), GetAttenScale(), GetDriftScale(), GetTimingOffset(), MakeCellHit(), postBeginRun(), and SystematicUncertaintyScale().

art::ServiceHandle<nova::dbi::RunHistoryService> calib::Calibrator::fRH

private

Definition at line 446 of file Calibrator.h.

ADCShapeFitTable* calib::Calibrator::fShapeTable

private

Definition at line 405 of file Calibrator.h.

Referenced by GetTNS(), and ~Calibrator().

ADCShapeFitTable* calib::Calibrator::fShapeTable5TB

private

FEBv5 table for TestBeam (fShapeTable will be FEBv4)

Definition at line 406 of file Calibrator.h.

Referenced by GetTNS(), and ~Calibrator().

std::string calib::Calibrator::fShapeTableFilenameFDData

private

Definition at line 400 of file Calibrator.h.

Referenced by Calibrator(), and GetTNS().

std::string calib::Calibrator::fShapeTableFilenameFDMC

private

Root file ADCShapeFitTable will load from.

Definition at line 399 of file Calibrator.h.

Referenced by Calibrator(), and GetTNS().

std::string calib::Calibrator::fShapeTableFilenameNDData

private

Definition at line 402 of file Calibrator.h.

Referenced by Calibrator(), and GetTNS().

std::string calib::Calibrator::fShapeTableFilenameNDMC

private

Definition at line 401 of file Calibrator.h.

Referenced by Calibrator(), and GetTNS().

unsigned int calib::Calibrator::fStatsNumAveraged

private

Number of hits from uncalibrated diblocks using averaged calibrations.

Definition at line 453 of file Calibrator.h.

Referenced by GetAttenScale(), and ~Calibrator().

unsigned int calib::Calibrator::fStatsNumCalibrated

private

Number of calibrated hits returned.

Definition at line 449 of file Calibrator.h.

Referenced by MakeRecoHit(), and ~Calibrator().

unsigned int calib::Calibrator::fStatsNumUncalibrated

private

Number of uncalibrated hits returned.

Definition at line 451 of file Calibrator.h.

Referenced by MakeRecoHit(), and ~Calibrator().

std::string calib::Calibrator::fTag

private

Definition at line 433 of file Calibrator.h.

Referenced by Calibrator(), GetAttenCurve(), GetAttenScale(), and postBeginRun().

TimingCache* calib::Calibrator::fTimingCache

private

Definition at line 412 of file Calibrator.h.

Referenced by Calibrator(), EnsureTimingCacheVldTime(), GetTimingOffset(), MakeCellHit(), postBeginRun(), and ~Calibrator().

bool calib::Calibrator::fTimingCacheVldTimeSet

private

Is fTimingCache set to the right time?

Definition at line 413 of file Calibrator.h.

Referenced by EnsureTimingCacheVldTime(), and postBeginRun().

TF1* calib::Calibrator::fXFunction

private

Definition at line 436 of file Calibrator.h.

Referenced by postBeginRun(), and SystematicUncertaintyScale().

TF1* calib::Calibrator::fXMuCFunction

private

Definition at line 437 of file Calibrator.h.

Referenced by postBeginRun(), and SystematicUncertaintyScale().

TF1* calib::Calibrator::fYFunction

private

Definition at line 438 of file Calibrator.h.

Referenced by postBeginRun(), and SystematicUncertaintyScale().

---

The documentation for this class was generated from the following files:

• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-04-18/Calibrator/art/Calibrator.h
• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N21-04-18/Calibrator/art/Calibrator_service.cc