Cutter.cxx

Go to the documentation of this file.

/**************************************************************************/
/*   A CLASS TO MAKE CUTS ON EVENTS                                       */
/*   PATRICIA VAHLE                                                       */
/*   DECEMBER 14, 2001                                                    */
/**************************************************************************/

#include <algorithm>

#include "TCanvas.h"
#include "TAxis.h"
#include "TText.h"
#include "TFile.h"

#include "MinosObjectMap/MomNavigator.h"
#include "JobControl/JobCResult.h"
#include "JobControl/JobCModuleRegistry.h" // JOBMODULE registration macro
#include "JobControl/JobCommand.h"
#include "MessageService/MsgService.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawDigit.h"
#include "RawData/RawDaqHeader.h"
#include "Conventions/ElecType.h"
#include <sstream>
#include "Plex/PlexHandle.h"
#include "OnlineUtil/mdBlockDefinitions.h"
#include "CalDetSI/Cutter.h"
#include "CalDetSI/Helpers.h"

//some scripts that must be here
CVSID("$Id: Cutter.cxx,v 1.11 2007/11/11 09:13:18 rhatcher Exp $");
JOBMODULE(Cutter,"Cutter","A module to apply basic cuts to CalDet data\n");

Cutter::Cutter(): 
  fSparseErrCut(true),
  fFafErrCut(true),
  fTrigCut(true),  
  fTPMTCut(false),
  fCCCut(false),
  fDCCut(true), 
  fOSCut(false),      
  fKovCut(false),
  fTOFCut(false),
  fTOFTrigCut(false),
  fKov1TrigCut(false),
  fKov2TrigCut(false),
  fKov3TrigCut(false),
  fKovORTrigCut(false),
  fAllKovTrigCut(false),
  fLITrigCut(true),
  fPIDOrTrigCut(false),
  fDeadKovCut(true),
  fNDErrorCut(true),
  fDrawHist(false),
  fWriteHist(false),
  fWait(false),
  fCutsSet(false),

  fKovADCCutLow1(1),
  fKovADCCutHigh1(60000),
  fKovADCCutLow2(1),
  fKovADCCutHigh2(60000),
  fKovADCCutLow3(1),
  fKovADCCutHigh3(60000),
  fDCPlaneCut(15),
  fMinOST(20000),
  
  fFrequency(100),
  fCounter(0),
  fFileName("cuts.root"),
  fRunNumber(0),
  fRR(0),
  fCCDH(0),
  fCutHistogram("CutHistogram","CutHistogram",fNCuts+1,0,fNCuts+1),
  fCanvas("can","can"),
  fChipsToCut(),
  fFilledChipsToCut(false)
  

{
  fCanvas.SetGridx(1);
  fCanvas.SetLogy(1);
  fCutHistogram.SetNdivisions(510);


  for(int i=0;i<fNCuts+1;i++){
    fBinLabel[i] = "";
  }


  MSG("Cutter",Msg::kDebug)<<"Creating Cutter"<<endl;
}

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

//destructor, do nothing
Cutter::~Cutter() {MSG("Cutter",Msg::kDebug)<<"Killing Cutter"<<endl;}

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

JobCResult Cutter::Get(MomNavigator *mom)
{
  //  MSG("Cutter",Msg::kDebug)<<"Called Cutter::Get"<<endl;

  //ask mom for a RawRecord
  fRR = dynamic_cast<RawRecord *>(mom->GetFragment("RawRecord"));
  if(fRR==0){ //couldn't get a rawrecord
    MSG("Cutter", Msg::kError)<<"Could not retrieve a RawRecord from Mom"<<endl;
    return JobCResult(JobCResult::kFailed);
  }
  if(fRR->FindRawBlock("RawDigitDataBlock")==0){
     MSG("Cutter", Msg::kError)<<"Not a RawDigitDataBlock"<<endl;
     return JobCResult(JobCResult::kFailed);
  }

  //ask mom for a candrecord
  CandRecord *cr = dynamic_cast<CandRecord *>(mom->GetFragment("CandRecord"));
  if(cr==0){
    return JobCResult(JobCResult::kFailed);
  }

  //get the candcaldetsihandle from the candrecord
  fCCDH = dynamic_cast<CandCalDetSIHandle *>(cr->FindCandHandle("CandCalDetSIHandle"));
  if(fCCDH==0){ //couldn't get a CandCalDetSIHandle
    MSG("Cutter", Msg::kError)<<"Could not retrieve a CandCalDetSIHandle from Mom"<<endl;
    return JobCResult(JobCResult::kFailed);
  }

  if(!fFilledChipsToCut){
       FillChipsToCut();
       fFilledChipsToCut=true;
  }

  return JobCResult(JobCResult::kPassed);  //success in retrieving a raw record and CandCalDetSIHandle
} //end of Get

