AlgFilterDigitList.cxx

Go to the documentation of this file.

// $Id: AlgFilterDigitList.cxx,v 1.12 2008/11/12 17:37:14 rhatcher Exp $
//
// AlgFilterDigitList.cxx
//
// Concrete Algorithm for filtering CandDigit's from CandDigitList
//
// Author:  G. Irwin 2/2003
// AlgConfig parameters (with default values) are:
//
// "FilterStrategy" - Filtering strategy to use

#include <cassert>
#include <float.h>
#include <map>

#include "TROOT.h"
#include "Riostream.h"
#include "TFolder.h"

//test
#include "CandDigit/CandDigitBadChannels.h"
#include "DatabaseInterface/DbiResultPtr.h"


#include "Algorithm/AlgConfig.h"
#include "Algorithm/AlgFactory.h"
#include "CandDigit/AlgFilterDigitList.h"
#include "Algorithm/AlgHandle.h"
#include "CandDigit/CandDigit.h"
#include "CandDigit/CandDigitHandle.h"
#include "CandDigit/CandDigitList.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/FilterBadChannelMap.h"
#include "Candidate/CandContext.h"
#include "MessageService/MsgService.h"
#include "RawData/RawChannelId.h"
#include "Validity/VldContext.h"

// class FilterBadChannelMap : public TObject
// {
//    public:
//      FilterBadChannelMap();
//      ~FilterBadChannelMap();

//      map<RawChannelId, bool> fBadChannelMap;

// };

ClassImp(AlgFilterDigitList)

//______________________________________________________________________
CVSID("$Id: AlgFilterDigitList.cxx,v 1.12 2008/11/12 17:37:14 rhatcher Exp $");

//______________________________________________________________________
AlgFilterDigitList::AlgFilterDigitList() :
  fTFolder(0)
{
}

//______________________________________________________________________
AlgFilterDigitList::~AlgFilterDigitList()
{
  FilterBadChannelMap *badChannelMap;
  if (fTFolder && (badChannelMap = dynamic_cast<FilterBadChannelMap*>
                       (fTFolder->FindObject("FilterBadChannelMap")))) {
    fTFolder->Remove(badChannelMap);
    delete badChannelMap;
  }
}

