JobCPath Class Reference

#include <JobCPath.h>

Inheritance diagram for JobCPath:

List of all members.

Public Types
typedef enum JobCPath::ERunMode	RunMode_t
typedef list< JobCModule * >::const_iterator	ModuleIterator
typedef list< JobCNode * >::const_iterator	NodeIterator
enum	ERunMode { kRunAll, kRunNin, kRunNpass, kRunNfail }
Public Member Functions
	JobCPath ()
	JobCPath (const char *name, MomNavigator *mom, JobCInputModule *input)
virtual	~JobCPath ()
JobCModule &	Mod (const char *moduleName)
JobCNode &	Node (const char *nodeName)
void	Report ()
void	Run (int n=JOBCPATH_RUN_LIMIT, RunMode_t mode=JobCPath::kRunNin)
void	RunNin (int n)
void	RunNpass (int n)
void	RunNfail (int n)
void	SetAllFilters (bool onOff)
void	ReverseAllFilters ()
JobCResult	LastResult () const
const char *	GetName () const
void	Print (ostream &os) const
JobCModule *	GetModule (const char *moduleName, bool create=false)
JobCNode *	FindNode (const char *module, const char *method)
JobCInputModule *	GetInputModule ()
JobCNode *	PushFront (const char *moduleName, const char *methodName)
JobCNode *	PushBack (const char *moduleName, const char *methodName)
JobCNode *	AddAt (const char *moduleName, const char *methodName, int n)
JobCNode *	AddBetween (const char *moduleName, const char *methodName, const char *afterNodeName, const char *beforeNodeName)
void	Remove (const char *moduleName, const char *methodName)
void	Attach (JobCGraphVtx *p)
void	Detach (JobCGraphVtx *p)
bool	EvalInput (JobCRecord *rec)
JobCResult	Execute (JobCRecord *rec)
void	BeginJob () const
ModuleIterator	GetModuleBegin ()
ModuleIterator	GetModuleEnd ()
NodeIterator	GetNodeBegin ()
NodeIterator	GetNodeEnd ()
void	HandleResult (const JobCResult &r) const
void	SetRefreshMode (bool onOff) const
JobCPath &	operator= (const JobCPath &)
Private Member Functions
bool	AtJobStart () const
void	CheckResult (const JobCResult &r)
JobCNode *	CreateNode (const char *modName, const char *metName)
bool	HandleError (const JobCResult &r, const JobCNode *n)
void	PropagateRefreshMode (bool onOff)
void	SetUniquePaths (const char *base="")
Static Private Member Functions
void	PropagateResult (const JobCResult &r, JobCPath *p)
Private Attributes
bool	fIsRefreshRun
bool	fAtJobStart
string	fName
int	fNin
int	fNpass
int	fNfail
MomNavigator *	fMom
JobCInputModule *	fInput
list< JobCModule * >	fModuleList
list< JobCNode * >	fNodeList
JobCResult	fResult
JobCModule *	fDummyModule
JobCNode *	fDummyNode
Friends
ostream &	operator<< (ostream &os, const JobCPath &p)

---

Member Typedef Documentation

typedef list<JobCModule*>::const_iterator JobCPath::ModuleIterator

Definition at line 60 of file JobCPath.h. Referenced by GetModuleBegin(), and GetModuleEnd().

typedef list<JobCNode*>::const_iterator JobCPath::NodeIterator

Definition at line 61 of file JobCPath.h. Referenced by GetNodeBegin(), and GetNodeEnd().

typedef enum JobCPath::ERunMode JobCPath::RunMode_t

---

Member Enumeration Documentation

enum JobCPath::ERunMode

Enumeration values: kRunAll  kRunNin  kRunNpass  kRunNfail  Definition at line 53 of file JobCPath.h. { kRunAll, kRunNin, kRunNpass, kRunNfail } RunMode_t;

---

Constructor & Destructor Documentation

JobCPath::JobCPath (   )

