DemoDataReject.cxx

Go to the documentation of this file.

// $Id: DemoDataReject.cxx,v 1.5 2004/10/19 23:55:45 rhatcher Exp $
#include "Demo/DemoDataReject.h"
#include <cstdio>
// ROOT include files
#include "TObject.h"
#include "TCollection.h"
#include "TObjectTable.h"
// MINOS include files
#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitHandle.h"
#include "CandDigit/CandDigitListHandle.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDaqHeader.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawDigit.h"
#include "Plex/PlexHandle.h"
#include "JobControl/JobCommand.h"
#include "JobControl/JobCModuleRegistry.h"
#include "MinosObjectMap/MomNavigator.h"
#include "MessageService/MsgService.h"
#include "Util/UtilString.h"

CVSID("$Id: DemoDataReject.cxx,v 1.5 2004/10/19 23:55:45 rhatcher Exp $");
JOBMODULE(DemoDataReject, 
          "DataReject", "Filter out data records.");

//......................................................................

enum {
   kRejectIfAllOff = -2,
   kRejectIfAnyOff = -1,
   kIgnoreTest     =  0,
   kRejectIfAnyOn  =  1,
   kRejectIfAllOn  =  2
};

namespace RejectHelper {
//======================================================================
// Utility functions 
// put it in a namespace to avoid potential conflict
//======================================================================

   bool reject_it(Short_t setting, Short_t n, Short_t m) {
     //
     // make selection based on user setting and "n of m"
     //
      switch (setting) {
      case kRejectIfAllOff: return (n==0);
      case kRejectIfAnyOff: return (n<m);
      case kIgnoreTest:     return false;
      case kRejectIfAnyOn:  return (n>0);
      case kRejectIfAllOn:  return (n==m);
      default:              return false;
      }
   }

  bool reject_veto(Short_t setting, RawDigitDataBlock* rddb) {

    //
    // loop over digits, count number that come from veto shield
    // use user criteria for whether to reject
    //

    PlexHandle ph(rddb->GetVldContext());
    TIter rdit = rddb->GetDatumIter();
    RawDigit *rd;

    int ndigit=0, nveto=0;
    while ( ( rd = (RawDigit*)rdit() ) ) {
      ++ndigit;
      RawChannelId rcid = rd->GetChannel();
      PlexSEIdAltL altl = ph.GetSEIdAltL(rcid);
      if (altl.IsVetoShield()) ++nveto;
    }

    return reject_it(setting,nveto,ndigit);

  }

}
//......................................................................

DemoDataReject::DemoDataReject() : 
  fPedReject(kIgnoreTest), 
  fSparsReject(kIgnoreTest), 
  fCommonReject(kIgnoreTest),
  fVetoShieldReject(kIgnoreTest)
{}

//......................................................................

DemoDataReject::~DemoDataReject() {}

//......................................................................
  
JobCResult DemoDataReject::Ana(const MomNavigator* mom)
{
   JobCResult result = JobCResult::kPassed;
   
   // Get any and all raw records attached to the data record pointed 
   // to by "mom".  The dynamic cast from TObject is ugly but necessary
   TObject   *tobj   = 0;
   TIter reciter = const_cast<MomNavigator*>(mom)->FragmentIter();
   while ( (tobj = reciter() ) ) {
      RawRecord *rawrec = dynamic_cast<RawRecord *>(tobj);
      result = FilterRawRecord(rawrec);
      if (result.Failed()) return result;
   }

   // other potential tests

   return result;
}

//......................................................................

const Registry& DemoDataReject::DefaultConfig() const 
{
//======================================================================
// The default configuration for this module
//======================================================================
  static Registry r;
  
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());
  
  r.UnLockValues();
  r.Set("PedReject",        kIgnoreTest);
  r.Set("SparseReject",     kIgnoreTest);
  r.Set("CommonReject",     kIgnoreTest);
  r.Set("VetoShieldReject", kIgnoreTest);
  r.LockValues();

  return r;
}

//......................................................................

void DemoDataReject::Config(const Registry& r) 
{
//======================================================================
// Configure the module using the registry r
//======================================================================
  int  tmpi;

  if (r.Get("PedReject",tmpi))        fPedReject = tmpi;
  if (r.Get("SparsReject",tmpi))      fSparsReject = tmpi;
  if (r.Get("CommonReject",tmpi))     fCommonReject = tmpi;
  if (r.Get("VetoShieldReject",tmpi)) fVetoShieldReject = tmpi;

}