//------------------------------------------------------------------------------
                         
JobCResult Cutter::Ana(const MomNavigator* /* mom */)
{

  //  MSG("Cutter",Msg::kDebug)<<"Called Cutter::Ana"<<endl;

  //Note: all cuts return true if event passes cut
  if(!fCutsSet){
    SetCuts();
    fCutsSet=true;
  }

  if(fRunNumber==0){
    MSG("Cutter",Msg::kDebug)<<"Trying to get RunNumber"<<endl;
    const RawDaqHeader* daqhead = 
      dynamic_cast <const RawDaqHeader *>(fRR->GetRawHeader());
    if(daqhead){
      fRunNumber = daqhead->GetRun();
      MSG("Cutter",Msg::kDebug)<<fRunNumber<<endl;
    }
  }
  fCounter++;

  int CutNum = 1;
  int AllPassed = 0;

  if(fDrawHist){
    if(fCounter%fFrequency==0){
      DrawCutHistogram();
    }
  }
 
  if(fCounter%10000==0){
    MSG("Cutter",Msg::kInfo)<<"On Snarl "<<fCCDH->GetSnarl()<<endl;
  }

  for(int i=0;i<fNCuts;i++){
    if(!(this->*fCutList[i])()){
      fCutHistogram.Fill(CutNum+.5);
      MSG("Cutter",Msg::kDebug)<<fBinLabel[i+1]<<" Fail"<<endl;
      return JobCResult::kFailed;
    }
    CutNum++;
  }//end loop over cuts


  fCutHistogram.Fill(AllPassed+.5);
  MSG("Cutter",Msg::kDebug)<<"Passed all cuts"<<endl;
  if(fWait){ //if we want to wait before continuing
    MSG("Cutter", Msg::kInfo)<<"After viewing, hit any key to continue"<<endl
                             <<"--------------------------------------"<<endl;
   
    char c;
    cin>>c;
  }
  return JobCResult(JobCResult::kPassed);

} //end of Ana

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