//______________________________________________________________________
void AlgFilterDigitList::RunAlg(AlgConfig &ac, CandHandle &ch,
                                                        CandContext &cx)
{
   MSG("AlgFilterDigitList", Msg::kDebug)
                     << "Starting AlgFilterDigitList::RunAlg()" << endl;

// Check for input CandDigitListHandle in CandContext
   assert(cx.GetDataIn());

// Obtain CandContext's CandDigitList as input
   const CandDigitListHandle *cdlh =
             dynamic_cast<const CandDigitListHandle *> (cx.GetDataIn());
   assert(cdlh);   // Check for input CandDigitListHandle in CandContext

// Obtain filtering parameters from AlgConfig
   Int_t    filterstrategy = 0;
   Float_t  chargeMin = -FLT_MAX;
   Double_t timeMin   = -FLT_MAX;
   Int_t    errorBitsMaskVA  = 0;
   Int_t    errorBitsMaskQIE = 0;

   Int_t tmpi = 0;
   Double_t tmpd = 0;
   const char* tmps;
   if (ac.Get("FilterStrategy", tmpi))   filterstrategy   = tmpi;
   if (ac.Get("ChargeMin",tmpd))         chargeMin        = tmpd;
   if (ac.Get("SubtractedTimeMin",tmpd)) timeMin          = tmpd;
   if (ac.Get("ErrorBitsMaskVA",tmpi))   errorBitsMaskVA  = tmpi;
   if (ac.Get("ErrorBitsMaskQIE",tmpi))  errorBitsMaskQIE = tmpi;
   if (ac.Get("BadChannelFile", tmps))   fBadChannelFile  = tmps;

   MSG("AlgFilterDigitList", Msg::kDebug) << "file = "
                                    << fBadChannelFile << " strategy = " 
                                              << filterstrategy << endl;

// Set CandRecord pointer in new CandDigitList to that of CandDigitList
   ch.SetCandRecord((cdlh->GetCandRecord())); //Sub-algorithms need this

// Copy member variables from orig CandDigitList to new CandDigitList
   CandDigitListHandle &cddlh = dynamic_cast<CandDigitListHandle &>(ch);
   cddlh.SetAbsTime(cdlh->GetAbsTime());
   cddlh.SetIsSparse(cdlh->GetIsSparse());

// Iterate over CandContext's CandDigitList to find CandDigitHandles.
   TIter cdhiter = cdlh->GetDaughterIterator();
   TObject *tob;
   while ((tob = cdhiter())) {
     CandDigitHandle *cdh = dynamic_cast<CandDigitHandle *>(tob);
     if (cdh == 0) continue;   // Skip daughter if not a CandDigitHandle

// Filter unwanted digits here
// if (DontWantThisDigit(filterstrategy)) continue;

// Strategy 1:  filter away digits that have error codes
//              or are below the sparsification threshold
     if (1==filterstrategy) {
       if ( cdh->GetCharge()         < chargeMin ) continue;
       if ( cdh->GetSubtractedTime() < timeMin   ) continue;
       if ( cdh->GetVaErrorBits()    & errorBitsMaskVA  ) continue;
       if ( cdh->GetQieErrorBits()   & errorBitsMaskQIE ) continue;
     }                                          // End Filter Strategy 1

// Strategy 2:  Strategy 1 + filter away digits from known bad channels
     if(filterstrategy==2){
       MSG("AlgFilterDigitList", Msg::kDebug)
                                          << "using strategy 2" << endl;

// Look for the FilterBadChannelMap object on the TFolder white board.
       if (fTFolder==0) {
         TFolder *lf = dynamic_cast<TFolder*>
                           (gROOT->GetRootFolder()->FindObject("Loon"));
         if (lf==0) {
           MSG("AlgFilterDigitList", Msg::kDebug)
                                     << "Creating Loon TFolder" << endl;
           lf = gROOT->GetRootFolder()->AddFolder("Loon",
                                                       "Loon analysis");
           gROOT->GetListOfBrowsables()->Add(lf, "Loon");
         }
         fTFolder = dynamic_cast<TFolder*>(lf->FindObject("CandDigit"));
         if (fTFolder==0) {
           MSG("AlgFilterDigitList", Msg::kDebug)
                           << "Creating Loon/CandDigit TFolder" << endl;
           fTFolder =
                    lf->AddFolder("CandDigit", "CandDigit diagnostics");
         }
       }         

       FilterBadChannelMap *badChannelMap =
                                      dynamic_cast<FilterBadChannelMap*>
                          (fTFolder->FindObject("FilterBadChannelMap"));
       if (badChannelMap==0) {
         MAXMSG("AlgFilterDigitList", Msg::kInfo,2)
            << "Creating Loon/CandDigit/FilterBadChannelMap" << endl;
         MakeBadChannelMap(cdh->GetVldContext()->GetDetector());
         badChannelMap = dynamic_cast<FilterBadChannelMap*>
                          (fTFolder->FindObject("FilterBadChannelMap"));

         if ( !badChannelMap ) MSG("AlgFilterDigitList", Msg::kFatal)
            << "still no Loon/CandDigit/FilterBadChannelMap" << endl;
       }

// grab the RawChannelId and copy it to a local thing
       RawChannelId theChannel = cdh->GetChannelId();
       theChannel.ClearModeBits();

       MSG("AlgFilterDigitList", Msg::kDebug) << "encoded value = "
                                   << theChannel.AsString("ec") << endl;

// check to see if the channel for this digit is in the bad channel map
       map<RawChannelId, bool>& theMap = badChannelMap->fBadChannelMap;
       if (theMap.find(theChannel) != theMap.end()) {
         MSG("AlgFilterDigitList", Msg::kDebug)
                << "filtering " << cdh->GetChannelId().GetCrate() << "-"
                    << cdh->GetChannelId().GetGeographicAddress() << "-"
                        << cdh->GetChannelId().GetMasterChannel() << "-"
                      << cdh->GetChannelId().GetMinderChannel() << endl;
         continue;
       }

       if ( cdh->GetCharge()         < chargeMin ) continue;
       if ( cdh->GetSubtractedTime() < timeMin   ) continue;
       if ( cdh->GetVaErrorBits()    & errorBitsMaskVA  ) continue;
       if ( cdh->GetQieErrorBits()   & errorBitsMaskQIE ) continue;
              
     }                                                 // end strategy 2
     
     //Strategy 3:  Strategy 1 + filter away digits from BADCHANNELS db
     //This uses the database so is more flexible
     else if(filterstrategy==3){
       MSG("AlgFilterDigitList",Msg::kVerbose)
         <<"Using filterstrategy 3"<<endl;
       
       //do filter strategy 1 first
       if ( cdh->GetCharge()         < chargeMin ) continue;
       if ( cdh->GetSubtractedTime() < timeMin   ) continue;
       if ( cdh->GetVaErrorBits()    & errorBitsMaskVA  ) continue;
       if ( cdh->GetQieErrorBits()   & errorBitsMaskQIE ) continue;

       //now do the additional filter strategy
       
       //create the bad channel map pointer
       static FilterBadChannelMap* badChannelMap=0;
       
       //only create a bad channel map once per validity context
       static VldContext lastvc;
       if (*cdh->GetVldContext()!=lastvc) {
         MAXMSG("AlgFilterDigitList",Msg::kDebug,3)
           <<"AlgFilterDigitList: found new VldContext..."<<endl;
         //get the map of bad channels
         badChannelMap=this->MakeBadChannelMapDB(*cdh->GetVldContext());

         if ( !badChannelMap ) MSG("AlgFilterDigitList", Msg::kFatal)
            << "failed to get anything from MakeBadChannelMapDB" << endl;
         else {
           // RWH 2008-11-12 print the whole list once, just for the record
           // under the assumption that the list is short
           static int ndumps = 1;
           if ( ndumps > 0 ) {
             --ndumps;
             size_t nbad = badChannelMap->fBadChannelMap.size();
             MSG("AlgFilterDigitList", Msg::kInfo)
               << "AlgFilterDigitList strategy " << filterstrategy 
               << ", BadChannelMap has " << nbad << " entries" << endl;
             std::map<RawChannelId, bool>::const_iterator bcitr = 
               badChannelMap->fBadChannelMap.begin();
             std::map<RawChannelId, bool>::const_iterator bcitr_end = 
               badChannelMap->fBadChannelMap.end();
             size_t indx = 0;
             while ( bcitr != bcitr_end ) {
               MSG("AlgFilterDigitList", Msg::kInfo)
                 << "  [" << std::setw(3) << indx << "] "
                 << bcitr->first << " " << ((bcitr->second)?"true":"false")
                 << endl;
               indx++; bcitr++;
             }
           }
         }
       }
       assert(badChannelMap);
       //store the vc for next iteration of loop
       lastvc=*cdh->GetVldContext();

       //check that there is actually something in the map
       if (badChannelMap->fBadChannelMap.size()>0) {
         //cache the RawChannelId
         RawChannelId theChannel=cdh->GetChannelId();
         theChannel.ClearModeBits();
         
         MSG("AlgFilterDigitList",Msg::kDebug) 
           <<"Encoded value = "<<theChannel.AsString("ec")<<endl;
         
         //check to see if channel for this digit is in bad channel map
         map<RawChannelId, bool>& theMap = badChannelMap->fBadChannelMap;
         if (theMap.find(theChannel)!=theMap.end()) {
           MAXMSG("AlgFilterDigitList",Msg::kInfo,3)
             <<"AlgFilterDigitList::Filtering bad channel: "<<theChannel.AsString("ec")
             <<endl;
           continue;
         }
       }
       else {
         MAXMSG("AlgFilterDigitList",Msg::kInfo,1)
           <<"AlgFilterDigitList: No CandDigitBadChannels found in map"
           <<", skipping this filter step"<<endl;
       }
     }

     //Effect copy of wanted digits from orig CandDigitList to daughter list
     CandDigitHandle cddh(*cdh);
     ch.AddDaughterLink(cddh, kFALSE);           // Don't check for dups
   }
}

