CDPreFilterModule.cxx

Go to the documentation of this file.

// Program name: CDPreFilterModule.cxx
//
// Package: CalDetTracker
//
// Purpose: Only pass snarls with something interesting
//
// Contact: Chris Smith, Ryan Nichol, Leo Jenner or Jeff Hartnell

#include <cstdio>
#include <fstream>

#include "TObject.h"

#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "JobControl/JobCommand.h"
#include "JobControl/JobCModuleRegistry.h"
#include "RawData/RawRecord.h"
#include "RawData/RawHeader.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawTOFBlock.h"
#include "RawData/RawDeadChipBlock.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawDigit.h"
#include "RawData/RawQieDigit.h"
#include "RawData/RawVaDigit.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawVarcErrorInTfBlock.h"

#include "CalDetTracker/CDPreFilterModule.h"

CVSID("$Id: CDPreFilterModule.cxx,v 1.12 2005/08/28 01:41:37 rhatcher Exp $");

JOBMODULE(CDPreFilterModule,"CDPreFilterModule",
          "Only Pass Interesting Snarls");

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

CDPreFilterModule::CDPreFilterModule()
{
  //don't cut on any trigger bits by default
  fplanetrig=0;
  fnplane=0;
  fbeamonly=0;
  fcerenkov=0;
  fnodeadchips=0;
  fli=0;
  ftof=0;
  fNoNdErrors=0;
  fNoFdErrors=0;
  fBigSnarls=0;

  //initialise the counters
  fPlaneTrigCounter=0;
  fBeamOnlyCounter=0;
  fCerenkovCounter=0;
  fNoDeadChipsCounter=0;
  fLiCounter=0;
  fTofCounter=0;
  fTotalPassedCounter=0;
  fTotalFailedCounter=0;
  fTotalInputCounter=0;
  fNoNdErrorsCounter=0;
  fNoFdErrorsCounter=0;
  fBigSnarlsCounter=0;

  //error counters
  fNdSnarlErrorCounter=0;
  fNdSnarlFFFFCounter=0;
  fFdSnarlErrorCounter=0;
  fDigitCounter=0;
  fNdDigitCounter=0;
  fFdDigitCounter=0;
  fNdDigitErrorCounter=0;
  fNdDigitFFFFCounter=0;
  fFdDigitErrorCounter=0;

  //specific error counters
  fNdParityErrorCounter=0;
  fNdCapIdErrorCounter=0;
  fNdMisCountErrorCounter=0;
  fNdPriorityTruncateCounter=0;
  fFdAdcNegativeCounter=0;
  fFdNonStdDataCounter=0;
  fFdWarningStateCounter=0;
  fFdParityErr0Counter=0;
  fFdParityErr1Counter=0;
  fFdWordBitErr0Counter=0;
  fFdWordBitErr1Counter=0;

  //variables for cutting on snarl size
  fMinNumDigitsHit=100;
  fMinNumChannelsHit=100;

  //other
  fDetector=Detector::kUnknown;
}

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

