JobCRootCommandModule.cxx

Go to the documentation of this file.

// $Id: JobCRootCommandModule.cxx,v 1.11 2005/06/25 20:03:11 rhatcher Exp $
#include "JobControl/JobCRootCommandModule.h"

#include "JobControl/JobCRootModule.h"

#include <cassert>

// ROOT include files
#include "TROOT.h"
#include "TSystem.h"
#include "TObjectTable.h"
#include "TRint.h"
#include "TEnv.h"
#include "TInterpreter.h"
// for function: char* Form(const char *fmt, ...)
#include "TString.h"

#include "JobControl/JobCResult.h"
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCommand.h"

#include "MessageService/MsgService.h"

CVSID("$Id: JobCRootCommandModule.cxx,v 1.11 2005/06/25 20:03:11 rhatcher Exp $");
JOBMODULE(JobCRootCommandModule, 
          "RootCommand", "Handle lists of ROOT commands to run during path execution");

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

JobCRootCommandModule::JobCRootCommandModule() 
{
   MSG("Root",Msg::kVerbose) << "JobCRootCommandModule::ctor" << endl;
}

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

JobCRootCommandModule::~JobCRootCommandModule() 
{
   MSG("Root",Msg::kVerbose) << "JobCRootCommandModule::dtor" << endl;
}

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

void JobCRootCommandModule::Report() 
{
   MSG("Root",Msg::kWarning) << "JobCRootCommandModule::Report" << endl;
}

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

void JobCRootCommandModule::Reset() 
{
   MSG("Root",Msg::kWarning) << "JobCRootCommandModule::Reset" << endl;
}

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

void JobCRootCommandModule::Init() 
{
   // Perform any necessary initialization
   // including putting TApplication into TRint-like mode
   // use JobCRootModule to do most of the work
   MSG("Root",Msg::kVerbose) << "JobCRootCommandModule::Init" << endl;

   static bool first = true;
   if (!first) return;

   first = false;
   JobCRootModule::InitRoot();

}

//......................................................................
JobCResult JobCRootCommandModule::Ana(const MomNavigator *mom)
{
   MSG("Root",Msg::kDebug) 
     << GetUniqueName() << " JobCRootCommandModule::Ana" << endl;

   static JobCResult result;
   result = JobCResult(JobCResult::kAOK); // initialize each time

   JobCRootModule::PassPtrToRoot("MomNavigator","mom",mom,true);
   JobCRootModule::PassPtrToRoot("JobCResult","jobcresultptr",&result,false);
   Init();
   TApplication* app = gROOT->GetApplication();
   app->ProcessLine("JobCResult& jobcresult = *jobcresultptr;");

   ProcessLines("Ana");
   MSG("JobC",Msg::kDebug) 
     << "RootCommand::Ana returned result " << result << endl;
   return result;
}

JobCResult JobCRootCommandModule::Reco(MomNavigator *mom)
{ 
   MSG("Root",Msg::kDebug)
     << GetUniqueName() << " JobCRootCommandModule::Reco" << endl;

   static JobCResult result;
   result = JobCResult(JobCResult::kAOK); // initialize each time
   Init();
   JobCRootModule::PassPtrToRoot("MomNavigator","mom",mom,false);
   JobCRootModule::PassPtrToRoot("JobCResult","jobcresultptr",&result,false);

   TApplication* app = gROOT->GetApplication();
   app->ProcessLine("JobCResult& jobcresult = *jobcresultptr;");

   ProcessLines("Reco");
   MSG("JobC",Msg::kDebug) 
     << "RootCommand::Reco returned result " << result << endl;
   return result;
}

//......................................................................
void JobCRootCommandModule::BeginJob()  
{ 
  MSG("JobC",Msg::kDebug)
    << GetUniqueName() << " RootCommand::BeginJob" << endl;
  ProcessLines("BeginJob"); 
}
void JobCRootCommandModule::EndJob()    
{ 
  MSG("JobC",Msg::kDebug) 
    << GetUniqueName() << " RootCommand::EndJob" << endl;
  ProcessLines("EndJob"); 
}
void JobCRootCommandModule::BeginFile() 
{ 
  MSG("JobC",Msg::kDebug)
    << GetUniqueName() << " RootCommand::BeginFile " 
    << GetCurrentFile() << endl;
  ProcessLines("BeginFile"); 
}
void JobCRootCommandModule::EndFile()   
{ 
  MSG("JobC",Msg::kDebug)
    << GetUniqueName() << " RootCommand::EndFile " 
    << GetLastFile() << endl;
  ProcessLines("EndFile");
}
void JobCRootCommandModule::BeginRun()  
{ 
  MSG("JobC",Msg::kDebug)
    << GetUniqueName() << " RootCommand::BeginRun " 
    << GetCurrentRun() << endl;
  ProcessLines("BeginRun");
}
void JobCRootCommandModule::EndRun()    
{ 
  MSG("JobC",Msg::kDebug)
    << GetUniqueName() << " RootCommand::EndRun " 
    << GetLastRun() << endl;
  ProcessLines("EndRun"); 
}

//......................................................................
JobCResult JobCRootCommandModule::Get(MomNavigator *mom)
{ 
   MSG("Root",Msg::kDebug) << "JobCRootCommandModule::Get" << endl;

   JobCRootModule::PassPtrToRoot("MomNavigator","mom",mom,false);
   ProcessLines("Get"); 
   return JobCResult::kAOK;
}

JobCResult JobCRootCommandModule::Put(const MomNavigator *mom)
{ 
   MSG("Root",Msg::kDebug) << "JobCRootCommandModule::Put" << endl;

   JobCRootModule::PassPtrToRoot("MomNavigator","mom",mom,true);
   ProcessLines("Put");
   return JobCResult::kAOK;
}

