NoiseFilterModule.cxx

Go to the documentation of this file.

// $$
//
// NoiseFilterModule.cxx
//
// A JobControl Module for filtering non physics snarls.
//
// Author:  R. Lee 2002.08.01
// Modified: A. Weber 2004.08.19
//
// Calculates simple quantities
// reject snarl, if it does not satisfy simple cuts
//     - EventLength >= MinEventLength 
//     - TotAdc      >= MinPulseHeight
//

#include "NoiseFilter/NoiseFilterModule.h"
#include "JobControl/JobCModuleRegistry.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexSEIdAltL.h"
#include "RawData/RawRecord.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawDigit.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Validity/VldContext.h"
#include "Calibrator/Calibrator.h"
#include "Conventions/Munits.h"
#include "Conventions/ReadoutType.h"
#include <vector>

ClassImp(NoiseFilterModule)

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

CVSID("$Id: NoiseFilterModule.cxx,v 1.14 2007/11/11 05:58:26 rhatcher Exp $");
JOBMODULE(NoiseFilterModule, "NoiseFilterModule",
         "NoiseFilters removes non physics triggers");

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

NoiseFilterModule::NoiseFilterModule()
{
  MSG("NoiseFilter", Msg::kVerbose) 
    << "NoiseFilterModule::Constructor\n";
}

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

NoiseFilterModule::~NoiseFilterModule() 
{
  MSG("NoiseFilter", Msg::kVerbose) 
    << "NoiseFilterModule::Destructor\n";
}

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

void NoiseFilterModule::BeginJob() 
{
  MSG("NoiseFilter", Msg::kVerbose) 
    << "NoiseFilterModule::BeginJob\n";

}

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

JobCResult NoiseFilterModule::Ana(const MomNavigator *mom)
  //----------------------------------------------------------------
  // This is the part that actually does the work
  //
  // Figure out, which detector you are in 
  // Calculates simple quantities
  // reject snarl, if event does not satisfy cuts
  //     - EventLength >= MinEventLength 
  //     - TotAdc      >= MinPulseHeight
  //----------------------------------------------------------------
{

  MSG("NoiseFilter", Msg::kDebug) << "NoiseFilterModule::Ana\n";

  TObject* tobj;
  TIter    fragiter = mom->FragmentIter();

  RawRecord*                 rr   = 0;
  const RawDigitDataBlock*   rddb = 0;
  const RawDaqSnarlHeader*   rdsh = 0;

  // find the right raw records

  while( ( tobj = fragiter.Next() ) ) { 
    if( ( rr = dynamic_cast<RawRecord*>(tobj) ) ) {

      MSG("NoiseFilter", Msg::kDebug) 
        << "Found Next RawRecord at "<<rr<<".\n";

      if ( !rddb )  rddb  = dynamic_cast<const RawDigitDataBlock*>
                      (rr->FindRawBlock("RawDigitDataBlock"));

      if ( !rdsh )  rdsh  = dynamic_cast<const RawDaqSnarlHeader*>
                      (rr->GetRawHeader());

    }  // if
  } // while
  
  // check RawDigitDataBlock

  if ( !rddb) {
    MSG("NoiseFilter", Msg::kWarning) 
      <<"No RawDigitDataBlock in RawRecord.\n";
    return JobCResult::kFailed;
  }

  if ( !rdsh) {
    MSG("NoiseFilter", Msg::kWarning) 
      <<"No RawDaqSnarlHeader in RawRecord.\n";
    return JobCResult::kFailed;
  }

  // only active for near and far detector
  
  VldContext               vldc     = rdsh->GetVldContext();
  Detector::Detector_t Detector = vldc.GetDetector();
  if ( Detector != Detector::kNear &&
       Detector != Detector::kFar ) {
    MSG("NoiseFilter", Msg::kDebug) 
      << "Accepting snarl: Neither Near nor Far Detector.\n";
    return JobCResult::kPassed;
  }

  // now get set detector specific quantities

  Int_t MinPH = 0;
  Int_t MinEL = 0;
  Int_t PlaneMax = 0;
  Bool_t TriggerTimeCut = false;
  switch (Detector) {
  case Detector::kNear:
    MinPH    = fMinPulseHeightND;
    MinEL    = fMinEventLengthND;
    PlaneMax = 282;
    TriggerTimeCut = fTriggerTimeCutND;
    break;
  case Detector::kFar:
    MinPH    = fMinPulseHeightFD;
    MinEL    = fMinEventLengthFD;
    PlaneMax = 486;
    TriggerTimeCut = fTriggerTimeCutFD;
    break;
  default:
    break;
  }

  PlexHandle ph(vldc);
  VldTimeStamp vldcts   = vldc.GetTimeStamp();

  MSG("NoiseFilter", Msg::kDebug) << "VldTimeStamp = " 
                                  << vldcts.AsString("c") << endl;

  Double_t     TrigTime = vldcts.GetNanoSec()*Munits::ns;
  MSG("NoiseFilter", Msg::kDebug) << "TrigTime = " << TrigTime 
                                  << " (in sec)" <<endl;

  // define some quantities which are used later

  Int_t TotAdc  = 0;                                 // total energy in snarl
  Int_t rdcount = 0;                                 // raw digit counter
  std::vector<Bool_t> HitInPlane(PlaneMax,kFALSE);   // vector of hit planes 
  
  // loop over raw digits to calculate filter quantities

  Calibrator& calibrator = Calibrator::Instance();
  TIter rdit = rddb->GetDatumIter();

  while (RawDigit *rd = dynamic_cast<RawDigit*>(rdit())) {

    RawChannelId rcid  = rd->GetChannel();
    Int_t        adc   = rd->GetADC();
    Int_t        tdc   = rd->GetTDC();
    Int_t        error = rd->GetErrorCode();
    Double_t     time  = calibrator.GetTimeFromTDC(tdc, rcid);
    PlexSEIdAltL seid  = ph.GetSEIdAltL(rcid);
    Int_t        plane = seid.GetPlane();

    // now treat TDC reset at 1 secound boundary
    time += ( (rd->GetCrateT0()).GetSec()
              - (vldc.GetTimeStamp()).GetSec() )*Munits::s
      // add CrateT0
      +  (rd->GetCrateT0()).GetNanoSec()*Munits::ns;
      
    // now re-map ND spectrometer

    Int_t planeRAW = plane;
    if ( (vldc.GetDetector() == Detector::kNear) && (plane>121) )
         plane = 121 + (plane-121) / 5;

    MSG("NoiseFilter", Msg::kDebug) << "Digit("   << setw(3) << rdcount << "):"
                                    << " plane =" << setw(5) << plane <<"/" 
                                                  << setw(3) << planeRAW
                                    << " ADC ="   << setw(6) << adc
                                    << " TDC ="   << setw(12) << tdc
                                    << " err = "  << error
                                    << " Dt = "   << time-TrigTime 
                                    << endl;

    // only count the following hits
    //    - not veto counter
    //    - no error
    //    - scintilator strips
    //    - not in pretrigger window 
    //                   un-less no TriggerTimeCut or ND

    if ( !(seid.IsVetoShield()) && 
         ph.GetReadoutType(rcid) == ReadoutType::kScintStrip &&
         !error &&
         ( (time+50*Munits::ns>=TrigTime) || !TriggerTimeCut ) ) {

      // the following cut protects against unknown rcid

      if ( (plane>=0) && (plane<PlaneMax) ) {

        TotAdc            += adc;
        HitInPlane[plane]  = kTRUE;

      } else {

        MAXMSG("NoiseFilter", Msg::kWarning, 20) 
          << "Found plane number " << plane 
          << " outside allowed range 0 - " <<  PlaneMax << endl
          << "    ADC = "<< adc << " TDC = " << tdc << " t = " << time
          << endl << "    rcid = " << rcid.AsString("e") << endl;

      }

    } // hit cut

    rdcount++;

  } //while loop

  // now calculate event length (max number of cont. planes)

  MSG("NoiseFilter", Msg::kDebug) << "Now calculating snarl length.\n";

  Int_t EventLength = 0;
  Int_t PlaneCount  = 0;

  for (Int_t plane = 0; plane<PlaneMax; plane++) {
    if ( HitInPlane[plane] ) {
      PlaneCount++;
      if ( PlaneCount > EventLength ) {
        EventLength = PlaneCount;
      }
      MSG("NoiseFilter", Msg::kVerbose) 
        << "Plane " << plane << " was hit. PC = " << PlaneCount
        << " EL = " << EventLength << endl;
    }  else {
      MSG("NoiseFilter", Msg::kVerbose) 
        << "Plane " << plane << " was not hit."<< endl;
      PlaneCount = 0;
    }
  }

  // cut on total pulse height

  if (TotAdc<MinPH) {
    MSG("NoiseFilter", Msg::kDebug) << "Failing snarl: SumAdc = "
                                    << TotAdc << "/" << MinPH 
                                    << endl;
    return JobCResult::kFailed;
  }

  // cut on event length

  if (EventLength<MinEL) {
    MSG("NoiseFilter", Msg::kDebug) << "Failing snarl: EventLength = " 
                                    << EventLength << "/" << MinEL 
                                    << endl;
    return JobCResult::kFailed;
  }

  MSG("NoiseFilter", Msg::kDebug) 
    << "Snarl passed filter: EventLength = " 
    << EventLength << " and total ADC = " 
    << TotAdc << endl;

  return JobCResult::kPassed;

}

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

