Job.cxx

Go to the documentation of this file.

// $Id: Job.cxx,v 1.1 2007/02/09 04:44:13 fmwk Exp $
//
// The basic unit of running MIPP analysis and reconstruction
//
// messier@indina.edu
#include <iostream>
#include <cstring>
#include <ctime>
#include <climits>
#include <list>
#include <string>
#include "TSystem.h"
#include "TProcessID.h"
#include "EventDataModel/EventHandle.h"
#include "EventDataModel/EventHeader.h"
#include "IoModules/ReadWriteModule.h"
#include "JobControl/Job.h"
#include "JobControl/CmdLine.h"
#include "JobControl/Exception.h"
using namespace jobc;

const char* tstamp()
{
//======================================================================
// Provide a nicely formatted, current, time stamp string
//======================================================================
  static char tbuff[32];
  time_t t;
  t = time(0);
  strcpy(tbuff, ctime(&t));
  tbuff[24] = '\0';
  return tbuff;
}

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

Job::Job(const char* name) : 
  Sequence      (name ),
  fInit         (false),
  fCurrentRun   (-1   ),
  fCurrentSubrun(-1   ),
  fCurrentFile  (""   )
{ }

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

int Job::Run(int nevent) 
{
//======================================================================
// Process the next nevents in the queue through this job Use
// nevent=-1 to process all events
//======================================================================
  int  nMemReport = 0;
  bool printFlag = (nevent!=0);

  // Print begin run status
  if (printFlag) {
    std::cout << "** Start job '" << this->Name() << "' "
              << tstamp() << " **" << std::endl;
  }
  
  //
  // Setup the I/O module
  //
  int            nevt = nevent;
  CmdLine& opt  = CmdLine::Instance();
  
  io::ReadWriteModule iomod;
  opt.SetupIoModule(iomod, &nevt);
  bool outfile = !(opt.OutFileName()==std::string(""));
  if (printFlag) iomod.Report();

  // Event loop
  if (nevt==0) {
    edm::EventHandle& evt = iomod.GetEvent();
    this->CheckStatus(iomod.CurrentFile(), &evt);
    this->Exec(evt);
  }
  else {
    int n = 0;
    nMemReport = opt.NmemReport();
    for (; (iomod.ReadOK() && n<nevt); iomod.Advance()) {
      edm::EventHandle& evt = iomod.GetEvent();
      try {
        this->CheckStatus(iomod.CurrentFile(), &evt);
        bool passed = this->Exec(evt);
        if (passed && outfile) iomod.WriteEvent();
      }
      catch(Exception jce) {
        std::cout << "Job assertion '" << jce.fExpression
                  << "' failed:\n";
        if (!jce.fMessage.empty()) std::cout<<"  | "<<jce.fMessage<<"\n";
        std::cout << "  | in " << jce.fFile << ":" << jce.fLine
                  << "\n  |- Run "<<iomod.RunNumber() << " event " 
                  << iomod.EventNumber() << ": " << iomod.CurrentFile()
                  << std::endl;
        if (opt.DumpOnException()) break;
      }
      ++n;
      if (n>0 && nMemReport>0 && n%nMemReport==0) {
        this->ResourceReport(true);
      }
      if (n%1000==0) {
        std::cout << "[" << n << "] " 
                  << tstamp() << " /"
                  << iomod.RunNumber() << ":" << iomod.EventNumber()
                  << "/ " << iomod.CurrentFile()
                  << std::endl;
      }
      // Check for sighup signal
      if (CmdLine::Instance().HaveSIGHUP()==true) {
        std::cout << "** Job ending on SIGHUP " << std::endl;
        break;
      }
    }
  }
  this->CheckStatus(std::string(""),0);

  // Print end run status
  if (printFlag) {
    std::cout << "** " << tstamp() << " End job " << this->Name() 
              << " **" << std::endl;
    this->Print();
  }
  if (nMemReport>0) this->ResourceReport(true);

  return 1;
}

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

void Job::CheckStatus(const std::string&      file, 
                      const edm::EventHandle* evt)
{
//======================================================================
// Check the run status looking for things like new files, new run
// numbers, etc.
//======================================================================
  int run    = -1;
  int subrun = -1;

  if (evt) {
    const edm::EventHeader& head = evt->Header();
    run    = head.Run();
    subrun = head.Subrun();
  }
  
  // Very first time we should issue a begin file, run, and subrun in
  // that order. All other times we need to check the status.
  switch (fInit) {

  case false:
    //------------------------------------------------------------------
    if (run>=0 && subrun>=0) {
      this->NewRun(run, subrun);
      this->NewSubrun(run, subrun);
      this->NewFile(file.c_str());
    }
    break;

  case true:
    //------------------------------------------------------------------
    // Check status changes in order of most frequent to least frequent
    if (fCurrentSubrun != subrun) {
      if (fCurrentSubrun!=-1) this->EndSubrun(fCurrentRun, fCurrentSubrun);
      if (subrun!=-1)         this->NewSubrun(run, subrun);
    }
    if (fCurrentRun != run) {
      if (fCurrentRun!=-1) this->EndRun(fCurrentRun, fCurrentSubrun);
      if (run!=-1) this->NewRun(run, subrun);
    }
    if (fCurrentFile != file) {
      if (fCurrentFile!="") this->EndFile(fCurrentFile.c_str());
      if (file!="")         this->NewFile(file.c_str());
    }
    break;
  }
  fCurrentRun    = run;
  fCurrentSubrun = subrun;
  fCurrentFile   = file;
  fInit          = true;
}

---