//......................................................................
vector<string>* JobCRootCommandModule::WhichLinesList(string whichlist) 
{
   if (whichlist == "Ana"           ) return &fAnaLines;
   if (whichlist == "Reco"          ) return &fRecoLines;

   if (whichlist == "BeginJob"      ) return &fBeginJobLines;
   if (whichlist == "EndJob"        ) return &fEndJobLines;
   if (whichlist == "BeginFile"     ) return &fBeginFileLines;
   if (whichlist == "EndFile"       ) return &fEndFileLines;
   if (whichlist == "BeginRun"      ) return &fBeginRunLines;
   if (whichlist == "EndRun"        ) return &fEndRunLines;

   if (whichlist == "Get"           ) return &fGetLines;
   if (whichlist == "Put"           ) return &fPutLines;

   MSG("Root",Msg::kInfo) 
      << "JobCRootCommandModule::WhichLinesList \"" 
      << whichlist
      << "\" not a recoginized list"
      << endl;

   return 0;
}
//......................................................................
void JobCRootCommandModule::ProcessLines(string whichlist) 
{
   // process (ie. feed to ROOT) some set of command lines
   // relevant for a new Mom of data or a status change

   vector<string>* lines = WhichLinesList(whichlist);
   if (!lines) return;

   // make sure TApp is running so that CINT with <iostream.h> is defined
   Init();
   TApplication* app = gROOT->GetApplication();
   
   vector<string>::const_iterator itrend(lines->end());
   vector<string>::const_iterator itr;

   for (itr = lines->begin(); itr != itrend; ++itr) {
      app->ProcessLine((*itr).c_str());
   }

}

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

void JobCRootCommandModule::HandleCommand(JobCommand* cmd) 
{

   static int ncmd = 0;
   ncmd++;

   class BadJobCRootCommandCmd { };

   // make sure TApp is running so that CINT with <iostream.h> is defined
   Init();

   try {
      TApplication* app = gROOT->GetApplication();
      if (!app) abort();        // mostly to qwell "unsused var" warnings.
      const char* c = cmd->PopCmd();
      if (c) {
         string sc(c);
         const char* entry = cmd->PopCmd();
         // if no further part of the command: assume user meant "Ana"
         if (!entry) entry = "Ana";
         string sentry(entry);
         // which set of lines
         vector<string>* lines = WhichLinesList(sentry);
         if (!lines) {
            MSG("Root",Msg::kWarning) 
               << "\"" << sentry << "\":"
               << " Not a valid entry point for " << sc << " command" << endl;
            throw BadJobCRootCommandCmd();
         }
         if (sc == "AddLine" || sc == "Addline") {
            string wholeLine;
            // eat up rest of line
            while (const char* opt = cmd->PopOpt()) {
               wholeLine += " ";  // put back in the spaces
               wholeLine += opt;
            }
            lines->push_back(wholeLine);
         }
         else if (sc == "Clear") {
            lines->clear();
         }
         else if (sc == "Show") {
            vector<string>::const_iterator itrend(lines->end());
            vector<string>::const_iterator itr;
            int i = 0;
            for (itr = lines->begin(); itr != itrend; ++itr) {
               MSG("Root",Msg::kInfo) 
                  << " [" << i++ << "] " << (*itr) << endl;
            }
         }
         else {
            MSG("Root",Msg::kWarning) 
               << "\"" << sc << "\":"
               << " Not a valid command" << endl;
            throw BadJobCRootCommandCmd();
         }
      }
      else {
         throw BadJobCRootCommandCmd();
      }
   }
   catch ( BadJobCRootCommandCmd ) {
      static bool firsthelp = true;
      if (firsthelp) Help();
      firsthelp = false;
   }
}

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

void JobCRootCommandModule::Help()
{
   //
   // Print help for this module
   //

   const char *name = this->GetName();

   MSG("JobC", Msg::kInfo)
      << "Help for '" << name << "': " << endl
      << name 
      << " is a JobCModule allowing access to scripts from JobControl." 
      << endl
      << " Lines of text are processed as if typed at the ROOT prompt at"
      << endl
      << " various stages of the job process (ala entry points)."
      << endl
      << " The legal entry points are: " 
      << endl << "   Analysis/Reconstruction:"
      << endl << "     Ana            - read-only analysis of data records"
      << endl << "     Reco           - read-write access to data records"
      << endl << "   Status changes:"
      << endl << "     BeginJob  - Notice of begin job"
      << endl << "     EndJob    - Notice of end job"
      << endl << "     BeginFile - Notice of begin of file"
      << endl << "     EndFile   - Notice of end of file"
      << endl << "     BeginRun  - Notice of begin of run"
      << endl << "     EndRun    - Notice of end of run"
      << endl << "   I/O Methods (in general provided by framework):"
      << endl << "     Get - get a header/event"
      << endl << "     Put - write a header/event"
      << endl << endl
      << " As necessary the relevant MomNavigator* is made available to ROOT as \"mom\""
      << endl 
      << " \"Ana\" is the default entry point"
      << endl << endl
      << "Commands implemented:" 
      << endl << endl
//--------------
      << "  /" << name << "/AddLine[/<entrypoint>] <arbitrary text>"
      << endl
      << "     Add a line of text to end of the list -- text is interpeted when the "
      << endl
      << "     entry point is processed in the path"
      << endl << endl
//--------------
      << "  /" << name << "/Show[/<entrypoint>]"
      << endl
      << "     Show the ordered list of lines. "
      << endl << endl
//--------------
      << "  /" << name << "/Clear[/<entrypoint>]"
      << endl
      << "     Clear the list of lines. "
      << endl << endl
//--------------
      << endl;
}

---