const Registry &NoiseFilterModule::DefaultConfig() const
{
//  Purpose:    Method to return default configuration.
//
//  Arguments:  n/a
//
//  Return:     Registry item containing default configuration.
//

  MSG("NoiseFilter", Msg::kDebug) 
    << "NoiseFilterModule::DefaultConfig\n";

  static Registry r;

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

  r.UnLockValues();

  r.Set("MinPulseHeightFD", 2000);
  r.Set("MinEventLengthFD", 2);
  r.Set("TriggerTimeCutFD", kTRUE);
  r.Set("MinPulseHeightND", 3000);
  r.Set("MinEventLengthND", 1);
  r.Set("TriggerTimeCutND", kTRUE);

  r.LockValues();

  return r;

}

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

void NoiseFilterModule::Config(const Registry& r)
{
//====================================================================
// Configure the module given the registry r
// Do all configuration here.
// Beware: this methode may be called several times!
//====================================================================

  MSG("NoiseFilter", Msg::kDebug) << "NoiseFilterModule::Config\n";

  Int_t tmpi;

  if (r.Get("MinPulseHeightND", tmpi)) { fMinPulseHeightND = tmpi;}
  if (r.Get("MinEventLengthND", tmpi)) { fMinEventLengthND = tmpi;}
  if (r.Get("TriggerTimeCutND", tmpi)) { fTriggerTimeCutND = tmpi!=0;}
  if (r.Get("MinPulseHeightFD", tmpi)) { fMinPulseHeightFD = tmpi;}
  if (r.Get("MinEventLengthFD", tmpi)) { fMinEventLengthFD = tmpi;}
  if (r.Get("TriggerTimeCutFD", tmpi)) { fTriggerTimeCutFD = tmpi!=0;}

  return;

}

---