void CDPreFilterModule::HandleCommand(JobCommand* cmd)
{

  if (cmd->HaveCmd()) {       // If we have a command...
    string sc=cmd->PopCmd();// Get the command
    
    if (sc == "PlaneTrig"){
      if(cmd->HaveOpt()){
        Int_t tempPlanes=cmd->PopIntOpt();
        if (tempPlanes==0 || tempPlanes==1){
          fplanetrig=0;//no point having a 0 or 1 out of M plane trig
        }
        else if (tempPlanes<0){
          fplanetrig=0;
          MSG("CDPreFilterModule",Msg::kWarning) 
            <<"Can't do plane trigger with negative number of planes!"
            <<" Not cutting on plane trigger"<<endl;
        }
        else{
          fplanetrig=1;
          fnplane=tempPlanes;
        }
      }
      else {
        fplanetrig=0;
        MSG("CDPreFilterModule",Msg::kWarning) 
          << "PlaneTrig command given without number of planes option."
          << " Not cutting on Plane Trigger"  << endl;
      }
      
      MSG("CDPreFilterModule",Msg::kVerbose) 
        <<"Plane trigger control flag fplanetrig="<<fplanetrig
        <<endl;
      return;
    }
    else if (sc == "BeamSpill") {
      fbeamonly=1;
      if(cmd->HaveOpt()) {
        string opt=cmd->PopOpt();
        if(opt == "yes") fbeamonly=1; 
        else if(opt == "no") fbeamonly=-1;
        else if(opt == "off") fbeamonly=0;
        else if(opt == "tof") {
          if(cmd->HaveOpt()) {
            string opt2=cmd->PopOpt();
            if(opt2 == "yes") fbeamonly=2;
            else if(opt2 == "no") fbeamonly=-2;
            else {
              MSG("CDPreFilterModule",Msg::kWarning) 
                << "Don't understand '" << opt2.c_str() << "'\n" 
                << "Module will be ignoring "<<sc.c_str()<<" triggers"
                << endl;
              fbeamonly=0;
            }
          }
          else {
            MSG("CDPreFilterModule",Msg::kWarning) 
              << "No option specified with " 
              << sc.c_str() << " " << opt.c_str() 
              << " needed for this Handle Command" 
              << "Module ignoring " << sc.c_str()<<" triggers"<<endl;
            fbeamonly=0;
          }
        }
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            <<"Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be ignoring " << sc.c_str()<<" triggers"
            <<endl;
          fbeamonly=0;
        }
      }
      return;
    }
    else if(sc == "Cerenkov") {
      fcerenkov=1;
      if(cmd->HaveOpt()){
        string opt=cmd->PopOpt();
        if(opt == "yes") fcerenkov=1; 
        else if(opt == "no") fcerenkov=-1;
        else if(opt == "off") fcerenkov=0;
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            << "Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be accepting "<<sc.c_str()<<" triggers"
            <<endl;
        }
      }
      return;
    }
    else if(sc == "LI") {
      fli=1;
      if(cmd->HaveOpt()){
        string opt=cmd->PopOpt();
        if(opt == "yes") fli=1; 
        else if(opt == "no") fli=-1;
        else if(opt == "off") fli=0;
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            << "Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be accepting "<<sc.c_str()<<" triggers"
            <<endl;
        }   
      }
      return;
    }
    else if(sc == "TOF") {
      ftof=1;
      if(cmd->HaveOpt()){
        string opt=cmd->PopOpt();
        if(opt == "yes") ftof=1; 
        else if(opt == "no") ftof=-1;
        else if(opt == "off") ftof=0;
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            << "Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be accepting "<<sc.c_str()<<" triggers"
            <<endl;
        }
      }
      return;
    }
    else if(sc == "NoDeadChips") {
      fnodeadchips=1;
      if(cmd->HaveOpt()){
        string opt=cmd->PopOpt();
        if(opt == "yes") fnodeadchips=1;
        else if(opt == "no") fnodeadchips=-1;
        else if(opt == "off") fnodeadchips=0;
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            << "Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be requiring "<<sc.c_str()<<" triggers"
            <<endl;
        }
      }
      return;
    }
    else if(sc =="NoNdErrors"){
      fNoNdErrors=1;
      if(cmd->HaveOpt()){
        string opt=cmd->PopOpt();
        if(opt == "yes") fNoNdErrors=1;
        else if(opt == "no") fNoNdErrors=-1;
        else if(opt == "off") fNoNdErrors=0;
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            << "Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be requiring "<<sc.c_str()<<endl;
        }
      }
      return;
    }
    else if(sc =="NoFdErrors"){
      fNoFdErrors=1;
      if(cmd->HaveOpt()){
        string opt=cmd->PopOpt();
        if(opt == "yes") fNoFdErrors=1;
        else if(opt == "no") fNoFdErrors=-1;
        else if(opt == "off") fNoFdErrors=0;
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            << "Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be requiring "<<sc.c_str()<<endl;
        }
      }
      return;
    }
    else if(sc =="BigSnarls"){
      fBigSnarls=1;
      if(cmd->HaveOpt()){
        string opt=cmd->PopOpt();
        if(opt == "yes") fBigSnarls=1;
        else if(opt == "no") fBigSnarls=-1;
        else if(opt == "off") fBigSnarls=0;
        else {
          MSG("CDPreFilterModule",Msg::kWarning) 
            << "Don't understand '" << opt.c_str() << "'\n" 
            <<"Module will be requiring "<<sc.c_str()<<endl;
        }
      }
      return;
    }
    else{
      MSG("CDPreFilterModule",Msg::kWarning)
        << "Don't understand '" << sc.c_str() << "'\n";
    }
  }
}

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