//______________________________________________________________________
void AlgFilterDigitList::Trace(const char * /* c */) const
{
}

//----------------------------------------------------------------------
// this function should only be called once, otherwise a memory leak
void AlgFilterDigitList::MakeBadChannelMap(Detector::Detector_t det)
{
   MSG("AlgFilterDigitList",Msg::kDebug)
     << "MakeBadChannelMap called for " << Detector::AsString(det)
     << " using " << fBadChannelFile << endl;

   UInt_t prevEncoded = 0;

// make the bad channel map object
   FilterBadChannelMap *badChMap = new FilterBadChannelMap();

// open the bad channel file
   ifstream badChannels(fBadChannelFile.c_str());

   if (!badChannels.is_open()) {
     MSG("AlgFilterDigitList", Msg::kError)
                                  << "cannot open list of bad channels," 
                                                      << fBadChannelFile
                                    << " assume there are none" << endl;

// Add the map to the white board. AlgFilterDigitList retains ownership!
     fTFolder->Add(badChMap);
     return;
   }

// fill the map
   if (det==Detector::kNear) {
     UInt_t crate = 0;
     UInt_t geo = 0;
     UInt_t masterChannel = 0;
     UInt_t minderChannel = 0;

// read in the list of bad channels
     while (!badChannels.eof()) {
       badChannels >> crate >> geo >> masterChannel >> minderChannel;

// make a RawChannelId to get the encoded value
#ifdef RAWCHANNELID_NEW_CTOR
       RawChannelId rawId(det,ElecType::kQIE, crate, geo,
                                          masterChannel, minderChannel);
#else
       RawChannelId rawId(det,ElecType::kQIE, crate, geo,
                            masterChannel, minderChannel, false, false);
#endif
       rawId.ClearModeBits();
       MSG("AlgFilterDigitList", Msg::kDebug)
                                      << "*******filter channel********"
                   << crate << " " << geo << " " << masterChannel << " " 
                                                 << minderChannel << " " 
                                        << rawId.AsString("ec") << endl;

// if the channel is in the list it is a bad channel so the flag is true
       if (rawId.GetEncoded() != prevEncoded)
         badChMap->fBadChannelMap[rawId] = true;

     }                                       // end loop over input file
   }                                             // end if near detector

// Add the map to the white board. AlgFilterDigitList retains ownership!
   fTFolder->Add(badChMap);
   return;
}