//A method that cuts out dead chips 
bool Cutter::DeadChipCutter() const
{
  if(fCCDH->GetDeadChips().size()==0){ //if there are no chips in the vector, 
    return true; //passes cut
  }

/*  
  const VldContext *vldc = fRR->GetVldContext(); //get Validity context
  PlexHandle ph(*vldc);  //use validity context to get a plex handle
  MSG("Cutter",Msg::kDebug)<<"Validity context "<<*vldc<<endl;
  for(UShort_t i=0; i<(fCCDH->GetDeadChips()).size();i++){
    Int_t crate = (fCCDH->GetDeadChips())[i].GetCrate();
    Int_t varc = (fCCDH->GetDeadChips())[i].GetVarcId();
    Int_t vmm = (fCCDH->GetDeadChips())[i].GetVmm();
    Int_t vaadc = (fCCDH->GetDeadChips())[i].GetVaAdcSel();
    Int_t chip = (fCCDH->GetDeadChips())[i].GetVaChip();
    MSG("Cutter",Msg::kDebug)<<"Dead Chips"<<endl
                             <<varc<<","<<vmm<<","<<vaadc<<","<<vaadc<<","<<chip<<endl;
    //create new channel Id with a valid channel 
    //channel 0 is given in the DeadChip vector, but is not mapped to a plane-strip 
    const RawChannelId newchan(Detector::kCalDet, 
                               ElecType::kVA, crate,varc, vmm, vaadc, chip, 2, kFALSE, kFALSE);
    PlexStripEndId pse = ph.GetSEIdAltL(newchan).GetBestSEId(); //use ph to get stripendid
    int plane = pse.GetPlane(); //use stripend id to get plane
    MSG("Cutter",Msg::kDebug)<<"Plane: "<<plane<<" Cut "<<fDCPlaneCut<<endl;
    if(plane<fDCPlaneCut){// if there is a dead chip in a plane less than fDCPlaneCut
      return false; //fails cut
    }
    if(chip==1){ //chip 1 spans two different planes, channel 5 goes to the other plane
      const RawChannelId newchan(Detector::kCalDet, 
                               ElecType::kVA, crate,varc, vmm, vaadc, chip, 5, kFALSE, kFALSE);
      PlexStripEndId pse = ph.GetSEIdAltL(newchan).GetBestSEId(); //use ph to get stripendid
      int plane = pse.GetPlane(); //use stripend id to get plane
      MSG("Cutter",Msg::kDebug)<<"Plane: "<<plane<<" Cut "<<fDCPlaneCut<<endl;
      if(plane<fDCPlaneCut){// if there is a dead chip in a plane less than fDCPlaneCut
        return false; //fails cut
      }
    }
      
  }//end loop over vector elements
        
*/

  
  MSG("Cutter",Msg::kDebug)<<"Looking for DEAD CHIPS "<<endl;
/*
  vector<const RawChannelId>::iterator dcit = fCCDH->GetDeadChips().begin();
  while(dcit!=fCCDH->GetDeadChips().end()){
    MSG("Cutter",Msg::kDebug)<<*dcit<<endl;
    dcit++;
  }
  MSG("Cutter",Msg::kDebug)<<"In the following list "<<endl;
  set<RawChannelId>::iterator ctcit = fChipsToCut.begin();
  while(ctcit!=fChipsToCut.end()){
    MSG("Cutter",Msg::kDebug)<<*ctcit<<endl;
    ctcit++;
  }
*/
  MSG("Cutter",Msg::kDebug)<<"The dead chips are:"<<endl;;
  for(unsigned int i=0;i<fCCDH->GetDeadChips().size();i++){
     MSG("Cutter",Msg::kDebug)<<fCCDH->GetDeadChips()[i]<<endl;
  }
  
  std::set<RawChannelId>::iterator ctci(fChipsToCut.begin());
  MSG("Cutter",Msg::kDebug)<<"The chips in the list of chips to cut are:"<<endl;
  while(ctci!=fChipsToCut.end()){
     MSG("Cutter",Msg::kDebug)<<*ctci<<endl;
     ctci++;
  }

  if(find_first_of(fChipsToCut.begin(),
                    fChipsToCut.end(), 
                    fCCDH->GetDeadChips().begin(), 
                    fCCDH->GetDeadChips().end())!= fChipsToCut.end())
     {

       MSG("Cutter",Msg::kDebug)<<"FOUND DEAD CHIPS "<<endl
                                <<"Size of DCVector "<<fCCDH->GetDeadChips().size()
                                <<" first entry "<<(fCCDH->GetDeadChips())[0]
                                <<endl;
       MSG("Cutter",Msg::kDebug)<<"Dead chips "
                                <<*find_first_of(fChipsToCut.begin(),
                                                 fChipsToCut.end(),
                                                 fCCDH->GetDeadChips().begin(), 
                                                 fCCDH->GetDeadChips().end())
                                <<endl;
       return false;
     }
   
  
      
  return true; //no dead chips, passes cut
}//End DeadChipCutter()
//______________________________________________________________________________

bool Cutter::DeadKovCutter() const
{

  if(fCCDH->GetDeadChips().size()==0){ //if there are no chips in the vector, 
    return true; //passes cut
  }

  vector<RawChannelId>::const_iterator it(fCCDH->GetDeadChips().begin());
  while(it!=fCCDH->GetDeadChips().end()){
     if(it->GetElecType()==ElecType::kVA
        &&fCCDH->GetCerenkovChannel1()==ElecType::kVA){
        if(it->IsSameVAChip(fCCDH->GetCerenkovChannel1())){
           return false;
        }
     }
     else if(it->GetElecType()==ElecType::kQIE
             &&fCCDH->GetCerenkovChannel1()==ElecType::kQIE){
        if(it->IsSameChannel(fCCDH->GetCerenkovChannel1())){
           return false;
        }
     }
     if(it->GetElecType()==ElecType::kVA
        &&fCCDH->GetCerenkovChannel2()==ElecType::kVA){
        if(it->IsSameVAChip(fCCDH->GetCerenkovChannel2())){
           return false;
        }
     }
     else if(it->GetElecType()==ElecType::kQIE
             &&fCCDH->GetCerenkovChannel2()==ElecType::kQIE){
        if(it->IsSameChannel(fCCDH->GetCerenkovChannel2())){
           return false;
        }
     }
     if(it->GetElecType()==ElecType::kVA
        &&fCCDH->GetCerenkovChannel3()==ElecType::kVA){
        if(it->IsSameVAChip(fCCDH->GetCerenkovChannel3())){
           return false;
        }
     }
     else if(it->GetElecType()==ElecType::kQIE
             &&fCCDH->GetCerenkovChannel3()==ElecType::kQIE){
        if(it->IsSameChannel(fCCDH->GetCerenkovChannel3())){
           return false;
        }
     }

    it++;
  }
  
  return true;
  
}//End DeadKovCutter
//--------------------------------------------------------------------------------