JobCResult CDPreFilterModule::Ana(const MomNavigator *mom) 
{
  JobCResult result(JobCResult::kPassed);

  //count every snarl that is input
  //this should stay at the top of the method
  fTotalInputCounter++;

  //the master/deciding cut variable, this MUST ONLY be set to TRUE
  //in the code below, setting it to false would override previous
  //decissions
  Bool_t rejectSnarl=false;
  //Note that the setting of "result" is mostly irrelevant
  //but it makes it clearer what passed and what failed.

  RawRecord *rr=dynamic_cast<RawRecord *>
    (mom->GetFragment("RawRecord"));
  if (rr==0) {
    MSG("CDPreFilterModule", Msg::kWarning) 
      << "No RawRecord in MOM." << endl;
    result.SetFailed();//added by JJH 12/Dec/2003
    return result;
  }

  const RawHeader* rawHdr=
    dynamic_cast<const RawHeader*>(rr->GetRawHeader());
  if(!rawHdr){
    MSG("CDPreFilterModule", Msg::kWarning) 
      << "No RawHeader in RawRecord" << endl;
    //result.SetFailed();
    //return result;
  }
  else{
    fDetector=rawHdr->GetVldContext().GetDetector();
  }

  Int_t num_tof_digits=0;
  const RawTOFBlock* tofblock=
    dynamic_cast<const RawTOFBlock*>(rr->FindRawBlock("RawTOFBlock"));
  if (tofblock) {
    num_tof_digits=tofblock->GetNumberOfDigits();
  }

  UInt_t trigword=0;
  const RawDaqSnarlHeader* snarlHdr =
    dynamic_cast<const RawDaqSnarlHeader*>(rr->GetRawHeader());
  if (snarlHdr) {
    trigword=snarlHdr->GetTrigSrc();
  }

  Int_t num_dead_chips=0;
  const RawDeadChipBlock* deadblock =
    dynamic_cast<const RawDeadChipBlock*>
    (rr->FindRawBlock("RawDeadChipBlock"));
  if(deadblock) {
    num_dead_chips=deadblock->GetNumberOfEntries();
  }

  //check the plane trigger
  if(fplanetrig==1) {
    if((trigword & 0x4) && (trigword>>8)>=fnplane)
      result.SetPassed();
    else {
      result.SetFailed();
      rejectSnarl=true;
      fPlaneTrigCounter++;
      //return result;
    }
  }
  
  //check the tof hits
  if(fbeamonly!=0) {
    if(fbeamonly==1 && (trigword & 0x80)) result.SetPassed();
    else if(fbeamonly==2 && num_tof_digits>0) result.SetPassed();
    else if(fbeamonly==-1 && !(trigword & 0x80)) result.SetPassed();
    else if(fbeamonly==-2 && num_tof_digits==0) result.SetPassed();
    else {
      result.SetFailed();
      rejectSnarl=true;
      fBeamOnlyCounter++;
      //return result;
    }
  }

  //check the cerenkov hits
  if(fcerenkov!=0) {
    if(fcerenkov==1 && 
       ((trigword & 0x10) || (trigword & 0x20) || (trigword & 0x40))){
      result.SetPassed();
    }
    else if(fcerenkov==-1 && 
            !(trigword&0x10) && !(trigword&0x20) && !(trigword&0x40)){
      result.SetPassed();
    }
    else {
      result.SetFailed();
      rejectSnarl=true;
      fCerenkovCounter++;
      //return result;
    }
  }
  
  //check the light injection
  if(fli!=0){
    if(fli==1 && (trigword & 0x2)) result.SetPassed();
    else if(fli==-1 && !(trigword & 0x2)) result.SetPassed();
    else {
      result.SetFailed();
      rejectSnarl=true;
      fLiCounter++;
      //return result;
    }
  }

  //check the tofs again??? JJH
  if(ftof!=0){
    if(ftof==1 && (trigword & 0x8)) result.SetPassed();
    else if(ftof==-1 && !(trigword & 0x8)) result.SetPassed();
    else {
      result.SetFailed();
      rejectSnarl=true;
      fTofCounter++;
      //return result;
    }
  }

  //check the dead chips
  if(fnodeadchips!=0) {
    if(fnodeadchips==1 && num_dead_chips==0) result.SetPassed();
    else if(fnodeadchips==-1 && num_dead_chips>0) result.SetPassed();
    else {
      result.SetFailed();
      rejectSnarl=true;
      fNoDeadChipsCounter++;
      //return result;
    }
  }

  //if any of the digit filters are enabled
  if (fNoNdErrors || fNoFdErrors || fBigSnarls){
    //get the raw digit data block
    const RawDigitDataBlock* rddb=dynamic_cast<const RawDigitDataBlock*>
      (rr->FindRawBlock("RawDigitDataBlock"));
    if (!rddb){
      MSG("CDPreFilterModule",Msg::kWarning) 
        <<"No RawDigitDataBlock in RawRecord"<<endl;
      //return JobCResult::kFailed;
    }
    else{
      //look at the digit errors
      if (fNoNdErrors || fNoFdErrors){
        Bool_t reject=this->FilterSnarlForErrors(rddb);
        if (reject) rejectSnarl=true;
      }
      //look at the digit size
      if (fBigSnarls){
        Bool_t reject=this->FilterOnSnarlSize(rddb);
        if (reject) rejectSnarl=true;
      }
    }
  }
  
  //gave up on this bit, you have to loop to get all the 
  //raw records and also over the raw records themselves to get
  //all the rvebs since there are 16 of them per rr!!!!

  //const RawVarcErrorInTfBlock* rveb=
  //dynamic_cast<const RawVarcErrorInTfBlock*>
  //(rr->FindRawBlock("RawVarcErrorInTfBlock"));
  //if (!rveb){
  //MAXMSG("CDPreFilterModule",Msg::kWarning,10) 
  //  <<"No RawVarcErrorInTfBlock in RawRecord"<<endl;
  //return JobCResult::kFailed;
  //}
  //else{
  //MAXMSG("CDPreFilterModule",Msg::kInfo,200) 
  //  <<"Found RawVarcErrorInTfBlock, Num SparsErrors="
  //  <<rveb->GetNumberOfSparsErrors()
  //  <<", Num EtcErrors="<<rveb->GetNumberOfEtcErrors()
  //  <<endl;
  //rveb->Print();
  //}

  //check the final result
  if (rejectSnarl){
    //fail the event
    result.SetFailed();
    //count the events failed
    fTotalFailedCounter++;
  }
  else {
    //pass the event
    result.SetPassed();
    //count the events passed
    fTotalPassedCounter++;
  }

  //return the final result
  return result;
}

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

