ShowerEMListModule.cxx

Go to the documentation of this file.

// $Id: ShowerEMListModule.cxx,v 1.5 2010/01/06 18:47:35 rhatcher Exp $
//
// ShowerEMListModule.cxx
//
// A JobControl Module for filling CandShowerEMList from
// CandSliceList and CandCLusterList
//

#include <cassert>

#include "Algorithm/AlgConfig.h"
#include "Algorithm/AlgFactory.h"
#include "Algorithm/AlgHandle.h"
#include "Calibrator/Calibrator.h"
#include "CandData/CandHeader.h"
#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandShowerEM/CandShowerEMListHandle.h"
#include "CandShowerEM/CandShowerEMList.h"
#include "CandShowerEM/CandShowerEMHandle.h"
#include "CandShowerEM/ShowerEMListModule.h"
#include "Candidate/CandContext.h"
#include "Conventions/Munits.h"
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "RawData/RawDigit.h"
#include "RawData/RawHeader.h"
#include "RawData/RawRecord.h"
#include "RawData/RawChannelId.h"
#include "RawData/RawDaqSnarlHeader.h"
#include "RawData/RawDaqHeaderBlock.h"
#include "RawData/RawDigitDataBlock.h"
#include "RawData/RawVarcErrorInTfBlock.h"
#include "RecoBase/CandStripHandle.h"
#include "RecoBase/CandStripListHandle.h"
#include "RecoBase/CandClusterListHandle.h"
#include "RecoBase/CandSliceListHandle.h"
#include "RecoBase/CandShowerListHandle.h"
#include "RecoBase/CandShowerHandle.h"
#include "Validity/VldContext.h"

ClassImp(ShowerEMListModule)

//......................................................................
CVSID("$Id: ShowerEMListModule.cxx,v 1.5 2010/01/06 18:47:35 rhatcher Exp $");
JOBMODULE(ShowerEMListModule, "ShowerEMListModule",
         "Builds CandShowerEMList from CandSliceList");

//......................................................................
ShowerEMListModule::ShowerEMListModule()
{

}

//......................................................................
ShowerEMListModule::~ShowerEMListModule() 
{

}

//......................................................................
void ShowerEMListModule::BeginJob() 
{

}

const Registry &ShowerEMListModule::DefaultConfig() const
{ 
    
  static Registry def_cfg;
  static bool been_here = false;
  if(been_here) return def_cfg;
  been_here=true;
  
  std::string name = this->JobCModule::GetName();
  name += ".config.default";
  def_cfg.SetName(name.c_str());
  
  def_cfg.Set("ShowerEMListAlgorithm","AlgShowerEMList");
  def_cfg.Set("ShowerEMListAlgConfig","default");
  def_cfg.Set("ListIn","CandSliceList");
  def_cfg.Set("ClusterListIn","CandClusterList");
  def_cfg.Set("ListOut","CandShowerEMList");
  def_cfg.Set("LogLevel","Fatal");
  return def_cfg;
  
}