//A method that cuts out over shoot chips
bool Cutter::OverShootCutter() const
{
  TIter rbi = fRR->GetRawBlockIter();

  while(TObject* obj = rbi.Next()){
    //cast iterator object to a RawDataBlock
    const RawDataBlock* rdb=dynamic_cast<RawDataBlock *>(obj);
    if(rdb==0){ //if cast fails
      continue;
    }
    //Get the RawBlockID
/*
    RawBlockId bid=rdb->GetBlockId();
    int maj=bid.GetMajor();
*/
     //Compare result of GetMajor to kMdBlockCrateReadout
    if(rdb->GetBlockId().GetMajor()==kMdBlockCrateReadout){ 
      //if we find a datablock, cast to a RawDigitDataBlock
      const RawDigitDataBlock* data = dynamic_cast<RawDigitDataBlock *>(obj);
      if(data==0){ //if cast doesn't work
        continue;
      }
      Int_t NDigits = data->GetNumberOfDigits();
      for(Int_t i=0;i<NDigits;i++){ //iterate over digits in the snarl
/*
        const RawDigit *digit = data->At(i);
        RawChannelId cid = digit->GetChannel();
        
        map<RawChannelId, Int_t>::const_iterator mit=fCCDH->GetUnderShootChips().begin();
        while(mit!=fCCDH->GetUnderShootChips().end()){
          MSG("Cutter",Msg::kDebug)<<"UnderShoot Chips"<<" "
                                   <<mit->first.GetCrate()<<","<<mit->first.GetVarcId()
                                   <<","<<mit->first.GetVaAdcSel()<<","<<mit->first.GetVaChip()
                                   <<","<<mit->first.GetVaChannel()<<" ticks "<<mit->second<<endl
                                   <<"This Chip"<<" "
                                   <<cid.GetCrate()<<","<<cid.GetVarcId()
                                   <<","<<cid.GetVaAdcSel()<<","<<cid.GetVaChip()
                                   <<","<<cid.GetVaChannel()<<" ticks "<<mit->second<<endl;
          if(cid.GetChAdd()==mit->first.GetChAdd()){ //if current chan. id is in Undershoot map
            MSG("Cutter",Msg::kDebug)<<"Found matching Chips"<<endl;
            MSG("Cutter",Msg::kDebug)<<"Ticks "<<mit->second<<" cut "<<fMinOST<<endl;
            if(mit->second<fMinOST){ //compare time of Undershoot to cut value
              MSG("Cutter",Msg::kDebug)<<"Failed time cut"<<endl;
              return false; //there is a chip in the undershoot period
            }
          }

          mit++;
        }//end iteration on UnderShoot map
*/

// This should be much more efficient that iterating through the map
// (log(n) vs n) where n = # overshoot chips
// one could add the debugging output back in if desired
         map<RawChannelId, Int_t>::const_iterator mit =
              fCCDH->GetUnderShootChips().find(data->At(i)->GetChannel());
         if(mit==fCCDH->GetUnderShootChips().end() || mit->second>fMinOST) {}// do nothing
         else return false; // fail this snarl

        
      }//end loop on snarl digits
    }//end if kMdBlockCrateReadout
  }//end iteration over raw blocks

  return true;

}

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

void Cutter::DrawCutHistogram()
{
  fCanvas.cd();
  fCutHistogram.Draw();
  TText t;
  t.SetTextAngle(90);
  t.SetTextSize(.035);
  t.SetTextAlign(33);
//  t.SetTextFont(12);
  Float_t y = (fCanvas.GetUymax()+fCanvas.GetUymin())/2.;
  for(int i=0;i<fCutHistogram.GetNbinsX();i++){
    const char* temp = fBinLabel[i].c_str();
    char name[100];
    strcpy(name, temp);
    Float_t x = fCutHistogram.GetXaxis()->GetBinCenter(i+1);
    MSG("Cutter",Msg::kDebug)<<"*"<<name<<endl;
    t.DrawText(x,y,name);
  }
//  fCanvas.Update();
  
}//end DrawCutHistogram

