FarDetStripListModule.cxx

Go to the documentation of this file.

#include "FarDetStripListModule.h"
#include "FarDetStripListHandle.h"
#include "FarDetStripHandle.h"

#include "Algorithm/AlgConfig.h"
#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"

#include "MessageService/MsgService.h"  
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"
#include "MinosObjectMap/MomNavigator.h"

#include "RawData/RawRecord.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawDigit.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawDaqHeaderBlock.h"
#include "RawData/RawSnarlHeaderBlock.h"
#include "RawData/RawDigitDataBlock.h"

#include "Candidate/CandContext.h"
#include "CandData/CandRecord.h"
#include "CandData/CandHeader.h"

#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/CandDigitHandle.h"

#include "CandDigit/CandDeMuxDigitListHandle.h"
#include "CandDigit/CandDeMuxDigitHandle.h"


#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliPlnNode.h"
#include "Validity/VldContext.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexPlaneId.h"

#include "TDirectory.h"
#include <cmath>

CVSID("$Id: FarDetStripListModule.cxx,v 1.5 2007/02/04 06:16:55 rhatcher Exp $");

JOBMODULE(FarDetStripListModule,"FarDetStripListModule","Making CandStrips");

FarDetStripListModule::FarDetStripListModule() :
  fFarDetStripFile(0),
  fFarDetStripTree(0),
  fListIn("CandDigitListHandle"),
  fListOut("FarDetStripListHandle"),
  fFilterOnOff(0),
  fFilterMinStrips(-1),
  fFilter(0)
{

}

FarDetStripListModule::~FarDetStripListModule()
{

}
    
void FarDetStripListModule::BeginJob()
{
  MSG("FarDetStrip",Msg::kDebug) << " *** FarDetStripListModule::BeginJob( ) *** " << endl;

  /*
  AlgFactory &af = AlgFactory::GetInstance();
  af.Register("AlgFarDetStripList","default","libFarDetStrip.so","AlgConfig");
  af.Register("AlgFarDetStrip","default","libFarDetStrip.so","AlgConfig");
  */
}
  
JobCResult FarDetStripListModule::Reco(MomNavigator *mom)
{
  MSG("FarDetStrip",Msg::kDebug) << " *** FarDetStripListModule::Reco( ) *** " << endl;

  fFilter=0;
  JobCResult result(JobCResult::kPassed);

  // get candrecord
  CandRecord* candrec = dynamic_cast<CandRecord*>(mom->GetFragment("CandRecord","PrimaryCandidateRecord"));
  if( candrec==0 ){
    MSG("FarDetStrip",Msg::kDebug) << "  *** FAILED TO FIND CANDRECORD *** " << endl;
    return result.SetFailed();
  }

  // make striplist handle
  CandDigitListHandle* cdlh = dynamic_cast<CandDigitListHandle*>(candrec->FindCandHandle("CandDigitListHandle",fListIn.Data()));
  if( cdlh){
    MSG("FarDetStrip",Msg::kDebug) << "  *** MAKE HANDLE *** " << endl;

    AlgFactory &af = AlgFactory::GetInstance();
    AlgHandle ah = af.GetAlgHandle("AlgFarDetStripList", "default");
  
    CandContext cx(this, mom);
    cx.SetCandRecord(candrec);
    cx.SetDataIn(cdlh);
    FarDetStripListHandle strplist = FarDetStripList::MakeCandidate(ah,cx);
    strplist.SetName(fListOut.Data());
    strplist.SetTitle(TString("Created by FarDetStripListModule"));

    candrec->SecureCandHandle(strplist);
  }

  // contained event filter 
  FarDetStripListHandle* csh = dynamic_cast<FarDetStripListHandle*>(candrec->FindCandHandle("FarDetStripListHandle"));
  if( csh ){
    fFilter = this->ApplyFilter(csh);
  }

  // apply filter
  if( fFilterOnOff ){
    MSG("FarDetStrip",Msg::kDebug) << "  *** APPLY FILTER *** " << endl;

    if( fFilter ){
      MSG("FarDetStrip",Msg::kDebug) << "   *** PASSED FILTER *** " << endl;      
      return result.SetPassed(); 
    }
    else{
      MSG("FarDetStrip",Msg::kDebug) << "   *** FAILED FILTER *** " << endl;      
      return result.SetFailed();
    } 
  }

  return result;
}
  