Definition at line 140 of file JobCPath.cxx. References MSG. : fIsRefreshRun(false), fAtJobStart(true), fName(""), fNin(0), fNpass(0), fNfail(0), fMom(0), fInput(0), fDummyModule(0), fDummyNode(0) { MSG("JobC", Msg::kDebug) << " default constructor\n"; //cerr << "JobCPath::JobCPath()\n"; }

JobCPath::JobCPath (  const char *  name, MomNavigator *  mom, JobCInputModule *  input )

Definition at line 158 of file JobCPath.cxx. References MSG. : fIsRefreshRun(false), fAtJobStart(true), fName(name), fNin(0), fNpass(0), fNfail(0), fMom(mom), fInput(inp), fDummyModule(0), fDummyNode(0) { //====================================================================== // Purpose: Create and empty, named path which lives in the job // environment "env" // Input : name - the name of this path // : env - pointer to the job environment data //====================================================================== MSG("JobC", Msg::kDebug) << " input module at " << (void*)inp << endl; //cerr << "JobCPath::JobCPath(\""<<name<<"\","<<(void*)mom<<","<<(void*)inp<<")\n"; }

JobCPath::~JobCPath (   )  [virtual]

Definition at line 185 of file JobCPath.cxx. References JobCModule::EndJob(), fDummyModule, fDummyNode, fModuleList, fNodeList, JobCModule::GetName(), GetName(), and MSG. { //====================================================================== // Purpose: Delete a path //====================================================================== MSG("JobC", Msg::kVerbose) << this->GetName() << " destructor" << "\n"; #ifdef SITE_HAS_SIGC this->SigDelete(this); #endif // Delete the nodes attached to this path list<JobCNode*>::iterator itrJobCNode; for (itrJobCNode = fNodeList.begin(); itrJobCNode != fNodeList.end(); ++itrJobCNode) { MSG("JobC", Msg::kVerbose) << " >delete node " << (**itrJobCNode) << "\n"; delete (*itrJobCNode); } // Delete modules attached to this path list<JobCModule*>::iterator itrJobCModule; for (itrJobCModule = fModuleList.begin(); itrJobCModule != fModuleList.end(); ++itrJobCModule) { MSG("JobC", Msg::kVerbose) << " >delete module " << (*itrJobCModule)->GetName() << "\n"; // Tell the module the job is over before deleting it (*itrJobCModule)->EndJob(); delete (*itrJobCModule); } if (fDummyModule) { delete fDummyModule; fDummyModule = 0; } if (fDummyNode) { delete fDummyNode; fDummyNode = 0; } }

---

Member Function Documentation

JobCNode * JobCPath::AddAt (  const char *  moduleName, const char *  methodName, int  n )

Definition at line 584 of file JobCPath.cxx. References CreateNode(), and fNodeList. Referenced by JobCPathModule::Add(). { //====================================================================== // Purpose: Add a module::method pair at the nth position in the path // // Inputs: moduleName - name of the module // methodName - name of the method // // Returns: pointer to node created //====================================================================== // Create the node JobCNode *node = this->CreateNode(moduleName, methodName); // Advance to this place in the list. Note: start at 1 since that's // the way humans count. Ie. n=1 places the node first in the list, // n=2 second in the list etc. list<JobCNode*>::iterator itrJobCNode = fNodeList.begin(); for (int i=1; i<n; ++i) { if (++itrJobCNode == fNodeList.end()) break; } // Insert at this point if (node) { fNodeList.insert(itrJobCNode, node); #ifdef SITE_HAS_SIGC this->SigUpdate(this,JobCPath::kAddNode); #endif } return node; }

JobCNode * JobCPath::AddBetween (  const char *  moduleName, const char *  methodName, const char *  afterNodeName, const char *  beforeNodeName )

Definition at line 619 of file JobCPath.cxx. References CreateNode(), FindNode(), fNodeList, MSG, and JobCommand::SplitLine(). Referenced by atmo_create_path_data(). { //====================================================================== // Purpose: Add a module::method pair to the path between named modules // // Inputs: moduleName - name of the module // methodName - name of the method // afterNodeName - name of the node to insert after // beforeNodeName - name of the node to insert before // // Returns: pointer to node created //====================================================================== // Create the node. JobCNode* newNode = this->CreateNode(moduleName, methodName); if(!newNode){ MSG("JobCPath", Msg::kFatal) << "Could not create node " << moduleName << ":" << methodName << endl; return 0; } // Find the node we have to insert after. std::string afterModule, afterMethod; JobCommand::SplitLine(afterNodeName, ':', afterModule, afterMethod); JobCNode* afterNode = this->FindNode(afterModule.c_str() ,afterMethod.c_str()); // Find the node we have to insert before. std::string beforeModule, beforeMethod; JobCommand::SplitLine(beforeNodeName, ':', beforeModule, beforeMethod); JobCNode* beforeNode = this->FindNode(beforeModule.c_str() ,beforeMethod.c_str()); if(!afterNode){ MSG("JobCPath", Msg::kFatal) << "Could not find node " << afterNodeName << endl; return 0; } if(!beforeNode){ MSG("JobCPath", Msg::kFatal) << "Could not find node " << beforeNodeName << endl; return 0; } list<JobCNode*>::iterator it = fNodeList.begin(); for(; it != fNodeList.end(); ++it){ if(*it == afterNode){ // We found the node to go after. // Find the node we will be before. ++it; // Check it's the one we ought to be before. if(it != fNodeList.end() && *it == beforeNode){ fNodeList.insert(it, newNode); #ifdef SITE_HAS_SIGC this->SigUpdate(this, JobCPath::kAddNode); #endif return newNode; } else{ MSG("JobCPath", Msg::kFatal) << afterNodeName << " and " << beforeNodeName << " are not adjacent\n"; return 0; } } } MSG("JobCPath", Msg::kFatal) << "This should never happen.\n"; return 0; }

bool JobCPath::AtJobStart (   )  const [private]

Definition at line 241 of file JobCPath.cxx. References fAtJobStart. Referenced by Run(). { //====================================================================== // Are we starting a new job? //====================================================================== bool tmp = fAtJobStart; fAtJobStart = false; return tmp; }

void JobCPath::Attach (  JobCGraphVtx *  p  )  [virtual]

Reimplemented from JobCGraphVtx. Definition at line 751 of file JobCPath.cxx. References JobCGraphVtx::Attach(). Referenced by JobCPathModule::Attach(), attach_blinded_output(), attach_mrcc_path_far(), attach_mrcc_path_near(), attach_output_mc(), attach_output_mc_srfitter(), attach_output_mc_srsafitter(), attach_output_srfitter(), and attach_output_srsafitter(). { //====================================================================== // Attach a path to this one //====================================================================== this->JobCGraphVtx::Attach(p); #ifdef SITE_HAS_SIGC this->SigUpdate(this,JobCPath::kAddConnection); #endif }

void JobCPath::BeginJob (   )  const

Definition at line 845 of file JobCPath.cxx. References fModuleList. { //====================================================================== // Purpose: Signal BeginJob for every node in the path // //====================================================================== // First time entering a path, send the begin job message to each // module in the path list<JobCModule*>::const_iterator i(fModuleList.begin()); list<JobCModule*>::const_iterator iEnd(fModuleList.end()); for (; i!=iEnd; ++i) if (*i) (*i)->BeginJob(); }

void JobCPath::CheckResult (  const JobCResult &  r  )  [private]

Definition at line 253 of file JobCPath.cxx. References JobCResult::BeginFile(), JobCResult::BeginRun(), JobCResult::EndFile(), JobCResult::EndRun(), MSG, and PropagateResult(). Referenced by Execute(), and Run(). { //====================================================================== // Purpose: Check the result of a node to see if the path needs to // emit any status changes //====================================================================== // Check conditions that require a response MSG("JobC", Msg::kVerbose) << "CheckResult: Current result is " << r << endl; if ( r.BeginFile() || r.EndFile() || r.BeginRun() || r.EndRun() ) { this->PropagateResult(r,this); } }

JobCNode * JobCPath::CreateNode (  const char *  modName, const char *  metName )  [private]

Definition at line 453 of file JobCPath.cxx. References JobCMethod::GetMethodByName(), GetModule(), JobCMethod::GetName(), JobCModule::GetName(), and MSG. Referenced by AddAt(), AddBetween(), PushBack(), and PushFront(). { //====================================================================== // Purpose: Create a node using a specified module and method // // Inputs: modName - name of the module to use // metName - name of the method to use // // Returns: Pointer to the node created //====================================================================== // Look the module up JobCModule *module = this->GetModule(modName, true); if (module == 0) { MSG("JobC",Msg::kWarning) << "Get failed for module '" << modName << "'.\n"; return 0; } // Get the method const JobCMethod* method = JobCMethod::GetMethodByName(metName); if (method == 0) { MSG("JobC",Msg::kWarning) << "Look up failed for method '" << metName << "'\n"; return 0; } MSG("JobC", Msg::kDebug) << "Created node " << module->GetName() << "::" << method->GetName() << "\n"; // Create the node JobCNode* n = new JobCNode(module, method); #ifdef SITE_HAS_SIGC if (n) { // Attach the Filter update signal to the node's filter update signal n->SigUpdate.connect(SigC::slot_class(*this,&JobCPath::NodeUpdateCB)); } #endif return n; }

void JobCPath::Detach (  JobCGraphVtx *  p  )  [virtual]

Reimplemented from JobCGraphVtx. Definition at line 764 of file JobCPath.cxx. References JobCGraphVtx::Detach(). { //====================================================================== // Attach a path to this one //====================================================================== this->JobCGraphVtx::Detach(p); #ifdef SITE_HAS_SIGC this->SigUpdate(this,JobCPath::kRemoveConnection); #endif }

bool JobCPath::EvalInput (  JobCRecord *  rec  )  [virtual]

Implements JobCGraphVtx. Definition at line 733 of file JobCPath.cxx. References JobCResult::EndOfInputStream(), Execute(), JobCResult::Failed(), and MSG. { //====================================================================== // Evaluate this node in the graph //====================================================================== // Get the result of running this path JobCResult result = this->Execute(rec); MSG("JobC", Msg::kVerbose) << "EvalInput gets result = " << result << endl; // Decide if execute was sucessful or not if ( result.EndOfInputStream() || result.Failed() ) return false; return true; }

JobCResult JobCPath::Execute (  JobCRecord *  rec  )

Definition at line 777 of file JobCPath.cxx. References CheckResult(), JobCResult::EndOfInputStream(), JobCResult::Failed(), fInput, fIsRefreshRun, fNodeList, fResult, JobCRecord::GetDataPtr(), HandleError(), JobCResult::HaveError(), MsgTripWire::Instance(), MSG, JobCResult::NonPhysicsRecord(), JobCRecord::SetIsPhysics(), and MsgTripWire::StartNode(). Referenced by EvalInput(). { //====================================================================== // Purpose: Run a record through every node in the path // // Inputs: rec - the MINOS Object Map that holds the data to process // // Returns: Pass/Fail depending on whether the record passed every node //====================================================================== // Count events processed ++fNin; // Loop over all nodes in path list<JobCNode*>::iterator itrJobCNode(fNodeList.begin()); list<JobCNode*>::iterator itrEnd(fNodeList.end()); for (;itrJobCNode != itrEnd; ++itrJobCNode) { // We'll need to make some querries about what kind of node this // is, so get the method type JobCMethod m = (*itrJobCNode)->GetMethod(); // Don't evalute Get methods on "refresh" runs // This makes sense in the "old" framework (hence the fInput=0 if (fInput==0 && (fIsRefreshRun == true) && (m == JobCMethod::kGet)) { continue; } // Evaluate this node MsgTripWire::Instance().StartNode(); //Record start of node fResult = (*itrJobCNode)->Execute(rec->GetDataPtr()); MSG("JobC", Msg::kVerbose) << "Result of node " << *(*itrJobCNode) << "execution is: " << fResult << endl; // See if the job module produced any errors, warnings, or other // conditions which require special handling if (fResult.HaveError()) { bool stopRun = this->HandleError(fResult,(*itrJobCNode)); if (stopRun) return fResult; } // On end of input we have to adjust the counter since the stream // failed to deliver a new record if ( fResult.EndOfInputStream() ) { --fNin; return fResult; } // See if record was labeled non-phyiscs if ( fResult.NonPhysicsRecord() ) rec->SetIsPhysics(false); // See if this result has triggered any status changes this->CheckResult(fResult); // Exit on failure if (fResult.Failed()) { ++fNfail; return fResult; } } // loop on nodes // Passed all nodes ++fNpass; return fResult; }

JobCNode * JobCPath::FindNode (  const char *  module, const char *  method )

Definition at line 347 of file JobCPath.cxx. References fNodeList. Referenced by AddBetween(), Node(), and JobCPathHandler::PathFilterCommand(). { //====================================================================== // Purpose: Look for a node which matches the module method pair //====================================================================== list<JobCNode*>::const_iterator itr(fNodeList.begin()); list<JobCNode*>::const_iterator itrEnd(fNodeList.end()); for (; itr!=itrEnd; ++itr) { if ((*itr)->MatchModuleMethod(module,method)) { return (*itr); } } return 0; }

JobCInputModule * JobCPath::GetInputModule (   )

Definition at line 362 of file JobCPath.cxx. Referenced by JobCModule::GetJobCInputModule(). { return fInput; }

JobCModule * JobCPath::GetModule (  const char *  moduleName, bool  create = false )

Definition at line 311 of file JobCPath.cxx. References JobCModuleProxy::CreateModule(), fModuleList, fName, JobCModuleRegistry::Instance(), JobCModuleRegistry::LookUp(), MSG, and JobCModule::SetPath(). Referenced by CreateNode(), JobController::HandleCommand(), and Mod(). { //====================================================================== // Get the module named "moduleName" in this path. If no module is // found then the method returns 0 if create==false. If create==true // the a module with the given name is created and a pointer to it // returned. //====================================================================== list<JobCModule*>::iterator itrJobCModule(fModuleList.begin()); list<JobCModule*>::iterator itrEnd(fModuleList.end()); for (;itrJobCModule != itrEnd; ++itrJobCModule) { if (strcmp(moduleName,(*itrJobCModule)->GetName())==0) { MSG("JobC",Msg::kVerbose) << "Found " << moduleName << " in path " << fName << "\n"; return (*itrJobCModule); } } // Failed to find the module. Either return 0 or build the module if (create == false) return 0; // Not found and we've been asked to make one. JobCModuleProxy* jmp = JobCModuleRegistry::Instance().LookUp(moduleName); if (jmp) { JobCModule* m = jmp->CreateModule(); // Remember to delete this! m->SetPath(this); fModuleList.push_back(m); // Add to path's modules return m; } // Errors fall through to here return 0; }

ModuleIterator JobCPath::GetModuleBegin (   )  [inline]

Definition at line 104 of file JobCPath.h. References fModuleList, and ModuleIterator. { return fModuleList.begin(); }

ModuleIterator JobCPath::GetModuleEnd (   )  [inline]

Definition at line 105 of file JobCPath.h. References fModuleList, and ModuleIterator. { return fModuleList.end(); }

const char * JobCPath::GetName (   )  const

Definition at line 307 of file JobCPath.cxx. References fName. Referenced by Jint::AddPath(), Jint::EndPathRun(), Mod(), Node(), JobCPathHandler::PathRunCommand(), Print(), Jint::RemovePath(), Jint::UpdatePath(), and ~JobCPath(). { return fName.c_str(); }

NodeIterator JobCPath::GetNodeBegin (   )  [inline]

Definition at line 106 of file JobCPath.h. References fNodeList, and NodeIterator. { return fNodeList.begin(); }

NodeIterator JobCPath::GetNodeEnd (   )  [inline]

Definition at line 107 of file JobCPath.h. References fNodeList, and NodeIterator. { return fNodeList.end(); }

bool JobCPath::HandleError (  const JobCResult &  r, const JobCNode *  n )  [private]

Definition at line 370 of file JobCPath.cxx. References JobCResult::ErrorLevel(), and MSG. Referenced by Execute(). { //====================================================================== // Purpose: Handle any errors that might have occured from executing a // node // // Returns: true - stop the run // false - continue the run //====================================================================== JobCResult::Error_t errlvl = result.ErrorLevel(); if (errlvl == JobCResult::kWarning) { // MSG("JobC",Msg::kWarning) << "Warning in: [" << (*n) << "]\n"; } else if (errlvl == JobCResult::kError) { MSG("JobC",Msg::kError) << "Error in: [" << (*n) << "]\n"; } else { MSG("JobC",Msg::kFatal) << "Fatal error in: [" << (*n) << "]\n"; } // Is error relatively mild? JobCResult::Error_t errorThreshold = JobCResult::kError; if (errlvl < errorThreshold) return false; // Keep rolling... // Is the erro fatal? if (errlvl == JobCResult::kFatal) abort(); return true; // Stop the run }

void JobCPath::HandleResult (  const JobCResult &  r  )  const

Definition at line 269 of file JobCPath.cxx. References JobCResult::BeginFile(), JobCResult::BeginRun(), JobCResult::EndFile(), JobCResult::EndRun(), fModuleList, and MSG. { //====================================================================== // Purpose: Check the result of a node to see if the path needs to // emit any status changes //====================================================================== MSG("JobC", Msg::kVerbose) << "HandleResult: Current result is " << r << endl; bool beginFile = r.BeginFile(); bool endFile = r.EndFile(); bool beginRun = r.BeginRun(); bool endRun = r.EndRun(); list<JobCModule*>::const_iterator itrJobCModule; for (itrJobCModule = fModuleList.begin(); itrJobCModule != fModuleList.end(); ++itrJobCModule) { if (endFile) { (*itrJobCModule)->EndFile(); } if (endRun) { (*itrJobCModule)->EndRun(); } if (beginRun) { (*itrJobCModule)->BeginRun(); } if (beginFile) { (*itrJobCModule)->BeginFile(); } } }

JobCResult JobCPath::LastResult (   )  const [inline]

Definition at line 80 of file JobCPath.h. Referenced by Jint::EndPathRun(). { return fResult; }

JobCModule & JobCPath::Mod (  const char *  moduleName  )

Definition at line 403 of file JobCPath.cxx. References fDummyModule, GetModule(), GetName(), and MSG. Referenced by atmo_configure_common(), atmo_configure_data(), atmo_configure_mc(), attach_blinded_output(), attach_mrcc_path_far(), attach_mrcc_path_near(), attach_output(), attach_output_mc(), attach_output_mc_srfitter(), attach_output_mc_srsafitter(), attach_output_srfitter(), attach_output_srsafitter(), cosmic_configure(), cosmic_do_report(), cosmic_set_filter(), cosmic_set_prescaling(), far_all_configure(), far_all_configure_filters(), far_all_mc_configure(), far_configure(), far_configure_filters(), far_cosmic_mc_configure(), far_cosmic_mc_scale_xtalk(), far_do_report(), far_mc_configure(), far_mc_do_report(), far_spill_configure(), far_spill_configure_filters(), far_spill_do_report(), main(), mc_reco_configure(), mc_reco_cosmic_configure(), mc_reco_cosmic_configure_shower(), mc_reco_do_report(), mc_reco_far_configure(), mc_reco_far_do_report(), merge_configure(), merge_do_report(), near_configure(), near_configure_filter(), near_configure_shower(), near_cosmic_configure(), near_cosmic_do_report(), near_cosmic_mc_configure(), near_cosmic_mc_configure_shower(), near_cosmic_mc_scale_xtalk(), near_cosmic_set_filter(), near_cosmic_set_prescaling(), near_do_report(), near_mc_configure(), near_mc_do_report(), reroot_configure(), reroot_do_report(), spill_configure(), spill_configure_filter(), spill_configure_shower(), spill_do_report(), and use_new_hv_table(). { //====================================================================== // Return the module in this path by name. If not found return a dummy // module. This method is intened for use interactively so it doesn't // use pointers. Ie. it tries to help prevent people from doing // (JobCModule*)0->Method(); which would trash their root session //====================================================================== JobCModule* m = this->GetModule(moduleName, false); if (m) { return (*m); } MSG("JobC",Msg::kWarning) << "Path '" << this->GetName() << "' " << "does not contain module '" << moduleName << "'.\n"; // In this case return a dummy, empty module to avoid having things // complete blow up in the user's face... if (fDummyModule == 0) fDummyModule = new JobCModule; return (*fDummyModule); }

JobCNode & JobCPath::Node (  const char *  nodeName  )

Definition at line 426 of file JobCPath.cxx. References fDummyNode, FindNode(), GetName(), MSG, and JobCommand::SplitLine(). Referenced by attach_blinded_output(), attach_mrcc_path_far(), attach_mrcc_path_near(), cosmic_set_filter(), far_all_configure_filters(), far_configure_filters(), far_spill_configure_filters(), merge_configure_filter(), near_configure_filter(), near_cosmic_set_filter(), and spill_configure_filter(). { //====================================================================== // Return the module in this path by name. If not found return a dummy // module. This method is intened for use interactively so it doesn't // use pointers. Ie. it tries to help prevent people from doing // (JobCModule*)0->Method(); which would trash their root session //====================================================================== std::string module; std::string method; JobCommand::SplitLine(nodeName,':',module,method); JobCNode* n = this->FindNode(module.c_str(),method.c_str()); if (n) { return (*n); } MSG("JobC",Msg::kWarning) << "Path '" << this->GetName() << "' " << "does contain node '" << nodeName << "'.\n"; // In this case return a dummy, empty module to avoid having things // complete blow up in the user's face... if (fDummyNode == 0) fDummyNode = new JobCNode; return (*fDummyNode); }

JobCPath& JobCPath::operator= (  const JobCPath &   )  [inline]

Definition at line 135 of file JobCPath.h. { abort(); return *this; } // no assignment

void JobCPath::Print (  ostream &  os  )  const

Definition at line 97 of file JobCPath.cxx. References fName, fNfail, fNin, fNodeList, fNpass, JobCGraphVtx::GetAttached(), and GetName(). { //====================================================================== // Print the job path to the MsgStream os //====================================================================== os << fName.c_str() << "(" << fNin << " in " << fNpass << " out " << fNfail << " filt.)\n"; int i=0; MsgFormat i1("%3d"); list<JobCNode*>::const_iterator itrEnd = fNodeList.end(); for (list<JobCNode*>::const_iterator itrJobCNode = fNodeList.begin(); itrJobCNode != itrEnd; ++itrJobCNode) { os << i1(++i) << ") " << (**itrJobCNode) << "\n"; } // Print list of paths attached to this one bool haveconnect = false; const JobCGraphVtx* v = 0; for (i=0; (v=this->GetAttached(i))!=0; ++i) { const JobCPath* p2 = dynamic_cast<const JobCPath*>(v); if (p2!=0 && haveconnect==false) { os << " |-->"; } os << "/" << p2->GetName(); haveconnect = true; } if (haveconnect) os << "/\n"; }

void JobCPath::PropagateRefreshMode (  bool  onOff  )  [private]

Definition at line 870 of file JobCPath.cxx. References JobCPathConnectionHelper::SetRefreshMode(). Referenced by Run(). { //====================================================================== // Tell this path and all others attached that we're in refresh mode m //====================================================================== JobCPathConnectionHelper h(this); h.SetRefreshMode(m); }

void JobCPath::PropagateResult (  const JobCResult &  r, JobCPath *  p )  [static, private]

Definition at line 295 of file JobCPath.cxx. References JobCPathConnectionHelper::DoHandleResult(). Referenced by CheckResult(). { //====================================================================== // Send the result r to all the paths attached to path p //====================================================================== // Use the print helper to get the list of attached paths JobCPathConnectionHelper h(p); h.DoHandleResult(r); }

JobCNode * JobCPath::PushBack (  const char *  moduleName, const char *  methodName )

Definition at line 553 of file JobCPath.cxx. References CreateNode(), fNodeList, and MSG. Referenced by JobCPathModule::Add(), atmo_create_path_mc(), attach_mrcc_path_far(), attach_mrcc_path_near(), attach_output_mc(), attach_output_mc_srfitter(), attach_output_mc_srsafitter(), attach_output_srfitter(), attach_output_srsafitter(), JobController::BuildSystemPath(), JobCPathModule::Create(), far_all_create_path(), far_cosmic_mc_create_path(), far_create_path(), far_mc_create_path(), merge_create_path(), near_cosmic_create_path(), near_cosmic_mc_create_path(), near_create_path(), near_mc_create_path(), and reroot_create_path(). { //====================================================================== // Purpose: Add a module::method pair to the end of the path // // Inputs: moduleName - name of the module // methodName - name of the method // // Returns: pointer to the node created //====================================================================== // Create a node JobCNode *node = this->CreateNode(moduleName, methodName); if (node == 0) { MSG("JobC", Msg::kWarning) << "Failed to create node " << moduleName << "::" << methodName << "\n"; return 0; } // Add the node to the front of the list if (node) { fNodeList.push_back(node); #ifdef SITE_HAS_SIGC this->SigUpdate(this,JobCPath::kAddNode); #endif } return node; }

JobCNode * JobCPath::PushFront (  const char *  moduleName, const char *  methodName )

Definition at line 528 of file JobCPath.cxx. References CreateNode(), and fNodeList. { //====================================================================== // Purpose: Add a module::method pair to the begining of the path // // Inputs: moduleName - name of the module // methodName - name of the method // // Returns: pointer to node created //====================================================================== // Create a node JobCNode *node = this->CreateNode(moduleName, methodName); // Add the node to the front of the list if (node) { fNodeList.push_front(node); #ifdef SITE_HAS_SIGC this->SigUpdate(this,JobCPath::kAddNode); #endif } return node; }

void JobCPath::Remove (  const char *  moduleName, const char *  methodName )

Definition at line 694 of file JobCPath.cxx. References fNodeList, and MSG. { //====================================================================== // Purpose: Remove a module::method pair from the path // // Inputs: moduleName - name of the module // methodName - name of the method //====================================================================== // Find the node coresponding to this module/method bool haveMatch = false; // Is there a node that matches list<JobCNode*>::iterator itrJobCNode(fNodeList.begin()); list<JobCNode*>::iterator itrEnd(fNodeList.end()); for (;itrJobCNode != itrEnd; ++itrJobCNode) { if ( (haveMatch = (*itrJobCNode)->MatchModuleMethod(moduleName, methodName))) { break; } } if (haveMatch) { // Delete the node object pointed to delete (*itrJobCNode); // Remove pointer from list fNodeList.erase(itrJobCNode); #ifdef SITE_HAS_SIGC this->SigUpdate(this,JobCPath::kRemoveNode); #endif return; } // No match in list MSG("JobC", Msg::kWarning) << "Path does not contain " << moduleName << "::" << methodName << ".\n"; }

void JobCPath::Report (   )

Definition at line 881 of file JobCPath.cxx. References MSG. Referenced by main(), and run(). { MSG("JobCReport",Msg::kInfo) << (*this) << "\n"; }

void JobCPath::ReverseAllFilters (   )

Definition at line 514 of file JobCPath.cxx. References fNodeList, and JobCNode::ReverseFilter(). Referenced by JobCPathHandler::PathFilterCommand(). { //====================================================================== // Purpose: Reverse the meaning of pass/fail for all active filters //====================================================================== list<JobCNode*>::iterator itr(fNodeList.begin()); list<JobCNode*>::iterator itrEnd(fNodeList.end()); for (; itr!=itrEnd; ++itr) { (*itr)->ReverseFilter(); } }

void JobCPath::Run (  int  n = JOBCPATH_RUN_LIMIT, RunMode_t  mode = JobCPath::kRunNin )

Definition at line 885 of file JobCPath.cxx. References AtJobStart(), CheckResult(), JobCEnv::ContinueRun(), JobCPathConnectionHelper::DoBeginJob(), done(), JobCResult::EndOfInputStream(), JobCGraphVtx::EvaluateGraph(), fInput, fMom, fNfail, fNin, fNpass, fResult, JobCInputModule::GetCurrentRun(), JobCInputModule::GetCurrentSnarl(), JobCEnv::Instance(), MsgService::Instance(), MsgTripWire::Instance(), JOBCPATH_RUN_LIMIT, MSG, JobCInputModule::Next(), PropagateRefreshMode(), JobCRecord::Reset(), SetUniquePaths(), and MsgTripWire::StartRecordSet(). Referenced by main(), JobCPathHandler::PathRunCommand(), run(), RunNfail(), RunNin(), and RunNpass(). { //====================================================================== // Purpose: Run records through the path until the path cannot find // records to process //====================================================================== assert(fMom); JobCRecord rec(fMom); this->SetUniquePaths(); #ifdef SITE_HAS_SIGC this->SigStartRun(this); #endif // n = 0 is a flag to re-run the current event if (n == 0) { this->PropagateRefreshMode(true); this->EvaluateGraph(&rec); this->PropagateRefreshMode(false); #ifdef SITE_HAS_SIGC this->SigEndRun(this); #endif return; } else { // First time entering a path, send the begin job message to each // module in the path, as well as the attached paths. // Use the path helper to process the list of attached paths. if (this->AtJobStart()) { JobCPathConnectionHelper h(this); h.DoBeginJob(); } // n != 0 runs new events bool done = false; // Are we done with the run? int nIn0 = fNin; // Number events already read at start of run int nPass0 = fNpass; // Number events already passed at start of run int nFail0 = fNfail; // Number events already failed at start of run while (done == false) { MsgTripWire::Instance().StartRecordSet(); //Record start of record set rec.Reset(); if (fInput) { fResult = fInput->Next(); // Reset the prefix on future MsgService calls. (MsgService::Instance())->SetCurrentRunSnarl(fInput->GetCurrentRun(), fInput->GetCurrentSnarl()); MSG("JobC", Msg::kVerbose) << "Result input module is: " << fResult << endl; this->CheckResult(fResult); if (fResult.EndOfInputStream()) { done |= true; break; } } this->EvaluateGraph(&rec); // Decide if we're done based on number of events processed // The variables fNin, fNpass, and fNfail get updated as we run done |= ( (runmode == JobCPath::kRunAll) && (false) ); done |= ( (runmode == JobCPath::kRunNin) && (fNin -nIn0 )==n ); done |= ( (runmode == JobCPath::kRunNpass) && (fNpass-nPass0)==n ); done |= ( (runmode == JobCPath::kRunNfail) && (fNfail-nFail0)==n ); // Check if we've reached the end of the input stream if (fResult.EndOfInputStream()) done |= true; // Check run limits from the job environmemt if (JobCEnv::Instance().ContinueRun(fNin) == false) { done |= true; } // Prevent running forever... if ( (fNin-nIn0)==JOBCPATH_RUN_LIMIT ) { MSG("JobC",Msg::kWarning) << "Run limit (" << JOBCPATH_RUN_LIMIT << " records) reached.\n"; done |= true; } } } #ifdef SITE_HAS_SIGC this->SigEndRun(this); #endif }

void JobCPath::RunNfail (  int  n  )

Definition at line 996 of file JobCPath.cxx. References kRunNfail, and Run(). Referenced by JobCPathHandler::PathRunCommand(). { //====================================================================== // Purpose: Run records through the path until n fail //====================================================================== this->Run(n,JobCPath::kRunNfail); }

void JobCPath::RunNin (  int  n  )

Definition at line 975 of file JobCPath.cxx. References kRunNin, and Run(). Referenced by JobCPathHandler::PathRunCommand(). { //====================================================================== // Purpose: Run n records through the path - n=0 is a special case for // interactive jobs //====================================================================== this->Run(n,JobCPath::kRunNin); }

void JobCPath::RunNpass (  int  n  )

Definition at line 986 of file JobCPath.cxx. References kRunNpass, and Run(). Referenced by JobCPathHandler::PathRunCommand(). { //====================================================================== // Purpose: Run records through the path until n pass //====================================================================== this->Run(n,JobCPath::kRunNpass); }

void JobCPath::SetAllFilters (  bool  onOff  )

Definition at line 495 of file JobCPath.cxx. References JobCNode::FilterOff(), JobCNode::FilterOn(), and fNodeList. Referenced by attach_blinded_output(), attach_mrcc_path_far(), attach_mrcc_path_near(), cosmic_set_filter(), far_all_configure_filters(), far_configure_filters(), far_spill_configure_filters(), merge_configure(), near_configure_filter(), near_cosmic_set_filter(), near_mc_configure(), JobCPathHandler::PathFilterCommand(), reroot_configure(), and spill_configure_filter(). { //====================================================================== // Purpose: Set all nodes to filter (true) or not to filter (false) //====================================================================== list<JobCNode*>::iterator itr(fNodeList.begin()); list<JobCNode*>::iterator itrEnd(fNodeList.end()); for (; itr!=itrEnd; ++itr) { if (onOff) { (*itr)->FilterOn(); } else { (*itr)->FilterOff(); } } }

void JobCPath::SetRefreshMode (  bool  onOff  )  const

Definition at line 862 of file JobCPath.cxx. References fIsRefreshRun. { // This bool is mutable so the const is OK fIsRefreshRun = m; }

void JobCPath::SetUniquePaths (  const char *  base = ""  )  [private]

Definition at line 1003 of file JobCPath.cxx. References base, done(), fName, fNodeList, Form(), JobCGraphVtx::GetAttached(), JobCModule::GetName(), and JobCModule::SetUniqueName(). Referenced by Run(). { string path = Form("%s/%s",base,fName.c_str()); list<JobCNode*>::const_iterator nit, done = fNodeList.end(); for (nit = fNodeList.begin(); nit != done; ++nit) { JobCModule* mod = (*nit)->GetModule(); string name = Form("%s/%s",path.c_str(),mod->GetName()); mod->SetUniqueName(name.c_str()); } JobCGraphVtx* v = 0; for (int ind = 0; (v=this->GetAttached(ind))!=0; ++ind) { JobCPath* p2 = dynamic_cast<JobCPath*>(v); p2->SetUniquePaths(path.c_str()); } }

---

Friends And Related Function Documentation

ostream& operator<< (  ostream &  os, const JobCPath &  p )  [friend]

Definition at line 132 of file JobCPath.cxx. { JobCPathConnectionHelper jcpph(&p); return jcpph.DoPrint(os); }

---

Member Data Documentation

bool JobCPath::fAtJobStart [mutable, private]

Definition at line 149 of file JobCPath.h. Referenced by AtJobStart().

JobCModule* JobCPath::fDummyModule [mutable, private]

Definition at line 161 of file JobCPath.h. Referenced by Mod(), and ~JobCPath().

JobCNode* JobCPath::fDummyNode [mutable, private]

Definition at line 162 of file JobCPath.h. Referenced by Node(), and ~JobCPath().

JobCInputModule* JobCPath::fInput [private]

Definition at line 156 of file JobCPath.h. Referenced by Execute(), and Run().

bool JobCPath::fIsRefreshRun [mutable, private]

Definition at line 148 of file JobCPath.h. Referenced by Execute(), and SetRefreshMode().

list<JobCModule*> JobCPath::fModuleList [private]

Definition at line 157 of file JobCPath.h. Referenced by BeginJob(), GetModule(), GetModuleBegin(), GetModuleEnd(), HandleResult(), and ~JobCPath().

MomNavigator* JobCPath::fMom [private]

Definition at line 155 of file JobCPath.h. Referenced by Run().

string JobCPath::fName [private]

Definition at line 150 of file JobCPath.h. Referenced by GetModule(), GetName(), Print(), and SetUniquePaths().

int JobCPath::fNfail [private]

Definition at line 153 of file JobCPath.h. Referenced by Print(), and Run().

int JobCPath::fNin [private]

Definition at line 151 of file JobCPath.h. Referenced by Print(), and Run().

list<JobCNode*> JobCPath::fNodeList [private]

Definition at line 158 of file JobCPath.h. Referenced by AddAt(), AddBetween(), Execute(), FindNode(), GetNodeBegin(), GetNodeEnd(), Print(), PushBack(), PushFront(), Remove(), ReverseAllFilters(), SetAllFilters(), SetUniquePaths(), and ~JobCPath().

int JobCPath::fNpass [private]

Definition at line 152 of file JobCPath.h. Referenced by Print(), and Run().

JobCResult JobCPath::fResult [private]

Definition at line 159 of file JobCPath.h. Referenced by Execute(), and Run().

---

The documentation for this class was generated from the following files:

• JobCPath.h
• JobCPath.cxx

---