DmxDeMuxFilterModule.cxx

Go to the documentation of this file.

//$Id: DmxDeMuxFilterModule.cxx,v 1.12 2003/05/21 16:24:35 bv Exp $
//
//DmxDeMuxFilterModule.cxx
//
//Module for demultiplexing cosmic ray events in the far detector
//
//Author:  B. Rebel 6/2001

#include "DeMux/DmxDeMuxFilterModule.h"
#include "DeMux/DmxChiSqrStat.h"
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Algorithm/AlgConfig.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/CandDigitHandle.h"
#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "CandData/CandRecord.h"
#include "CandData/CandHeader.h"
#include "Candidate/CandContext.h"
#include "Navigation/NavKey.h"
#include "Navigation/NavSet.h"
#include "Conventions/PlaneView.h"
#include "Navigation/XxxItr.h"
#include "DeMux/DmxShowerPlane.h"
#include "DeMux/DmxMuonPlane.h"
#include "DeMux/DmxPlane.h"
#include "DeMux/DmxHypothesis.h"
#include "TFile.h"
#include "TH1.h"
#include "TH2.h"
#include "TClonesArray.h"
#include "Validity/VldContext.h"
#include "UgliGeometry/UgliGeomHandle.h"

#include <cassert>

//define the NavKey to sort the digits by plane
//static NavKey KeyFromDigitPlane( const CandDigitHandle *cdh){
//  return const_cast<CandDigitHandle*>(cdh)->GetPlexSEIdAltL().GetPlane();}

//define the NavKey to sort the planes
//static NavKey KeyOnPlaneNumber( const TObject *tobj){
//  DmxPlane *currentPlane = dynamic_cast<DmxPlane *>(const_cast<TObject*>(tobj));
//  return currentPlane->GetPlaneNumber();
//}

ClassImp(DmxDeMuxFilterModule)

CVSID("$Id: DmxDeMuxFilterModule.cxx,v 1.12 2003/05/21 16:24:35 bv Exp $");

// Declare this module to JobControll. Arguments are:
//  (1) The class name 
//  (2) The human-readable name 
//  (3) A short, human-readable description of what the module does
JOBMODULE(DmxDeMuxFilterModule, 
          "DeMuxFilterModule",
          "A module used for demultiplexing cosmics in the far detector");

//......................................................................
DmxDeMuxFilterModule::DmxDeMuxFilterModule() :
  fDontUseCandDigitMasks(false),
  fSignalFractionLimit(0.1)
{

  MSG("JobC", Msg::kDebug) << "DmxDeMuxFilterModule::Constructor" << endl;
  //MSG("DMX", Msg::kInfo) << fSignalFractionLimit << endl;

}

//----------------------------------------------------------------------
DmxDeMuxFilterModule::~DmxDeMuxFilterModule()
{
  MSG("JobC", Msg::kDebug) << "DmxDeMuxFilterModule::Destructor" << endl;
}

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

void DmxDeMuxFilterModule::BeginJob()
{
  AlgFactory &af = AlgFactory::GetInstance();
  af.Register("AlgDeMuxCosmics", "default", "libDeMux.so", "AlgConfigDeMux");
  AlgHandle ah = af.GetAlgHandle("AlgDeMuxCosmics", "default");
  //MSG("DMX", Msg::kInfo) << fSignalFractionLimit << endl;

  //get the AlgConfigDeMux class and set some variables
  AlgConfig &acd = ah.GetAlgConfig();
  acd.UnLockValues();
  acd.Set("HoughInterceptLimit",1.5);
  acd.Set("HoughPeakLimit",0.66);
  acd.Set("HoughSlopeLimit",1.);
  acd.Set("HypothesisSize",24);
  acd.Set("MuonTrackSlopeLimit",0.09);
  acd.Set("NumberOfHypotheses",169);
  acd.Set("NumberOfStrips", 192);
  acd.Set("PlanesInSet",6);
  acd.Set("RatioMatedSignalForValid",0.3);
  acd.Set("UseCandDigitMask", 1);
  acd.Set("XTalkFractionLimit", 0.1);
  acd.Set("IgnoreFractionLimit", 0.05);
  acd.Set("AveragePEGainConversion", 55.);
  acd.Set("StrayDeltaStripLimit",6);
  acd.Set("StrayPlanesLimit",10);
  acd.Set("UseStrayPlaneCheck", 0);
  
  acd.LockValues();
  acd.LockKeys();
  
  //MSG("DMX", Msg::kInfo) << fSignalFractionLimit << endl;

  fStatus = DmxStatus();

  return;
}

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