void CDPreFilterModule::PrintFilterSummary() const
{
  MSG("CDPreFilterModule",Msg::kVerbose)
    <<"Running PrintFilterSummary method..."<<endl;


  if (fTotalInputCounter>=0){
    Int_t totalHits=0;
    totalHits=fTotalFailedCounter+fTotalPassedCounter;
    
    MSG("CDPreFilterModule",Msg::kInfo) 
      <<endl 
      <<" ** Filter Summary Information: **"<<endl
      <<"  Total snarls input="<<fTotalInputCounter<<endl
      <<"    Snarls passed="<<fTotalPassedCounter
      <<" ("<<Pct(fTotalPassedCounter,totalHits)<<"%)"<<endl      
      <<"    Snarls failed="<<fTotalFailedCounter
      <<" ("<<Pct(fTotalFailedCounter,totalHits)<<"%)"<<endl      
      <<"    Sum of hits passed or failed="<<totalHits<<endl;

    MSG("CDPreFilterModule",Msg::kInfo) 
      <<"  Data Summary:"<<endl
      <<"    PlaneTrigger cut="<<fPlaneTrigCounter
      <<" ("<<Pct(fPlaneTrigCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fplanetrig)<<")"<<endl
      <<"    BeamOnly cut="<<fBeamOnlyCounter
      <<" ("<<Pct(fBeamOnlyCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fbeamonly)<<")"<<endl
      <<"    Cerenkov cut="<<fCerenkovCounter
      <<" ("<<Pct(fCerenkovCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fcerenkov)<<")"<<endl
      <<"    NoDeadChips cut="<<fNoDeadChipsCounter
      <<" ("<<Pct(fNoDeadChipsCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fnodeadchips)<<")"<<endl
      <<"    Li cut="<<fLiCounter
      <<" ("<<Pct(fLiCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fli)<<")"<<endl
      <<"    Tof cut="<<fTofCounter
      <<" ("<<Pct(fTofCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(ftof)<<")"<<endl
      <<"    ND Error cut="<<fNoNdErrorsCounter
      <<" ("<<Pct(fNoNdErrorsCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fNoNdErrors)<<")"<<endl
      <<"    FD Error cut="<<fNoFdErrorsCounter
      <<" ("<<Pct(fNoFdErrorsCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fNoFdErrors)<<")"<<endl
      <<"    Big Snarls cut="<<fBigSnarlsCounter
      <<" ("<<Pct(fBigSnarlsCounter,totalHits)<<"%)"
      <<" ("<<GetCutStatus(fBigSnarls)<<")"<<endl;

    //now print out the errors
    if (fNoNdErrors || fNoFdErrors){
      MSG("CDPreFilterModule",Msg::kInfo) 
        <<this->GetErrorString();
    }

    MSG("CDPreFilterModule",Msg::kInfo) 
      <<" ** End of Filter Summary Information ** "<<endl; 
  }
  else {
    MSG("CDPreFilterModule",Msg::kInfo) 
      <<" ** No data input to prefilter **"<<endl<<endl;
  }

  MSG("CDPreFilterModule",Msg::kVerbose) 
    <<"Finished PrintFilterSummary method"<<endl;
}

//......................................................................
 
string CDPreFilterModule::Pct(Double_t top,Double_t bottom) const
{
  Double_t percent=-1;
  string sPercent="notset";
  if (bottom!=0){
    percent=top/bottom;
    percent*=100;
    sPercent=Form("%.1f",percent);
  }
  else{
    sPercent="fpe!";
  }
  return sPercent;
}

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

string CDPreFilterModule::SForm(Int_t number) const
{
  string sNumber="";
  sNumber=Form("%d",number);
  return sNumber;
}

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

string CDPreFilterModule::GetErrorString() const
{

  Int_t totalHits=0;
  totalHits=fTotalFailedCounter+fTotalPassedCounter;
 
  string sErrors="  Snarl Error and FFFF Summary:\n";
  string sNdErrors="";
  sNdErrors=
    "    Num ND Snarls with Errors  ="+SForm(fNdSnarlErrorCounter)+
    " ("+Pct(fNdSnarlErrorCounter,totalHits)+"%)"+"\n"
    +"      -Parity errors           ="+SForm(fNdParityErrorCounter)
    +" ("+Pct(fNdParityErrorCounter,totalHits)+"%)"+"\n"
    +"      -CapId errors            ="+SForm(fNdCapIdErrorCounter)
    +" ("+Pct(fNdCapIdErrorCounter,totalHits)+"%)"+"\n"
    +"      -MisCount errors         ="+SForm(fNdMisCountErrorCounter)
    +" ("+Pct(fNdMisCountErrorCounter,totalHits)+"%)"+"\n"
    +"      -PriorityTruncate errors ="+
    SForm(fNdPriorityTruncateCounter)
    +" ("+Pct(fNdPriorityTruncateCounter,totalHits)+"%)"+"\n"
    +"    Num ND Snarls with FFFFs   ="+SForm(fNdSnarlFFFFCounter)
    +" ("+Pct(fNdSnarlFFFFCounter,totalHits)+"%)"+"\n";
  string sFdErrors="";
  sFdErrors=
    "    Num FD Snarls (VMM<5 - if CalDet) with Errors="+
    SForm(fFdSnarlErrorCounter)
    +" ("+Pct(fFdSnarlErrorCounter,totalHits)+"%)"+"\n"
    +"      -AdcNegative errors      ="+SForm(fFdAdcNegativeCounter)
    +" ("+Pct(fFdAdcNegativeCounter,totalHits)+"%)"+"\n"
    +"      -NonStdData errors       ="+SForm(fFdNonStdDataCounter)
    +" ("+Pct(fFdNonStdDataCounter,totalHits)+"%)"+"\n"
    +"      -WarningState errors     ="+SForm(fFdWarningStateCounter)
    +" ("+Pct(fFdWarningStateCounter,totalHits)+"%)"+"\n"
    +"      -ParityErr0 errors       ="+SForm(fFdParityErr0Counter)
    +" ("+Pct(fFdParityErr0Counter,totalHits)+"%)"+"\n"
    +"      -ParityErr1 errors       ="+SForm(fFdParityErr1Counter)
    +" ("+Pct(fFdParityErr1Counter,totalHits)+"%)"+"\n"
    +"      -WordBitErr0 errors      ="+SForm(fFdWordBitErr0Counter)
    +" ("+Pct(fFdWordBitErr0Counter,totalHits)+"%)"+"\n"
    +"      -WordBitErr1 errors      ="+SForm(fFdWordBitErr1Counter)
    +" ("+Pct(fFdWordBitErr1Counter,totalHits)+"%)"+"\n";

  string sDigitErrors="";
  sDigitErrors="  Digit Error and FFFF Summary:\n";
  sDigitErrors+="    Total Number of Digits="+SForm(fDigitCounter)+"\n";

  string sFdDigits="";
  sFdDigits=
    "      -Num FD Digits="+SForm(fFdDigitCounter)
    +" ("+Pct(fFdDigitCounter,fDigitCounter)+"%)"+"\n";
  string sNdDigits="";
  sNdDigits=
    "      -Num ND Digits="+SForm(fNdDigitCounter)
    +" ("+Pct(fNdDigitCounter,fDigitCounter)+"%)"+"\n";
    
  string sFdDigitErrors="";
  sFdDigitErrors=
    "    Num FD Digits with Errors="+SForm(fFdDigitErrorCounter)
    +" ("+Pct(fFdDigitErrorCounter,fDigitCounter)+"%)"+"\n";
  string sNdDigitErrors="";
  sNdDigitErrors=
    "    Num ND Digits with Errors="+SForm(fNdDigitErrorCounter)
    +" ("+Pct(fNdDigitErrorCounter,fNdDigitCounter)+"%)"+"\n"
    +"    Num ND Digits with FFFFs="+SForm(fNdDigitFFFFCounter)
    +" ("+Pct(fNdDigitFFFFCounter,fNdDigitCounter)+"%)"+"\n";

  //work out what to print...
  if (fNoNdErrors) sErrors+=sNdErrors;
  if (fNoFdErrors) sErrors+=sFdErrors;
  sErrors+=sDigitErrors;
  if (fNoNdErrors) sErrors+=sNdDigits;
  if (fNoFdErrors) sErrors+=sFdDigits;
  if (fNoNdErrors) sErrors+=sNdDigitErrors;
  if (fNoFdErrors) sErrors+=sFdDigitErrors;

  return sErrors;
}

//......................................................................
 
string CDPreFilterModule::GetCutStatus(Int_t cut) const
{
  string status="";
  if (cut==0) status="disabled";
  else if (cut==1) status="enabled";
  else if (cut==-1) status="anti-enabled";
  else if (cut==2) status="enabled, special";
  else if (cut==-2) status="anti-enabled, special";
  else status="Cut not recognised";

  return status;
}

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

void CDPreFilterModule::EndJob() 
{
  //print what was found and what was filtered
  this->PrintFilterSummary();
}

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

Bool_t CDPreFilterModule::FilterSnarlForErrors(const 
                                               RawDigitDataBlock* rddb)
{  
  //counting snarls control variables
  Bool_t foundNdError=false;
  Bool_t foundNdFFFF=false;
  Bool_t foundFdError=false;

  //counting snarl error control variables
  Bool_t foundParityError=false;
  Bool_t foundCapIdError=false;
  Bool_t foundMisCountError=false;
  Bool_t foundPriorityTruncate=false;
  Bool_t foundAdcNegative=false;
  Bool_t foundNonStdData=false;
  Bool_t foundWarningState=false;
  Bool_t foundParityErr0=false;
  Bool_t foundParityErr1=false;
  Bool_t foundWordBitErr0=false;
  Bool_t foundWordBitErr1=false;

  TIter datit = rddb->GetDatumIter();
  while (TObject *tobd=datit()){

    //get the raw digit
    RawDigit *rd=dynamic_cast<RawDigit *>(tobd);

    //count the digits
    fDigitCounter++;

    //check the digit for errors and FFFF

    //look at far detector digits if fNoFdErrors is non-zero
    if (rd->GetChannel().GetElecType()==ElecType::kVA){
      if (fNoFdErrors){//allows to only count ND errors
        //count the FD digits
        fFdDigitCounter++;

        //check if there is an error (and that the vmm was <5 if CalDet)
        if (rd->GetErrorCode() && (rd->GetChannel().GetVmm()<5 
                                   || fDetector!=
                                   Detector::kCalDet)){

          //count the digits with errors
          fFdDigitErrorCounter++;

          //count the snarls with errors
          if (!foundFdError){
            foundFdError=true;
            fFdSnarlErrorCounter++;
          }

          //count the individual error types occurance in snarls
          Char_t errCode=rd->GetErrorCode();
          Bool_t errorRecognised=false;
          if ((errCode&0x1)==RawVaDigit::kAdcNegative){//bit0
            if (!foundAdcNegative) fFdAdcNegativeCounter++;
            foundAdcNegative=true;
            errorRecognised=true;
          }
          if ((errCode&0x2)==RawVaDigit::kNonStdData){//bit1
            if (!foundNonStdData) fFdNonStdDataCounter++;
            foundNonStdData=true;
            errorRecognised=true;
            static Int_t msgCounter=0;
            if (msgCounter<100){
              RawChannelId rcid=rd->GetChannel();
              MSG("CDPreFilterModule",Msg::kDebug)
                <<"Error: NonStdData on VA("<<rcid.GetCrate()<<","
                <<rcid.GetVarcId()<<","<<rcid.GetVmm()<<","
                <<rcid.GetVaAdcSel()<<","<<rcid.GetVaChip()<<","
                <<rcid.GetVaChannel()<<")"<<endl;
            }
            else if (msgCounter==100){
              MSG("CDPreFilterModule",Msg::kDebug)
                <<"Not printing any more NonStdData errors"<<endl;
            }
            msgCounter++;
          }
          if ((errCode&0x4)==RawVaDigit::kWarningState){//bit2
            if (!foundWarningState) fFdWarningStateCounter++;
            foundWarningState=true;
            errorRecognised=true;
          }
          if ((errCode&0x8)==RawVaDigit::kParityErr0){//bit3
            if (!foundParityErr0) fFdParityErr0Counter++;
            foundParityErr0=true;
            errorRecognised=true;

            static Int_t msgCounter=0;
            if (msgCounter<100){
              RawChannelId rcid=rd->GetChannel();
              MSG("CDPreFilterModule",Msg::kDebug)
                <<"Error: ParityErr0 on VA("<<rcid.GetCrate()<<","
                <<rcid.GetVarcId()<<","<<rcid.GetVmm()<<","
                <<rcid.GetVaAdcSel()<<","<<rcid.GetVaChip()<<","
                <<rcid.GetVaChannel()<<")"<<endl;
            }
            else if (msgCounter==100){
              MSG("CDPreFilterModule",Msg::kDebug)
                <<"Not printing any more ParityErr0 errors"<<endl;
            }
            msgCounter++;
          }
          if ((errCode&0x10)==RawVaDigit::kParityErr1){//bit4
            if (!foundParityErr1) fFdParityErr1Counter++;
            foundParityErr1=true;
            errorRecognised=true;
          }
          if ((errCode&0x20)==RawVaDigit::kWordBitErr0){//bit5
            if (!foundWordBitErr0) fFdWordBitErr0Counter++;
            foundWordBitErr0=true;
            errorRecognised=true;
          }
          if ((errCode&0x40)==RawVaDigit::kWordBitErr1){//bit6
            if (!foundWordBitErr1) fFdWordBitErr1Counter++;
            foundWordBitErr1=true;
            errorRecognised=true;
          }

          //check that the error was recognised 
          if (!errorRecognised){
            RawChannelId rcid=rd->GetChannel();
            MSG("CDPreFilterModule",Msg::kWarning)
              <<"EVaErrorCode not recognised: "
              <<static_cast<Int_t>(errCode)
              //have to cast it as it might not be a printable character
              <<" VA("<<rcid.GetCrate()<<","
              <<rcid.GetVarcId()<<","<<rcid.GetVmm()<<","
              <<rcid.GetVaAdcSel()<<","<<rcid.GetVaChip()<<","
              <<rcid.GetVaChannel()<<")"<<endl;
          }
        }
      }
    }
    //look at near detector digits if fNoNdErrors is non-zero
    else if (rd->GetChannel().GetElecType()==ElecType::kQIE){
      if (fNoNdErrors){//allows to only count FD errors
        //count the ND digits
        fNdDigitCounter++;

        //check for FFFFs
        if (rd->GetADC()==0xFFFF){
          fNdDigitFFFFCounter++;
          //count the snarls with errors
          if (!foundNdFFFF){
            foundNdFFFF=true;
            fNdSnarlFFFFCounter++;
          }
        }
      
        //check for errors
        if (rd->GetErrorCode()){

          //count the digits with errors
          fNdDigitErrorCounter++;

          //count the snarls with errors
          if (!foundNdError){
            foundNdError=true;
            fNdSnarlErrorCounter++;

            //count the individual error types occurance in snarls
            Char_t errCode=rd->GetErrorCode();
            Bool_t errorRecognised=false;
            if ((errCode&0x1)==RawQieDigit::kParityError){//bit0
              if (!foundParityError) fNdParityErrorCounter++;
              foundParityError=true;
              errorRecognised=true;
            }
            if ((errCode&0x2)==RawQieDigit::kCapIdError){//bit1
              if (!foundCapIdError) fNdCapIdErrorCounter++;
              foundCapIdError=true;
              errorRecognised=true;
              static Int_t msgCounter=0;
              if (msgCounter<100){
                RawChannelId rcid=rd->GetChannel();
                MSG("CDPreFilterModule",Msg::kDebug)
                  <<"Error: CapIdError on QIE("
                  <<rcid.GetCrate()<<","
                  <<rcid.GetGeographicAddress()<<","
                  <<rcid.GetMasterChannel()<<","
                  <<rcid.GetMinderChannel()<<")"<<endl;
              }
              else if (msgCounter==100){
                MSG("CDPreFilterModule",Msg::kDebug)
                  <<"Not printing any more CapId errors"<<endl;
              }
              msgCounter++;
            }
            if ((errCode&0x4)==RawQieDigit::kMisCountError){//bit2
              if (!foundMisCountError) fNdMisCountErrorCounter++;
              foundMisCountError=true;
              errorRecognised=true;
            }
            if ((errCode&0x8)==RawQieDigit::kPriorityTruncate){//bit3
              if (!foundPriorityTruncate) fNdPriorityTruncateCounter++;
              foundPriorityTruncate=true;
              errorRecognised=true;
            }

            if (!errorRecognised){
              RawChannelId rcid=rd->GetChannel();
              MSG("CDPreFilterModule",Msg::kWarning)
                <<"EQieErrorCode not recognised: "
                <<static_cast<Int_t>(errCode)
                <<" QIE("
                <<rcid.GetCrate()<<","
                <<rcid.GetGeographicAddress()<<","
                <<rcid.GetMasterChannel()<<","
                <<rcid.GetMinderChannel()<<")"<<endl;
            }
          }
          //check the type of error here as well
          //
        }
      }
    }
    else{
      MSG("CDPreFilterModule",Msg::kWarning)
        <<"ElecType not recognised: "
        <<ElecType::AsString(rd->GetChannel().GetElecType())<<endl;
    }
  }

  //Section to actually reject the snarls based on the errors

  Bool_t rejectSnarl=false;

  //check the ND errors
  //only pass snarls without errors
  if (fNoNdErrors==1){
    if (foundNdError || foundNdFFFF) rejectSnarl=true;
    if (rejectSnarl) fNoNdErrorsCounter++;

    MSG("CDPreFilterModule",Msg::kVerbose)
      <<"enabled, foundNdError="<<foundNdError
      <<", foundNdFFFF="<<foundNdFFFF<<", reject="<<rejectSnarl
      <<", counter="<<fNoNdErrorsCounter<<endl;
  }
  //if anti-enabled only pass snarls WITH errors
  else if (fNoNdErrors==-1){
    //don't reject if found an error, only reject with errors!
    if (!foundNdError && !foundNdFFFF) rejectSnarl=true;
    if (rejectSnarl) fNoNdErrorsCounter++;

    MSG("CDPreFilterModule",Msg::kVerbose)
      <<"anti-enabled, foundNdError="<<foundNdError
      <<", foundNdFFFF="<<foundNdFFFF<<", reject="<<rejectSnarl
      <<", counter="<<fNoNdErrorsCounter<<endl;
  }
  else if (fNoNdErrors==0){
    //don't do anything in this case
  }
  else {
    MSG("CDPreFilterModule",Msg::kWarning)
      <<"Not cutting on NoNdErrors"
      <<", control variable value not recognised: "
      <<"fNoNdErrors="<<fNoNdErrors<<endl;
  } 

  //check the FD errors
  //only pass snarls without errors
  if (fNoFdErrors==1){
    if (foundFdError){
      rejectSnarl=true;
      fNoFdErrorsCounter++;
    }
  }
  //if anti-enabled only pass snarls WITH errors
  else if (fNoFdErrors==-1){
    if (!foundFdError){
      rejectSnarl=true;
      fNoFdErrorsCounter++;
    }
  }
  else if (fNoFdErrors==0){
    //don't do anything in this case
  }
  else {
    MSG("CDPreFilterModule",Msg::kWarning)
      <<"Not cutting on NoFdErrors"
      <<", control variable value not recognised: "
      <<"fNoFdErrors="<<fNoFdErrors<<endl;
  }

  //return the decision
  return rejectSnarl;
}

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

Bool_t CDPreFilterModule::FilterOnSnarlSize(const 
                                            RawDigitDataBlock* rddb)
{  
  Bool_t rejectSnarl=false;

  //variables to be evaluated before filtering the snarl
  Bool_t lowNumDigits=false;
  Bool_t lowNumChannels=false;
  Bool_t highNumDigits=false;
  Bool_t highNumChannels=false;

  //check snarl initially on the number of digits (buckets+vaHits)
  if (rddb->GetNumberOfDigits()<static_cast<Int_t>(fMinNumDigitsHit)){
    lowNumDigits=true;
  }
  //check that snarls over fMinNumDigitsHit satisfy the channel cut
  else{
    highNumDigits=true;

    //variables for counting up the hits
    map<UInt_t,UInt_t> qieChannelsHit;
    UInt_t vaChannelsHit=0;
    UInt_t qieDigitCounter=0;
    UInt_t vaDigitCounter=0;

    //loop over digits
    TIter datit = rddb->GetDatumIter();
    while (TObject *tobd=datit()){
      
      //get the raw digit
      RawDigit *rd=dynamic_cast<RawDigit *>(tobd);

      //count the hits
      if (rd->GetChannel().GetElecType()==ElecType::kQIE){
        //count up the buckets
        qieChannelsHit[rd->GetChannel().GetEncoded()]++;
        qieDigitCounter++;
      }
      else if (rd->GetChannel().GetElecType()==ElecType::kVA){
        //only count the scint channels at CalDet
        if (rd->GetChannel().GetVmm()<5 || 
            fDetector!=Detector::kCalDet){
          vaChannelsHit++;
          vaDigitCounter++;
        }
      }
      else{
        MSG("CDPreFilterModule",Msg::kWarning)
          <<"ElecType not recognised: "
          <<ElecType::AsString(rd->GetChannel().GetElecType())<<endl;
      }
    }

    //check the number of channels
    if (vaChannelsHit+qieChannelsHit.size()<fMinNumChannelsHit){
      lowNumChannels=true;

      //print message
      static Int_t msgCounter=0;
      if (msgCounter<100){
        MSG("CDPreFilterModule",Msg::kDebug)
          <<"Snarl with low num channels: vaCh="<<vaChannelsHit
          <<", qieCh="<<qieChannelsHit.size()
          <<", totalDig="<<rddb->GetNumberOfDigits()
          <<", vaDig="<<vaDigitCounter
          <<", qieDig="<<qieDigitCounter
          <<endl;
      }
      else if (msgCounter==100){
        MSG("CDPreFilterModule",Msg::kDebug)
          <<"Not printing any more snarls with low num channels"<<endl;
      }
      msgCounter++;
    }
    else{
      highNumChannels=true;
    }
  }

  //Section to actually reject the snarls based on the sizes

  //only reject the snarl if the cut 
  //is enabled (1) not anti-enabled (-1)
  if (fBigSnarls==1){
    if (lowNumDigits || lowNumChannels) rejectSnarl=true;
  }
  //check if the cut is anti-enabled (-1) rather than enabled (1)
  //so here you cut on snarls over fMinNumDigitsHit & fMinNumChannelsHit
  else if (fBigSnarls==-1){
    if (highNumDigits || highNumChannels) rejectSnarl=true;
  }
  else {
    MSG("CDPreFilterModule",Msg::kWarning)
      <<"Not cutting on BigSnarls"
      <<", control variable value not recognised: "
      <<"fBigSnarls="<<fBigSnarls<<endl;
  }

  //count the rejected snarls
  if (rejectSnarl) fBigSnarlsCounter++;

  //return the result
  return rejectSnarl;
}

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

const Registry& CDPreFilterModule::DefaultConfig() const
{

  MSG("CDPreFilterModule", Msg::kDebug)
    << "Running CDPreFilterModule::DefaultConfig..." << endl;
    
  static Registry r;

  string name=this->JobCModule::GetName();
  name+=".config.default";
  r.SetName(name.c_str());
  r.UnLockValues();

  r.Set("MinNumDigitsHit",0);
  r.Set("MinNumChannelsHit",0);

  r.LockValues();

  return r;
}

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

void CDPreFilterModule::Config(const Registry &r)
{

  MSG("CDPreFilterModule", Msg::kDebug) 
    <<"CDPreFilterModule::Config"<<endl;

  Int_t temp=0;

  temp=0;
  //set fMinNumDigitsHit
  if (r.Get("MinNumDigitsHit",temp)) {
    fMinNumDigitsHit=temp;
  }

  temp=0;
  //set fMinNumChannelsHit
  if (r.Get("MinNumChannelsHit",temp)) {
    fMinNumChannelsHit=temp;
  }
}

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

---