//......................................................................
void DemoDataReject::HandleCommand(JobCommand* cmd) 
{

   using namespace RejectHelper;
   const char* c = cmd->PopCmd();
   if (c) {
      string sc(c);
      if (sc == "RunType") {
         while (cmd->HaveOpt()) fRunTypeReject.insert(cmd->PopIntOpt());
      }
      else  if (sc == "Mode") {
         const char* opt = cmd->PopOpt();
         string sopt(opt);
         Short_t *which = 0;
         if      (sopt.find("Ped")   !=string::npos) which = &fPedReject;
         else if (sopt.find("Ped")   !=string::npos) which = &fPedReject;
         else if (sopt.find("Spars") !=string::npos) which = &fSparsReject;
         else if (sopt.find("spars") !=string::npos) which = &fSparsReject;
         else if (sopt.find("Common")!=string::npos) which = &fCommonReject;
         else if (sopt.find("common")!=string::npos) which = &fCommonReject;
         else if (sopt.find("Veto")  !=string::npos) which = &fVetoShieldReject;
         else if (sopt.find("veto")  !=string::npos) which = &fVetoShieldReject;
         else {
            which = 0;
            MSG("Demo",Msg::kWarning) 
               << "No DataReject/Mode available for mode '" << opt << "'." 
               << "  Try one of Ped, Spars, Common, VetoShield." << endl
               << endl;
         }
         if (which) {
            const char* tst = cmd->PopOpt();
            string stst(tst);
            using namespace UtilString;
            if      (!cmp_nocase(stst,"ignore")) *which = kIgnoreTest;
            else if (!cmp_nocase(stst,"alloff")) *which = kRejectIfAllOff;
            else if (!cmp_nocase(stst,"anyoff")) *which = kRejectIfAnyOff;
            else if (!cmp_nocase(stst,"off"))    *which = kRejectIfAnyOff;
            else if (!cmp_nocase(stst,"on"))     *which = kRejectIfAnyOn;
            else if (!cmp_nocase(stst,"anyon"))  *which = kRejectIfAnyOn;
            else if (!cmp_nocase(stst,"allon"))  *which = kRejectIfAllOn;
            else {
               MSG("Demo",Msg::kWarning) 
                  << "No DataReject/Mode setting \"" << stst
                  << "\", should be one of on, off, ignore." << endl;
               *which = kIgnoreTest;
            }
         }
      }
   }
   else {
      MSG("Demo",Msg::kInfo) 
         << "Valid DataReject commands are RunType, Mode" << endl;
   }
}

//......................................................................

JobCResult DemoDataReject::FilterRawRecord(const RawRecord* rawrec) const
{

   JobCResult result = JobCResult::kPassed;

   // test if the run type is in the disallowed set
   const RawDaqHeader* header = 
      dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());
   if (header) {
      Short_t rt = header->GetRunType();
      if (fRunTypeReject.end() != fRunTypeReject.find(rt))
         return JobCResult::kFailed;
   }
   else {
      MSG("Demo",Msg::kInfo)
         << "RawRecord lacked RawDaqHeader: "
         << *(rawrec->GetRawHeader())
         << endl;
   }

   // test if the wrong modes were in play in RawDigitDataBlock
   TIter itr = rawrec->GetRawBlockIter();
   RawDataBlock* rdb = 0;
   // The dynamic cast from TObject is ugly but necessary
   // Careful! the itr() advances the iterator as a side effect!
   while ((rdb = dynamic_cast<RawDataBlock*>(itr()))) {
      RawDigitDataBlock *rddb = dynamic_cast<RawDigitDataBlock*>(rdb);
      if (rddb) {
         Short_t ncrates = rddb->GetNumberOfCrates();
         Short_t nped    = rddb->GetNPedModeCrates();
         Short_t nspars  = rddb->GetNSparsModeCrates();
         Short_t ncommon = rddb->GetNCommonModeCrates();

         using namespace RejectHelper;
         if (reject_it(fPedReject,nped,ncrates)) 
            return JobCResult::kFailed;
         if (reject_it(fSparsReject,nspars,ncrates)) 
            return JobCResult::kFailed;
         if (reject_it(fCommonReject,ncommon,ncrates)) 
            return JobCResult::kFailed;

         if ( fVetoShieldReject != kIgnoreTest &&
              reject_veto(fVetoShieldReject,rddb) ) return JobCResult::kFailed;
      }
  }

  return result;
}

//......................................................................

void DemoDataReject::Help()
{
  const char* n = this->GetName();

  MSG("Demo",Msg::kInfo)
     << "Help for module " << n << endl
     << endl
     << "  A filter to remove undesired data configurations" << endl
     << "  commands:" << endl
     << endl
     << "  /" << n << "/RunType [ival [ival ...]]" << endl
     << endl
     << "  /" << n << "/Mode <mode> <toggle> ..." << endl
     << "     where <mode> is one of Ped, Spars, Common " <<endl
     << "     and   <toggle> is: " << endl
     << "                AllOff, [Any]Off, [Any]On, AllOn " << endl
     << "                or Ignore (which skips the test) " << endl
     << endl
     << endl;

}

---