//____________________________________________________________________________

void Cutter::WriteCutHistogram()
{


//  stringstream fn;
//  fn << "cuts-" << fRunNumber << ".root" << '\0';
//  fn >> fFileName;
  const char* fname = fFileName.c_str();
  TFile f(fname, "RECREATE");
  if(!f.IsOpen()){
    MSG("Cutter",Msg::kError) << "Could not open " << fname
                              << " for writing Cut Histogram" << endl;
    return;
  }
  MSG("Cutter",Msg::kInfo) <<"Writing cut hists to " << fname<<endl;


  fCanvas.Update();
  f.cd();
  fCutHistogram.Write();
  fCanvas.Write();
  f.Close();

  return;


}//end WriteCutHistogram()

//_______________________________________________________________________________

void Cutter::HandleCommand(JobCommand *cmd)
{

  const char* c = cmd->PopCmd();
  if (c) {
    string sc(c);
    //  if(sc == "SetCutList"){
    //SetCutList();
    //}
    if(sc == "Wait"){
      fWait = true;
    }

    if(sc == "NoWait"){
      fWait = false;
    }

    if (sc == "SetDrawFreq") {
      fDrawHist = true;
      fFrequency = atoi(cmd->PopOpt());
    }

    if(sc == "SetFileName"){
      fFileName = cmd->PopOpt();
    }

    if(sc == "WriteHistogram"){
      WriteCutHistogram();
    }
    
    if(sc == "DrawHistogram"){
      DrawCutHistogram();
    }

    if(sc == "CutON"){
      string cutname = cmd->PopOpt();
      if(cutname == "SparseErrCut"){
        fSparseErrCut=true;
      }
      if(cutname == "FafErrCut"){
        fFafErrCut=true;
      }
      if(cutname == "TrigCut"){
        fTrigCut=true;
      }
      if(cutname == "TriggerPMTCut"){
        //cout<<"Setting TriggerPMTCUT to true"<<endl;
        fTPMTCut=true;
      }
      if(cutname == "CosmicCntCut"){
        fCCCut=true;
      }
      if(cutname == "DeadChipCut"){
        fDCCut=true;
      }
      if(cutname == "UnderShootCut"){
        fOSCut=true;
      }
      if(cutname == "KovCut1"){
        fKovCut=true;
        fKovADCCutLow1 = atoi(cmd->PopOpt());
        fKovADCCutHigh1 = atoi(cmd->PopOpt());
      }
      if(cutname == "KovCut2"){
        fKovCut=true;
        fKovADCCutLow2 = atoi(cmd->PopOpt());
        fKovADCCutHigh2 = atoi(cmd->PopOpt());
      }
      if(cutname == "TOFCut"){
        fTOFCut=true;
      }
      if(cutname == "TOFTrigCut"){
        fTOFTrigCut=true;
      }
      if(cutname=="Kov1TrigCut"){
        fKov1TrigCut=true;
      }
      if(cutname=="Kov2TrigCut"){
        fKov2TrigCut=true;
      }
      if(cutname=="Kov3TrigCut"){
        fKov3TrigCut=true;
      }
      if(cutname=="KovORTrigCut"){
        fKovORTrigCut=true;
      }
      if(cutname=="AllKovTrigCut"){
        fAllKovTrigCut = true;
      }
      if(cutname=="PIDOrTrigCut"){
        fPIDOrTrigCut = true;
      }
      if(cutname=="LITrigCut"){
        fLITrigCut = true;
      }
      if(cutname == "NDErrorCut"){
        fNDErrorCut=true;
      }
    }//end cuton
    
    if(sc == "SetCutValue"){
      string cutname = cmd->PopOpt();
      if(cutname == "DeadChipCut"){
        fDCPlaneCut = atoi(cmd->PopOpt());
      }
      if(cutname == "UnderShootCut"){
        fMinOST = atoi(cmd->PopOpt());
      }
    }//end setcutvalue

    if(sc == "CutOFF"){
      string cutname = cmd->PopOpt();
      if(cutname == "SparseErrCut"){
        fSparseErrCut=false;
      }
      if(cutname == "FafErrCut"){
        fFafErrCut=false;
      }
      if(cutname == "TrigCut"){
        fTrigCut=false;
      }
      if(cutname == "TriggerPMTCut"){
        fTPMTCut=false;
      }
      if(cutname == "CosmicCntCut"){
        fCCCut=false;
      }
      if(cutname == "DeadChipCut"){
        fDCCut=false;
      }
      if(cutname == "UnderShootCut"){
        fOSCut=false;
      }
      if(cutname == "KovCut"){
        fKovCut=false;
      }
      if(cutname == "TOFCut"){
        fTOFCut=false;
      }
      if(cutname == "TOFTrigCut"){
        fTOFTrigCut=false;
      }
      if(cutname=="Kov1TrigCut"){
        fKov1TrigCut=false;
      }
      if(cutname=="Kov2TrigCut"){
        fKov2TrigCut=false;
      }
      if(cutname=="Kov3TrigCut"){
        fKov2TrigCut=false;
      }
      if(cutname=="KovORTrigCut"){
        fKov2TrigCut=false;
      }
      if(cutname=="AllKovTrigCut"){
        fAllKovTrigCut = false;
      }
      if(cutname=="PIDOrTrigCut"){
        fPIDOrTrigCut = false;
      }
      if(cutname=="LITrigCut"){
        fLITrigCut = false;
      }
      if(cutname == "NDErrorCut"){
        fNDErrorCut=false;
      }


    }//end cutoff

  }//end commandcheck
  return;
}//end HandleCommand

