Evaluator.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       Evaluator
// File:        Evaluator.cxx
//
////////////////////////////////////////////////////////////////////////
#include "AnalysisSkimmer/evaluators/Evaluator.h"
#include "RunHistory/service/RunHistoryService.h"

//------------------------------------------------------------------------------
skim::Evaluator::Evaluator()
{
}

//------------------------------------------------------------------------------
skim::Evaluator::~Evaluator()
{
}

//------------------------------------------------------------------------------
bool skim::Evaluator::CheckTiming(rb::Cluster const& slice)
{
  // look in CAFAna/TimingCuts.h for definitions of the timing constants
  
  const double BeamWindowMinMicroSec = 217;
  const double BeamWindowMaxMicroSec = 229;
  const double PeakShiftMicroSec     = 64;
  const int    LastBadTimingRun      = 17945;
  
  auto time = slice.MeanTNS();
  
  LOG_DEBUG("Evaluator")
  << "the mean time is "  << time
  << "\ncurrent Run "     << fCurrentRun << "/" << LastBadTimingRun
  << "\nbeam window min " << 1000 * BeamWindowMinMicroSec
  << "\nbeam window max " << 1000 * BeamWindowMaxMicroSec
  << "\nbeam offset "     << 1000 * PeakShiftMicroSec;
  
  if(fCurrentRun <= LastBadTimingRun                           &&
     time > 1000 * (BeamWindowMinMicroSec + PeakShiftMicroSec) &&
     time < 1000 * (BeamWindowMaxMicroSec + PeakShiftMicroSec)) return true;
  
  if(time > 1000 * BeamWindowMinMicroSec &&
     time < 1000 * BeamWindowMaxMicroSec) return true;
  
  return false;
}

//------------------------------------------------------------------------------
// This is a stop gap \TODO: remove at some point

std::pair<int, int> calcFirstLastLivePlane(int plane,
                                           std::bitset<14> binary,
                                           novadaq::cnv::DetId det){
    //if not the FD, return full ND size
  if (det != novadaq::cnv::kFARDET) return std::pair<int, int>(0,213);
  int testDB = (plane / 64);
  int minblock = testDB;
  int maxblock = testDB;
    //find block boundaries;
  for (int i=testDB-1; i>=0; --i){
    if (binary[i]) minblock=i;
    else break;
  }
  for (int i=testDB+1; i<14; ++i){
    if (binary[i]) maxblock=i;
    else break;
  }
  return std::pair<int, int>(64*(minblock), 64*(maxblock+1)-1);
}


//------------------------------------------------------------------------------
bool skim::Evaluator::CheckSliceQuality(rb::Cluster const& slice)
{
  if(fDetId != novadaq::cnv::kFARDET) return true;
  
  art::ServiceHandle<nova::dbi::RunHistoryService> rh;
  unsigned int dibmask  = (rh->GoodDiBlockMask()&rh->GetConfiguration());
  std::bitset<14> binary(dibmask);

  std::pair<int,int> planesA = calcFirstLastLivePlane(slice.MinPlane(), binary, fDetId);
  std::pair<int,int> planesB = calcFirstLastLivePlane(slice.MaxPlane(), binary, fDetId);
  
  LOG_DEBUG("Evaluator")
  << "min plane: " << slice.MinPlane() << " max plane: " << slice.MaxPlane()
  << " " << planesA.first << " " << planesA.second
  << " " << planesB.first << " " << planesB.second
  << " " << (planesA.second - planesA.first + 1)/64 << " > 3";
  
  if ((planesA.first != planesB.first) || (planesA.second != planesB.second))
    return false;
  
    // 1/64 = 0.015625
  return ((planesA.second - planesA.first + 1) * 0.015625 > 3);
}

/******
//------------------------------------------------------------------------------
static bool skim::Evaluator::ShowerByEnergy(slid::ShowerLID const* s1, slid::ShowerLID const* s2)
{
  return s1->ShowerEnergy() > s2->ShowerEnergy();
}

//------------------------------------------------------------------------------
static bool skim::Evaluator::ProngByLength(rb::Prong const* p1, rb::Prong const* p2)
{
  return p1->TotalLength() > p2->TotalLength();
}
********/