//......................................................................
JobCResult ShowerEMListModule::Reco(MomNavigator *mom)
{
   JobCResult result(JobCResult::kPassed);

   MSG("ShowerEM", Msg::kVerbose) << "ShowerEMListModule::Reco\n";

   // load configuration 
   const char* tmps = 0;
   const char* alg_name = 0;
   const char* alg_config_name = 0;
   const char* list_in = 0;
   const char* cluster_list=0;
   const char* list_out = 0;

   Registry& cfg = this->GetConfig();
   if (cfg.Get("ShowerEMListAlgorithm",tmps)) alg_name = tmps;
   if (cfg.Get("ShowerEMListAlgConfig",tmps)) alg_config_name = tmps;
   if (cfg.Get("ListIn",tmps)) list_in = tmps;
   if (cfg.Get("ClusterListIn",tmps)) cluster_list = tmps;
   if (cfg.Get("ListOut",tmps)) list_out = tmps;   

   /*
   RawRecord *rr=dynamic_cast<RawRecord *> (mom->GetFragment("RawRecord",0,"DaqSnarl"));
   if (rr==0) { result.SetFailed(); return result; }
   
   const RawDaqSnarlHeader* snarlHdr =
     dynamic_cast<const RawDaqSnarlHeader*>(rr->GetRawHeader());
   if(snarlHdr){
     MSG("ShowerEM", Msg::kInfo) << "ShowerEMListModule::Reco Snarl "
                                 << snarlHdr->GetSnarl() << endl;
   }
   */

   // Find PrimaryCandidateRecord fragment in MOM.
   CandRecord *candrec = dynamic_cast<CandRecord *>
     (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
   if (candrec == 0) {
     MSG("ShowerEM", Msg::kWarning) << "No PrimaryCandidateRecord in MOM."
                                    << endl;
     result.SetWarning().SetFailed();
     return result;
   }

   //(Re)Initialize VldContext in Calibrator   
   Calibrator::Instance().Reset(*candrec->GetVldContext());

   // Find CandSliceList fragment in PrimaryCandidateRecord.
   CandSliceListHandle *cslh = dynamic_cast<CandSliceListHandle *>
     (candrec->FindCandHandle("CandSliceListHandle")); 
   if(!cslh){
     MSG("ShowerEM", Msg::kDebug)
       << "Null CandSlice list.  Bail out of event." << endl;
     result.SetFailed();
     return result;
   }

   // Find CandClusterList fragment in PrimaryCandidateRecord.   
   CandClusterListHandle *cclh = dynamic_cast<CandClusterListHandle *>
     (candrec->FindCandHandle("CandClusterListHandle"));
   if(!cclh){
     MSG("ShowerEM", Msg::kDebug)
       << "Null CandCluster list.  Bail out of event." << endl;
     return result;
   }

   TObjArray cxin;
   cxin.Add(cslh);
   cxin.Add(cclh);
   
   AlgFactory &af = AlgFactory::GetInstance();
   AlgHandle adlh = af.GetAlgHandle(alg_name,alg_config_name);
   CandContext cx(this, mom);
   cx.SetDataIn(&cxin);
   cx.SetCandRecord(candrec);
   CandShowerEMListHandle csllh = CandShowerEMList::MakeCandidate(adlh, cx);
   csllh.SetName(list_out);
   csllh.SetTitle(TString("Created by ShowerEMListModule from ").
                  Append(cslh->GetName()));
   candrec->SecureCandHandle(csllh);

   return result;
}

//......................................................................
// void ShowerEMListModule::Config(const Registry &r)
// {

//   MSG("ShowerEM", Msg::kDebug) << "ShowerEMListModule::Config" << endl;
    
// // Get Singleton instance of AlgFactory.
//   AlgFactory &af = AlgFactory::GetInstance();
    
//   AlgHandle alghandle = af.GetAlgHandle("AlgShowerEM","default");
//   AlgConfig &algconfig = alghandle.GetAlgConfig();
    
//   AlgHandle alglisthandle = af.GetAlgHandle("AlgShowerEMList","default");
//   AlgConfig &alglistconfig = alglisthandle.GetAlgConfig();
    
//   Int_t tmpi;
//   Double_t tmpd;
//   const Char_t *tmpc = 0;

//   alglistconfig.UnLockValues();
//   algconfig.UnLockValues();
    
//   if (r.Get("ListIn",tmpc)) fListIn  = tmpc;
//   if (r.Get("ListOut",tmpc)) fListOut = tmpc;

//   if (r.Get("NIter",tmpi)) algconfig.Set("NIter",tmpi);
//   if (r.Get("CutOff",tmpd)) algconfig.Set("CutOff",tmpd);
//   if (r.Get("ShwFrac",tmpd)) algconfig.Set("ShwFrac",tmpd);
//   if (r.Get("MipCut",tmpd)) algconfig.Set("MipCut",tmpd);
//   if (r.Get("RadCut",tmpd)) algconfig.Set("RadCut",tmpd);
//   if (r.Get("MaxBigPlaneSep",tmpi)) algconfig.Set("MaxBigPlaneSep",tmpi);
//   if (r.Get("IsolatedPlaneCut",tmpi)) algconfig.Set("IsolatedPlaneCut",tmpi);
//   if (r.Get("NGapPlanes",tmpi)) algconfig.Set("NGapPlanes",tmpi);
//   if (r.Get("NGapStrips",tmpi)) algconfig.Set("NGapStrips",tmpi);
//   if (r.Get("MaxAvgDev",tmpd)) algconfig.Set("MaxAvgDev",tmpd);
//   if (r.Get("MaxOffFrac",tmpd)) algconfig.Set("MaxOffFrac",tmpd);
//   if (r.Get("AvgDevCutForLargeOutliers",tmpd)) algconfig.Set("AvgDevCutForLargeOutliers",tmpd);
//   if (r.Get("VtxBegPlaneDiffCut",tmpd)) algconfig.Set("VtxBegPlaneDiffCut",tmpd);
//   if (r.Get("VtxPlaneDiffCut",tmpd)) algconfig.Set("VtxPlaneDiffCut",tmpd);
//   if (r.Get("TrkFraCut",tmpd)) algconfig.Set("TrkFraCut",tmpd);
//   if (r.Get("UVDiffCut",tmpd)) algconfig.Set("UVDiffCut",tmpd);
//   if (r.Get("Mip2GeV",tmpd)) algconfig.Set("Mip2Gev",tmpd);
//   if (r.Get("PE2Mip",tmpd)) algconfig.Set("PE2Mip",tmpd);

//   algconfig.LockValues();
//   alglistconfig.LockValues();
// }

---