//_______________________________________________________________________________

void Cutter::SetCuts()
{

  MSG("Cutter",Msg::kInfo)<<"THE CUTS ARE SET AS FOLLOWS:"<<endl
                          <<"____________________________"<<endl
                          <<"Dead Chip Cut "<<(int)fDCCut<<" Less than plane "<<fDCPlaneCut<<endl                        
                          <<"UnderShoot Cut "<<(int)fOSCut<<" more than "<<fMinOST<<" ticks"<<endl
                          <<"SparseErrCut "<<(int)fSparseErrCut<<endl
                          <<"FafErrCut "<<(int)fFafErrCut<<endl
                          <<"KovCut "<<(int)fKovCut<<endl
                          <<"TOFCut "<<(int)fTOFCut<<endl
                          <<"TrigCut "<<(int)fTrigCut<<endl
                          <<"TOFTrigCut"<<(int)fTOFTrigCut<<endl
                          <<"Kov1TrigCut"<<(int)fKov1TrigCut<<endl
                          <<"Kov2TrigCut"<<(int)fKov2TrigCut<<endl
                          <<"Kov3TrigCut"<<(int)fKov3TrigCut<<endl
                          <<"KovORTrigCut"<<(int)fKovORTrigCut<<endl
                          <<"AllKovTrigCut"<<(int)fAllKovTrigCut<<endl
                          <<"CosmicCntCut "<<(int)fCCCut<<endl          
                          <<"TriggerPMTCut "<<(int)fTPMTCut<<endl
                          <<"LITriggerCut "<<(int)fLITrigCut<<endl
                          <<"PIDOrTrigCut "<<(int)fPIDOrTrigCut<<endl
                          <<"DeadKovCut "<<(int)fDeadKovCut<<endl
                          <<"NDErrorCut "<<(int)fNDErrorCut<<endl;

  fBinLabel[0] = "PA";
  if(fTrigCut){
    fCutList[0] = &Cutter::TriggerCutter;
    fBinLabel[1] = "Trig";
  }
  else{
    fCutList[0] = &Cutter::DummyCutter;
  }

  if(fTOFTrigCut){
    fCutList[1] = &Cutter::TOFTrigCutter;
    fBinLabel[2] = "TOFTrig";
  }
  else{
        fCutList[1] = &Cutter::DummyCutter;
  }

  if(fKov1TrigCut){
    fCutList[2] = &Cutter::Kov1TrigCutter;
    fBinLabel[3] = "Kov1Trig";
  }
  else{
    fCutList[2] = &Cutter::DummyCutter;
  }

  if(fKov2TrigCut){
    fCutList[3] = &Cutter::Kov2TrigCutter;
    fBinLabel[4] = "Kov2Trig";    
  }
  else{
    fCutList[3] = &Cutter::DummyCutter;
  }

  if(fKov3TrigCut){
    fCutList[4] = &Cutter::Kov3TrigCutter;
    fBinLabel[5] = "Kov3Trig";    
  }
  else{
    fCutList[4] = &Cutter::DummyCutter;
  }

  if(fKovORTrigCut){
    fCutList[5] = &Cutter::KovORTrigCutter;
    fBinLabel[6] = "KovORTrig";    
  }
  else{
    fCutList[5] = &Cutter::DummyCutter;
  }

  if(fAllKovTrigCut){
    fCutList[6] = &Cutter::AllKovTrigCutter;
    fBinLabel[7] = "AllKovTrig";
  }
  else{
    fCutList[6] = &Cutter::DummyCutter;
  }

  if(fPIDOrTrigCut){
    fCutList[7] = &Cutter::PIDOrTrigCutter;
    fBinLabel[8] = "PIDTrig";
  }
  else{
    fCutList[7] = &Cutter::DummyCutter;
  }

  if(fLITrigCut){
    fCutList[8] = &Cutter::LITrigCutter;
    fBinLabel[9] = "LITrig";
  }
  else{
    fCutList[8] = &Cutter::DummyCutter;
  }

  if(fDCCut){
    fCutList[9] = &Cutter::DeadChipCutter;
    fBinLabel[10] = "DC";
  }
  else{
    fCutList[9] = &Cutter::DummyCutter;
  }

  if(fKovCut){
    fCutList[10]=&Cutter::KovCutter;
    fBinLabel[11] = "Kov";    
  }
  else{
    fCutList[10] = &Cutter::DummyCutter;
  }

  if(fSparseErrCut){
    fCutList[11] = &Cutter::SparseErrorCutter;
    fBinLabel[12] = "SE";     
  }
  else{
    fCutList[11] = &Cutter::DummyCutter;
  }

  if(fFafErrCut){
    fCutList[12] = &Cutter::FafErrorCutter;
    fBinLabel[13] = "Faf";
  }  
  else{
    fCutList[12] = &Cutter::DummyCutter;
  }

  if(fOSCut){
    fCutList[13] = &Cutter::OverShootCutter;
    fBinLabel[14] = "OS";    
  }
  else{
    fCutList[13] = &Cutter::DummyCutter;
  }

  if(fTOFCut){
    fCutList[14]=&Cutter::TOFCutter;
    fBinLabel[15]="TOF";
  }
  else{
    fCutList[14]=&Cutter::DummyCutter;
  }

  if(fCCCut){
    fCutList[15]=&Cutter::CosmicCounterCutter;
    fBinLabel[16] = "Cos";
  }
  else{
    fCutList[15] = &Cutter::DummyCutter;
  }

  if(fTPMTCut){
    fCutList[16]=&Cutter::TrigPMTCutter;
    fBinLabel[17] = "PMT";
  }
  else{
    fCutList[16] = &Cutter::DummyCutter;
  }

  if(fDeadKovCut){    
    fCutList[17]=&Cutter::DeadKovCutter;
    fBinLabel[18] = "DK";
  }
  else{
    fCutList[17] = &Cutter::DummyCutter;
  }

  if(fNDErrorCut){    
    fCutList[18]=&Cutter::NDErrorCutter;
    fBinLabel[19] = "NDE";
  }
  else{
    fCutList[18] = &Cutter::DummyCutter;
  }

  for(int i=0;i<fNCuts+1;i++){
    MSG("Cutter",Msg::kInfo)<<"THE CUTS ARE SET AS FOLLOWS:"<<endl
                            <<fBinLabel[i]<<endl;
  }
  
  return;
}//end BeginJob
//______________________________________________________________________________