JobCResult FarDetStripListModule::Ana(const MomNavigator* mom)
{
  MSG("FarDetStrip",Msg::kDebug) << " *** FarDetStripListModule::Ana( ) *** " << endl;

  JobCResult result(JobCResult::kPassed);  
  run=-1; snarl=-1; timeframe=-1;

  Double_t trigger=0.0;

  RawRecord *rawrec = dynamic_cast<RawRecord *>(mom->GetFragment("RawRecord"));
  if(rawrec){
    const RawDaqSnarlHeader* rawheader = dynamic_cast<const RawDaqSnarlHeader*>(rawrec->GetRawHeader());
    if(rawheader){
      if(run<0) run = rawheader->GetRun(); 
      if(snarl<0) snarl = rawheader->GetSnarl();
      if(timeframe<0) timeframe = rawheader->GetTimeFrameNum();
    }

    TIter rawrecitr = rawrec->GetRawBlockIter();
    TObject *tob;
    while((tob = rawrecitr())){
      if(tob->InheritsFrom("RawSnarlHeaderBlock")){
        RawSnarlHeaderBlock* rdb = (RawSnarlHeaderBlock*)(tob);
        trigger = 1.0e-9*((VldTimeStamp)(rdb->GetTriggerTime())).GetNanoSec();
        date = (((VldTimeStamp)(rdb->GetTriggerTime())).GetSec()-1059696000)/(3600*24);
        time = (((VldTimeStamp)(rdb->GetTriggerTime())).GetSec()-1059696000)%(3600*24);
      }
    }
  }  

  CandRecord* candrec = dynamic_cast<CandRecord*>(mom->GetFragment("CandRecord","PrimaryCandidateRecord"));
  if(candrec==0){
    return result.SetFailed();
  }

  VldContext *vldc = (VldContext*)(candrec->GetVldContext());
  UgliGeomHandle ugh(*vldc);
  PlexHandle ph(*vldc);
  CandHeader* candheader = (CandHeader*)(candrec->GetCandHeader());
  if(run<0) run = candheader->GetRun();
  if(snarl<0) snarl = candheader->GetSnarl();

  FarDetStripListHandle* strplist = dynamic_cast<FarDetStripListHandle*>(candrec->FindCandHandle("FarDetStripListHandle"));
  if(strplist==0){
    return result.SetFailed();
  }

  if(!fFarDetStripFile){      
    // TString mystring("results/fardet.strip");  
    // mystring.Append("."); mystring+=run; 
    // mystring.Append(".root");
    TString mystring("fardet.strip.root");
    TDirectory* tmpd = gDirectory;
    fFarDetStripFile = new TFile(mystring.Data(),"RECREATE");
    fFarDetStripTree = new TTree("StripTree","StripTree");
    fFarDetStripTree->SetAutoSave(100);

    fFarDetStripTree->Branch("run",&run,"run/I");
    fFarDetStripTree->Branch("snarl",&snarl,"snarl/I");
    fFarDetStripTree->Branch("timeframe",&timeframe,"timeframe/I");
    fFarDetStripTree->Branch("time",&time,"time/I");
    fFarDetStripTree->Branch("date",&date,"date/I");
    fFarDetStripTree->Branch("plane",&plane,"plane/I");
    fFarDetStripTree->Branch("strip",&strip,"strip/I");
    fFarDetStripTree->Branch("ndigits",&ndigits,"ndigits/I");
    fFarDetStripTree->Branch("view",&view,"view/I");
    fFarDetStripTree->Branch("xtalk",&xtalk,"xtalk/I");
    
    fFarDetStripTree->Branch("crateE",&crateE,"crateE/I");
    fFarDetStripTree->Branch("varcE",&varcE,"varcE/I");
    fFarDetStripTree->Branch("vmmE",&vmmE,"vmmE/I");
    fFarDetStripTree->Branch("vaadcE",&vaadcE,"vaadcE/I");
    fFarDetStripTree->Branch("vachipE",&vachipE,"vachipE/I");
    fFarDetStripTree->Branch("vachannelE",&vachannelE,"vachannelE/I");
    fFarDetStripTree->Branch("CTrawE",&CTrawE,"CTrawE/D");
    fFarDetStripTree->Branch("CTcalE",&CTcalE,"CTcalE/D");
    fFarDetStripTree->Branch("QrawE",&QrawE,"QrawE/D");
    fFarDetStripTree->Branch("QcalE",&QcalE,"QcalE/D");
    fFarDetStripTree->Branch("QpeE",&QpeE,"QpeE/D");
    fFarDetStripTree->Branch("QsiglinE",&QsiglinE,"QsiglinE/D");
    fFarDetStripTree->Branch("QsigcorrE",&QsigcorrE,"QsigcorrE/D");
    fFarDetStripTree->Branch("QsigmapE",&QsigmapE,"QsigmapE/D");
    fFarDetStripTree->Branch("fibreE",&fibreE,"fibreE/D");
    fFarDetStripTree->Branch("greenE",&greenE,"greenE/D");
    fFarDetStripTree->Branch("clearE",&clearE,"clearE/D");
    fFarDetStripTree->Branch("pigtailE",&pigtailE,"pigtailE/D");
   
    fFarDetStripTree->Branch("crateW",&crateW,"cratetW/I");
    fFarDetStripTree->Branch("varcW",&varcW,"varcW/I");
    fFarDetStripTree->Branch("vmmW",&vmmW,"vmmW/I");
    fFarDetStripTree->Branch("vaadcW",&vaadcW,"vaadcW/I");
    fFarDetStripTree->Branch("vachipW",&vachipW,"vachipW/I");
    fFarDetStripTree->Branch("vachannelW",&vachannelW,"vachannelW/I");
    fFarDetStripTree->Branch("CTrawW",&CTrawW,"CTrawW/D");
    fFarDetStripTree->Branch("CTcalW",&CTcalW,"CTcalW/D");
    fFarDetStripTree->Branch("QrawW",&QrawW,"QrawW/D");
    fFarDetStripTree->Branch("QcalW",&QcalW,"QcalW/D");
    fFarDetStripTree->Branch("QpeW",&QpeW,"QpeW/D");
    fFarDetStripTree->Branch("QsiglinW",&QsiglinW,"QsiglinW/D");
    fFarDetStripTree->Branch("QsigcorrW",&QsigcorrW,"QsigcorrW/D");
    fFarDetStripTree->Branch("QsigmapW",&QsigmapW,"QsigmapW/D");
    fFarDetStripTree->Branch("fibreW",&fibreW,"fibreW/D");
    fFarDetStripTree->Branch("greenW",&greenW,"greenW/D");
    fFarDetStripTree->Branch("clearW",&clearW,"clearW/D");
    fFarDetStripTree->Branch("pigtailW",&pigtailW,"pigtailW/D");

    fFarDetStripTree->Branch("halflength",&halflength,"halflength/D");
    fFarDetStripTree->Branch("Ltrk",&Ltrk,"Ltrk/D");
    
    fFarDetStripTree->Branch("Zstrp",&Zstrp,"Zstrp/D");
    fFarDetStripTree->Branch("Tstrp",&Tstrp,"Tstrp/D");
    fFarDetStripTree->Branch("dSfit",&dSfit,"dSfit/D");
    fFarDetStripTree->Branch("Tfit",&Tfit,"Tfit/D");
    fFarDetStripTree->Branch("Lfit",&Lfit,"Lfit/D");
    fFarDetStripTree->Branch("CTfit",&CTfit,"CTfit/D");
    fFarDetStripTree->Branch("U",&U,"U/D");
    fFarDetStripTree->Branch("V",&V,"V/D");
    fFarDetStripTree->Branch("X",&X,"X/D");
    fFarDetStripTree->Branch("Y",&Y,"Y/D");
    fFarDetStripTree->Branch("Z",&Z,"Z/D");

    fFarDetStripTree->Branch("pu",&pu,"pu/D");
    fFarDetStripTree->Branch("pv",&pv,"pv/D");
    fFarDetStripTree->Branch("pz",&pz,"pz/D");
    fFarDetStripTree->Branch("erru",&erru,"erru/D");
    fFarDetStripTree->Branch("errv",&errv,"errv/D");
    fFarDetStripTree->Branch("nplns",&nplns,"nplns/I");

    gDirectory = tmpd;
  }

  Int_t pln;

  TIter strpitr(strplist->GetDaughterIterator());
  while(FarDetStripHandle* strp = dynamic_cast<FarDetStripHandle*>(strpitr())){
    if(strp){
      pln=strp->GetPlane();
      if(pln>-1 && pln<500){
        fStrpList[pln].Add(strp);
      }
    }
  }

  Int_t i;
  Int_t uflag=0,vflag=0;
  Double_t dt,t,z,q;
  Double_t Uwuu=0.0,Uwzz=0.0,Uwzu=0.0,Uwu=0.0,Uwz=0.0,Uw=0.0;
  Double_t Vwvv=0.0,Vwzz=0.0,Vwzv=0.0,Vwv=0.0,Vwz=0.0,Vw=0.0;
  Int_t uplns=0,vplns=0;
  Double_t zmin=-999.9,zmax=-999.0;

  // *** DO STRAIGHT LINE FIT ***
  for(pln=0;pln<500;pln++){
    uflag=0; vflag=0;

    for(i=0;i<1+fStrpList[pln].GetLast();i++){
      FarDetStripHandle* strp = (FarDetStripHandle*)(fStrpList[pln].At(i));

      xtalk=strp->IsXtalk(StripEnd::kWhole);

      q=strp->GetCharge();
      t=strp->GetTPos(); z=strp->GetZPos();
      if( !xtalk && q>2.0 ){

        if( strp->GetPlaneView()==PlaneView::kU ){
          Uwuu+=q*t*t; Uwzu+=q*t*z; Uwzz+=q*z*z;
          Uwu+=q*t; Uwz+=q*z; Uw+=q;
          uflag=1;
        }
        if( strp->GetPlaneView()==PlaneView::kV ){
          Vwvv+=q*t*t; Vwzv+=q*t*z; Vwzz+=q*z*z;
          Vwv+=q*t; Vwz+=q*z; Vw+=q;
          vflag=1;
        }

        if( zmin<0||z<zmin ){ zmin=z; }  if( zmax<0||z>zmax ){ zmax=z; }
      }
    }

    if(uflag) uplns++; if(vflag) vplns++;
  }

  Double_t mu,mv,cu,cv;
  Double_t opos,tpos,upos,vpos;  

  // *** SELECT EVENTS ***
  if( uplns>3 && vplns>3 ){

    mu=(Uw*Uwzu-Uwz*Uwu)/(Uw*Uwzz-Uwz*Uwz); cu=(Uwu*Uwzz-Uwz*Uwzu)/(Uw*Uwzz-Uwz*Uwz);
    mv=(Vw*Vwzv-Vwz*Vwv)/(Vw*Vwzz-Vwz*Vwz); cv=(Vwv*Vwzz-Vwz*Vwzv)/(Vw*Vwzz-Vwz*Vwz);

    erru=(Uwuu-2.0*mu*Uwzu-2.0*cu*Uwu+mu*mu*Uwzz+2.0*mu*cu*Uwz+Uw*cu*cu)/(Uw);
    errv=(Vwvv-2.0*mv*Vwzv-2.0*cv*Vwv+mv*mv*Vwzz+2.0*mv*cv*Vwz+Vw*cv*cv)/(Vw);
    nplns=uplns+vplns;

    if( erru<0.01 && errv<0.01 && nplns>10 ){

      if( mu+mv>=0 ){
        pu=-mu/sqrt(mu*mu+mv*mv+1.0);
        pv=-mv/sqrt(mu*mu+mv*mv+1.0);
        pz=-1.0/sqrt(mu*mu+mv*mv+1.0);
      }
      else{   
        pu=mu/sqrt(mu*mu+mv*mv+1.0);
        pv=mv/sqrt(mu*mu+mv*mv+1.0);
        pz=1.0/sqrt(mu*mu+mv*mv+1.0);
      }

      // *** WRITE OUT STRIPS ON TRACK ***
      MSG("FarDetStrip",Msg::kDebug) << " COSMIC MUON AT TIME = " << timeframe << endl;

      for(pln=0;pln<500;pln++){
        for(i=0;i<1+fStrpList[pln].GetLast();i++){
          FarDetStripHandle* strp = (FarDetStripHandle*)(fStrpList[pln].At(i));
    
          view=-1;
          plane=strp->GetPlane(); strip=strp->GetStrip();
          ndigits=strp->GetNDaughters();
          
          CTrawE=0.0; CTcalE=0.0; 
          QrawE=0.0; QcalE=0.0; QpeE=0.0; QsiglinE=0.0; QsigcorrE=0.0; QsigmapE=0.0;
          CTrawW=0.0; CTcalW=0.0; 
          QrawW=0.0; QcalW=0.0; QpeW=0.0; QsiglinW=0.0; QsigcorrW=0.0; QsigmapW=0.0;
          CTfit=0.0;

          t=strp->GetTPos(); z=strp->GetZPos();
          Zstrp=z; Tstrp=t; 
          upos=mu*z+cu; vpos=mv*z+cv;
          opos=0.0; tpos=0.0; dt=0.0;
          U=upos; V=vpos; 
          X=0.7071*(U-V); Y=0.7071*(U+V);
          Z=z;

          if( strp->GetPlaneView()==PlaneView::kU ){
            view=0; dt=t-upos;
            tpos=upos; opos=-vpos;
            Tfit=upos; Lfit=vpos;
          }
          if( strp->GetPlaneView()==PlaneView::kV ){
            view=1; dt=t-vpos;
            tpos=vpos; opos=upos;
            Tfit=vpos; Lfit=upos;
          }

          halflength=strp->GetHalfLength();

          greenW=strp->GetGreenFibre(StripEnd::kPositive)-opos; 
          pigtailW=strp->GetWlsPigtail(StripEnd::kPositive);
          clearW=strp->GetClearFibre(StripEnd::kPositive);
          fibreW=greenW+pigtailW+clearW;

          PlexStripEndId stripidW = strp->GetStripEndId(StripEnd::kPositive);
          RawChannelId rawchW = ph.GetRawChannelId(stripidW);     
          crateW = rawchW.GetCrate();
          varcW = rawchW.GetVarcId();
          vmmW = rawchW.GetVmm();
          vaadcW = rawchW.GetVaAdcSel();
          vachipW = rawchW.GetVaChip();
          vachannelW = rawchW.GetVaChannel();
              
          CTrawW=3.0e8*(strp->GetTime(StripEnd::kPositive,CalTimeType::kNone));
          CTcalW=3.0e8*(strp->GetTime(StripEnd::kPositive,CalTimeType::kT0));
          QrawW=strp->GetCharge(StripEnd::kPositive,CalDigitType::kNone);
          QcalW=strp->GetCharge(StripEnd::kPositive,CalDigitType::kPE);
          QpeW=strp->GetCharge(StripEnd::kPositive,CalDigitType::kPE);
          QsiglinW=strp->GetCharge(StripEnd::kPositive,CalDigitType::kSigLin);
          QsigcorrW=strp->GetCharge(StripEnd::kPositive,CalDigitType::kSigCorr);
          QsigmapW=0.0;

          greenE=strp->GetGreenFibre(StripEnd::kNegative)+opos;
          pigtailE=strp->GetWlsPigtail(StripEnd::kNegative); 
          clearE=strp->GetClearFibre(StripEnd::kNegative);
          fibreE=greenE+pigtailE+clearE;              

          PlexStripEndId stripidE = strp->GetStripEndId(StripEnd::kNegative);
          RawChannelId rawchE = ph.GetRawChannelId(stripidE);
          crateE = rawchE.GetCrate();
          varcE = rawchE.GetVarcId();
          vmmE = rawchE.GetVmm();
          vaadcE = rawchE.GetVaAdcSel();
          vachipE = rawchE.GetVaChip();
          vachannelE = rawchE.GetVaChannel();   

          CTrawE=3.0e8*(strp->GetTime(StripEnd::kNegative,CalTimeType::kNone));
          CTcalE=3.0e8*(strp->GetTime(StripEnd::kNegative,CalTimeType::kT0));
          QrawE=strp->GetCharge(StripEnd::kNegative,CalDigitType::kNone);
          QcalE=strp->GetCharge(StripEnd::kNegative,CalDigitType::kPE);
          QpeE=strp->GetCharge(StripEnd::kNegative,CalDigitType::kPE);
          QsiglinE=strp->GetCharge(StripEnd::kNegative,CalDigitType::kSigLin);
          QsigcorrE=strp->GetCharge(StripEnd::kNegative,CalDigitType::kSigCorr);
          QsigmapE=0.0;

          if( mu+mv>=0 ){
            dSfit=(zmax-z)*sqrt(mu*mu+mv*mv+1.0);
          }
          else{
            dSfit=(z-zmin)*sqrt(mu*mu+mv*mv+1.0);
          } 
          Ltrk=dSfit;

          xtalk=strp->IsXtalk(StripEnd::kWhole);

          if( dt>-0.06 && dt<0.06 ){
            if(fFarDetStripFile){
              TDirectory* tmpdd = gDirectory;
              fFarDetStripFile->cd();
              fFarDetStripTree->Fill();
              gDirectory = tmpdd;
            }
          }

        }
      }

    }
  }

  for(pln=0;pln<500;pln++){
    fStrpList[pln].Clear();
  }

  return result;
}
  