//----------------------------------------------------------------------

FilterBadChannelMap* AlgFilterDigitList::MakeBadChannelMapDB(const VldContext& vc)
{
  //make the bad channel map object once
  static FilterBadChannelMap* badChMap=new FilterBadChannelMap();

  //clear out any channels that are already in the map
  badChMap->fBadChannelMap.clear();
  
  static Bool_t firstTime=true;
  if (firstTime) {
    firstTime=false;
    MAXMSG("AlgFilterDigitList",Msg::kDebug,200)
      <<"Running AlgFilterDigitList::MakeBadChannelMapDB for first time"
      <<endl;
    //vc.Print();
  }
  
  //now fill the map from the database
  //read in the list of bad channels
  Int_t task=0;
  DbiResultPtr<CandDigitBadChannels> badChannelsPtr(vc,task);
  
  MAXMSG("AlgFilterDigitList",Msg::kDebug,100)
    <<"Num of CandDigitBadChannels rows="
    <<badChannelsPtr.GetNumRows()<<endl;
  
  //loop over all the bad channels and add to map
  for (UInt_t irow=0;irow<badChannelsPtr.GetNumRows();++irow) {
    
    //get bad channel
    const CandDigitBadChannels& badChannel=*(badChannelsPtr.GetRow(irow));
    
    MSG("AlgFilterDigitList",Msg::kDebug)
      <<"Crate="<<badChannel.GetCrate()
      <<", ChAdd="<<badChannel.GetChAdd()
      //<<", badnessReason="<<badChannel.GetBadness()
      //<<", parA="<<badChannel.GetParA()<<", parB="<<badChannel.GetParB()
      //<<", parC="<<badChannel.GetParC()
      <<endl;
    
    Int_t crate=badChannel.GetCrate();
    Int_t chadd=badChannel.GetChAdd();
    
    //deal with electronics type
    ElecType::Elec_t et=ElecType::kVA;
    if (vc.GetDetector()==Detector::kNear) et=ElecType::kQIE;
    
    //make a RawChannelId to get the encoded value
    RawChannelId rawId(vc.GetDetector(),et,crate,chadd);
    rawId.ClearModeBits();
    
    MAXMSG("AlgFilterDigitList",Msg::kDebug,200)
      << "*******filter channel********"
      <<rawId.AsString("ec")<<endl;
    
    //add channel to map
    //if channel is in the list it is a bad channel so set to true
    badChMap->fBadChannelMap[rawId]=true;
  }
  
  return badChMap;
}

//----------------------------------------------------------------------

---