void Cutter::FillChipsToCut()
{
// fill fChipsToCut with the RawChannelId's (chan==0) for all chips
// whose plane<fDCPlaneCut


// get a plex handle
     const VldContext *vldc = fRR->GetVldContext(); //get Validity context
     PlexHandle ph(*vldc);  //use validity context to get a plex handle
     Detector::Detector_t detector = vldc->GetDetector();
     MSG("Cutter",Msg::kDebug)<<"The VldContext in  Fill chips to cut is:"
                              <<*vldc<<endl;
     for(Int_t plane=0; plane<fDCPlaneCut; plane++){
          // how many strips in a plane?
          // currently broken for everything but the caldet
          Int_t nstrips = 0;
          switch(detector) {
          case Detector::kCalDet:
               nstrips=24;
               break;
          default:
               break;
          }

// for now, do this for every strip
          for(Int_t strip=0; strip<nstrips; strip++) {
               PlexStripEndId pseid_pos(detector, plane, 
                                        strip, StripEnd::kPositive);
               PlexStripEndId pseid_neg(detector, plane, 
                                        strip, StripEnd::kNegative);
               RawChannelId chip_pos = ph.GetRawChannelId(pseid_pos);
               RawChannelId chip_neg = ph.GetRawChannelId(pseid_neg);

               MSG("Cutter",Msg::kDebug)<<" The real rawchan id (before changing) "
                                        <<plane<<" strip "<<strip<<endl;
               MSG("Cutter",Msg::kDebug)<<"pos "<<chip_pos<<endl
                                        <<"neg "<<chip_neg<<endl;

               

               if(chip_pos.GetElecType()==ElecType::kVA){
                  // convert to "chip" (a RawChannelId with chan=0)
                  MSG("Cutter",Msg::kDebug)<<"positive va"<<endl;
                  chip_pos.SetChAdd(
                     chip_pos.CalcChAdd(chip_pos.GetVarcId(),chip_pos.GetVmm(),
                                        chip_pos.GetVaAdcSel(),
                                        chip_pos.GetVaChip(),0));
               }
               if(chip_pos.GetElecType()==ElecType::kQIE){
                  MSG("Cutter",Msg::kDebug)<<"positive qie"<<endl;
                  //phil will give me the first masterchannel, minder channel
                  //combo of a dead pmt which will either be a 0 or a 4 for 
                  //master channel, and a 0 for minder channel
                  chip_pos.SetChAdd(
                     chip_pos.CalcChAdd(chip_pos.GetGeographicAddress(),
                                        ((int)(chip_pos.GetMasterChannel()/4))*4,
                                        0));
               }
               if(chip_neg.GetElecType()==ElecType::kVA){
                  MSG("Cutter",Msg::kDebug)<<"neg va"<<endl;
                  chip_neg.SetChAdd(
                     chip_neg.CalcChAdd(chip_neg.GetVarcId(),chip_neg.GetVmm(),
                                        chip_neg.GetVaAdcSel(),
                                        chip_neg.GetVaChip(),0));
               }
               if(chip_neg.GetElecType()==ElecType::kQIE){
                  MSG("Cutter",Msg::kDebug)<<"neg qie"<<endl;
                  chip_neg.SetChAdd(
                     chip_neg.CalcChAdd(chip_neg.GetGeographicAddress(),
                                        ((int)(chip_neg.GetMasterChannel()/4))*4,
                                        0));

               }
               // insert the "chips" into fChipsToCut
               MSG("Cutter",Msg::kDebug)<<" inserting chips for plane "
                                        <<plane<<" strip "<<strip<<endl;
               MSG("Cutter",Msg::kDebug)<<"pos "<<chip_pos<<endl
                                        <<"neg "<<chip_neg<<endl;
               fChipsToCut.insert(chip_pos);
               fChipsToCut.insert(chip_neg);
          }
     }
     return;

}