const Registry& FarDetStripListModule::DefaultConfig() const
{
  MSG("FarDetStrip",Msg::kDebug) << " *** FarDetStripListModule::DefaultConfig( ) *** " << endl;

  static Registry r;
  r.SetName("FarDetStripListModule.config.default");
  r.UnLockValues();
  r.Set("FilterOnOff",fFilterOnOff);
  r.Set("FilterMinStrips",fFilterMinStrips);
  r.Set("ListIn",fListIn);
  r.Set("ListOut",fListOut);
  r.Set("RemoveCrossTalk",0);
  r.LockValues();

  AlgFactory &af = AlgFactory::GetInstance();

  af.Register("AlgFarDetStripList","default");
  AlgHandle ah_list = af.GetAlgHandle("AlgFarDetStripList","default");
  AlgConfig &ac_list = ah_list.GetAlgConfig();
  ac_list.UnLockValues();
  ac_list.Set("RemoveCrossTalk",0);
  ac_list.LockValues();

  af.Register("AlgFarDetStrip","default");
  AlgHandle ah_strip = af.GetAlgHandle("AlgFarDetStrip","default");
  AlgConfig &ac_strip = ah_strip.GetAlgConfig();
  ac_strip.UnLockValues();
  ac_strip.LockValues();

  return r;
}
  