JobCResult DmxDeMuxFilterModule::Reco(MomNavigator *mom)
{
  JobCResult result(JobCResult::kPassed);

  MSG("JobC", Msg::kDebug) << "DeMuxFilterModule::Reco\n";

  fStatus.ClearPlaneArray();

  // Check that mom exists.
  assert(mom);

  // Find PrimaryCandidateRecord fragment in MOM.
  CandRecord *candrec = dynamic_cast<CandRecord *>
    (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
  if (candrec == 0) {
    result.SetError().SetFailed();
    return result;
  }
  
  //*-* Find Raw Data CandDigitList fragment in PrimaryCandidateRecord.
  CandDigitListHandle *crdlh = dynamic_cast<CandDigitListHandle *>
    (candrec->FindCandHandle("CandDigitListHandle", "canddigitlist"));
  if (crdlh == 0) {
    result.SetError().SetFailed();
    return result;
  }
  
  Int_t event = fStatus.GetEventNumber();
  const CandHeader* chead = candrec->GetCandHeader();
  if (!chead) {
    MSG("JobC",Msg::kWarning) << "No CandHeader, but continuing" << endl;
  }
  ++event;// chead->GetEvent();
  //MSG("Dmx", Msg::kInfo) << "event = " << event << endl;

  AlgFactory &af = AlgFactory::GetInstance();
  AlgHandle ah = af.GetAlgHandle("AlgDeMuxCosmics", "default");
  //AlgConfigDeMux &acd = dynamic_cast<AlgConfigDeMux &>(ah.GetAlgConfig());
  
  //set fStatus.fEventDeMuxed to be true as a default, it gets reset to false
  //if there is no vertex found or no valid planes
  fStatus.SetEventDeMuxed(true);
  fStatus.SetMultipleMuon(false);

  CandContext cx(this, mom);
  cx.SetDataIn(&fStatus);
  
  ah.RunAlg(*crdlh, cx);
  
  if( !fStatus.GetEventDeMuxed() ){
    result.SetError().SetFailed();
    return result;
  }
  
  //MSG("JobC", Msg::kInfo) << "Event DeMuxed" << endl;
  
  //get the TObjArray of DmxPlane objects
  //  const TObjArray *planeArray = fStatus.GetPlaneArray();
  
//    //create a TObjectItr
//    TObjectItr planeItr(planeArray);
    
//    //create a KeyFunc to sort planes by number
//    TObjectKeyFunc *pnKF = planeItr.CreateKeyFunc();
  
//    //program the KeyFunc with the sort function
//    pnKF->SetFun(KeyOnPlaneNumber);
  
//    //get the NavSet from the iterator and pass the KeyFunc to it
//    planeItr.GetSet()->AdoptSortKeyFunc(pnKF);
  
//    //clear the KF pointer because we no longer own the KeyFunc
//    pnKF = 0;
  
//    //zero values that need to start over with each event
//    Int_t vertexPlane = fStatus.GetVertexPlaneNumber();
//    Int_t endPlane = fStatus.GetEndPlaneNumber();

//    if(!fStatus.GetMultipleMuon()){planeItr.GetSet()->Slice(vertexPlane, endPlane);}
//    else if(fStatus.GetMultipleMuon()){planeItr.GetSet()->Slice(vertexPlane, 500);}

//    Float_t fracStray = (1.*(fStatus.GetUStrayPlanes()+fStatus.GetVStrayPlanes())) / (1.*planeItr.SizeSelect());
//    if( fStatus.GetUSlopeRMS()>15. && fracStray>0.3333){
//      result.SetError().SetFailed();
//      return result;
//    }
//    else if( fStatus.GetVSlopeRMS()>15. && fracStray>0.3333){
//      result.SetError().SetFailed();
//      return result;
//    }
    
  return result;
}

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

void DmxDeMuxFilterModule::HandleCommand(JobCommand *command) 
{
  //
  //  Purpose:  Method to interpret module commands.
  //
  //  Arguments:
  //    command   in    Command to interpret.
  //
  //  Return:   n/a
  //
  //  Commands implemented:
  //    Set TestToMake  Set the test to make to obtain a figure of merit - fraction of
  //                    digits within n strips from a track, fraction of mated signal
  //                    DigitsAlongTrack, and MatedSignalFraction respectively
  //    Set DataType    Set the type of data to test - MonteCarlo or FarDetector
  //    Set MatedSignalLimit  Set the lower limit for fraction of signal coming from opposite
  //                          sides of the same strip in a plane.
  //    Set DeltaStripsFromTrack  Set the number of strips a digit can be off from a track and
  //                              still be considered along that track.
  //
  //  see http://beaker.astro.indiana.edu/brebel/demux_notes/how_to_demux.html for details
   MSG("JobC", Msg::kDebug) << "DeMuxFilterModule::HandleCommand" << endl;

   TString cmd = command->PopCmd();
   if(cmd == "Set"){   
     TString opt = command->PopOpt();
     if(opt == "DontUseCandDigitMasks"){ fDontUseCandDigitMasks = true;}
     else if(opt = "SignalFractionLimit"){ fSignalFractionLimit = command->PopFloatOpt();}
     else {
         MSG("JobC", Msg::kWarning)<< "DeMuxFilterModule: Unrecognized option " << opt << endl;
      }
   }
   else {
     MSG("JobC", Msg::kWarning)<< "DeMuxFilterModule: Unrecognized command " << cmd << endl;
   }
   return;
}

//......................................................................
void DmxDeMuxFilterModule::ClearStatusObject() 
{
  fStatus.ClearPlaneArray();
  return;
}

void DmxDeMuxFilterModule::Help() 
{
  MSG("JobC", Msg::kInfo) 
    << "DeMuxFilterModule::Help\n"
    <<"DmxDeMuxFilterModule is a module which demultiplexes events "
    <<"in the far detector." << endl
    << "see http://beaker.astro.indiana.edu/brebel/demux_notes/how_to_demux.html for details"
    << endl;
}

---