bool Cutter::NDErrorCutter() const
{

// no data, no problem
if(!fRR) return true;

// fetch raw datablock
const RawDigitDataBlock* r = 
    dynamic_cast<const RawDigitDataBlock*>
    (fRR->FindRawBlock("RawDigitDataBlock"));

// no data, no problem
if(!r) return true;

// loop through digits
// if digit is qie and the error code !=0 then there is an error

bool error = false;
const Int_t ndig=r->GetNumberOfDigits();
for(int i=0; i<ndig; i++){
    const RawDigit* d = r->At(i); 
    if( (d->GetChannel().GetElecType()==ElecType::kQIE)
        &&(d->GetErrorCode()!=0) ) { error=true; break;}
    }

return !(error);
}


void Cutter::Config(const Registry& r)
{
//======================================================================
// Configure the module given the Registry r
//======================================================================
  const char*    t;
  if (r.Get("FileName",t)) { fFileName = t; }

}

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

const Registry& Cutter::DefaultConfig() const
{
//======================================================================
// Supply the default configuration for the module
//======================================================================
  static Registry r; // Default configuration for module

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

  // Set values in configuration
  r.UnLockValues();

  const char* s = "cuts.root";
  r.Set("FileName", s);
  
  r.LockValues();

  return r;
}

---