void FarDetStripListModule::Config(const Registry &r)
{
  MSG("FarDetStrip",Msg::kDebug) << " *** FarDetStripListModule::Config( ) *** " << endl;

  Int_t tmpint; const char* tmpchar = 0;

  if(r.Get("FilterOnOff",tmpint)) fFilterOnOff = tmpint;
  if(r.Get("FilterMinStrips",tmpint)) fFilterMinStrips = tmpint;
  if(r.Get("ListIn",tmpchar)) fListIn = tmpchar;
  if(r.Get("ListOut",tmpchar)) fListOut = tmpchar;

  AlgFactory &af = AlgFactory::GetInstance();

  AlgHandle ah_list = af.GetAlgHandle("AlgFarDetStripList","default");
  AlgConfig &ac_list = ah_list.GetAlgConfig();
  ac_list.UnLockValues();
  if(r.Get("RemoveCrossTalk",tmpint)) ac_list.Set("RemoveCrossTalk",tmpint);
  ac_list.LockValues();

  AlgHandle ah_strip = af.GetAlgHandle("AlgFarDetStrip","default");
  AlgConfig &ac_strip = ah_strip.GetAlgConfig();
  ac_strip.UnLockValues();
  ac_strip.LockValues();

  MSG("FarDetStrip",Msg::kDebug) << "  configuration : " << endl
                                << "     FilterOnOff=" << fFilterOnOff << endl
                                << "     FilterMinStrips=" << fFilterMinStrips << endl
                                << "     ListIn=" << fListIn.Data() << endl
                                << "     ListOut=" << fListOut.Data() << endl;
    
  return;
}
  
void FarDetStripListModule::HandleCommand(JobCommand *command)
{
  TString cmd = command->PopCmd();
  if(cmd=="Set"){
    TString opt = command->PopOpt();

  }
}
  
void FarDetStripListModule::EndJob()
{
  MSG("FarDetStrip",Msg::kDebug) << " *** FarDetStripListModule::EndJob( ) *** " << endl;

  if(fFarDetStripFile){
    MSG("FarDetStrip",Msg::kDebug) << " *** saving STRIP INFO to file *** " << endl;
    TDirectory* tmpddd = gDirectory;
    fFarDetStripFile->cd();
    fFarDetStripTree->Write();
    fFarDetStripFile->Close();
    gDirectory = tmpddd;
    MSG("FarDetStrip",Msg::kDebug) << "    ... data saved to file *** " << endl;
  }
}

Int_t FarDetStripListModule::ApplyFilter(FarDetStripListHandle* /* csh */)
{
  Int_t filter=0;

  MSG("FarDetStrip",Msg::kDebug) 
    << "  *** STRIP FILTER *** " << endl
    << "    Good Strips = ..." << endl;

  if( 0>fFilterMinStrips ) filter=1;

  return filter;
}

---