TRootanaDisplay Class Reference

#include <TRootanaDisplay.hxx>

Inheritance diagram for TRootanaDisplay:

[legend]

Collaboration diagram for TRootanaDisplay:

[legend]

List of all members.

Public Member Functions
	TRootanaDisplay ()
virtual	~TRootanaDisplay ()
virtual void	AddAllCanvases ()=0
	User must.
void	AddSingleCanvas (std::string name, std::string subtab_name=std::string(""))
	Add a new canvas; user will interactively fill it.
void	AddSingleCanvas (TCanvasHandleBase *handleClass, std::string subtab_name=std::string(""))
TMainDisplayWindow *	GetDisplayWindow ()
virtual void	UpdateHistograms (TDataContainer &dataContainer)
	This method can be implemented by users to update user histograms.
virtual void	PlotCanvas (TDataContainer &dataContainer)
	This method can be implemented by users to plotting of current canvas.
virtual void	ResetHistograms ()
	This method can be implemented by users to plotting of current canvas.
void	NextButtonPushed ()
	Method for when next button is pushed (offline mode).
void	EventSkipButtonPushed ()
	Method for when skip event button is pushed (online mode).
void	Reset ()
void	UpdatePlotsAction ()
void	QuitButtonAction ()
	Method to call when 'quit' button is pressed.
void	SetNumberSkipEvent (int number)
std::string	GetDisplayName ()
	Get Display name.
void	SetDisplayName (std::string name)
	Set Display name.
void	Initialize ()
bool	CheckOptionRAD (std::string option)
void	UsageRAD ()
	Also a special version of usage for TRootanaDisplay. See CheckOptionRAD.
TDataContainer *	GetDataContainer ()
	Method to get the data container that event loop owns.
virtual void	Finalize ()
virtual void	Usage (void)
virtual bool	CheckOption (std::string option)
virtual bool	PreFilter (TDataContainer &dataContainer)
bool	IsOnline () const
	Are we processing online data?
bool	IsOffline () const
	Are we processing offline data?
int	GetCurrentRunNumber () const
	Current Run Number.
void	SetCurrentRunNumber (int run)
	Current Run Number.
int	ExecuteLoop (int argc, char *argv[])
	Method to actually process the Midas information, either as file or online.
int	ProcessMidasFile (TApplication *app, const char *fname)
void	DisableAutoMainWindow ()
	Disable automatic creation of MainWindow.
void	UseBatchMode ()
	Use a batch mode, where we don't check ROOT status.
VirtualOdb *	GetODB ()
	Get pointer to ODB variables.
void	OpenRootFile (int run, std::string midasFilename=std::string(""))
	Open output ROOT file.
void	CloseRootFile ()
	Cloe output ROOT file.
bool	IsRootFileValid ()
	Check if output ROOT file is valid and open.
void	DisableRootOutput (bool disable=true)
int	IsRootOutputEnabled ()
void	SetOutputFilename (std::string name)
virtual std::string	SetFullOutputFileName (int run, std::string midasFilename)
void	SetOnlineName (std::string name)
void	ProcessThisEventID (int eventID)
bool	CheckEventID (int eventId)
	Little helper method to check if EventID matchs requested EventID list.
void	SuppressTimestampWarnings ()
bool	GetSuppressTimestampWarnings ()
	Suppress timestamp warnings? true = suppress warnings.
void	UseOnlyRecent (bool setting=true)
Static Public Member Functions
static TRootanaEventLoop &	Get (void)
template<typename T >
static void	CreateSingleton ()
Protected Member Functions
bool	CreateOutputFile (std::string name, std::string options="RECREATE")
Protected Attributes
TDirectory *	fOnlineHistDir
	TDirectory for online histograms.
Static Protected Attributes
static TRootanaEventLoop *	fTRootanaEventLoop = NULL
	The static pointer to the singleton instance.
Private Member Functions
void	InitializeMainWindow ()
	Method to initialize the Main display window.
bool	ProcessMidasEvent (TDataContainer &dataContainer)
	Process each midas event.
void	BeginRun (int transition, int run, int time)
void	EndRun (int transition, int run, int time)
void	SetCachedDataContainer (TDataContainer &dataContainer)
Private Attributes
bool	waitingForNextButton
int	fNumberSkipEventsOnline
int	fNumberSkipEventsOffline
int	fNumberProcessed
bool	fQuitPushed
	Flag to keep track of if quite button has been pushed.
TMainDisplayWindow *	fMainWindow
	The pointer to our display window.
TDataContainer *	fCachedDataContainer
	We keep a cached copy of the midas event (so that it can used for callback).
std::string	fDisplayName
	Display name.
std::vector< std::pair < std::pair< int, int > ,TCanvasHandleBase * > >	fCanvasHandlers

---

Detailed Description

This is an abstract base class for event displays. Users need to define a class that derives from this class in order to make an event display. The only method that users must implement is the method AddAllCanvas(), where the user defines which tabs to use.

The user then needs to define how they what to update and plot histograms. The updating of histograms happens for each event. In online mode, the plotting of histograms only happens for each XX events; for offline mode the plotting happens for each event.

There are two ways that users can decide to update and plot histograms:

1) They can create histograms in their event display class and then fill the methods UpdateHistograms(TDataContainer) and PlotCanvas(TDataContainer). This histograms can then file in the canvases that are added using AddSingleCanvas(std::string name).

2) They can create classes that are derived from TCanvasHandleBase. The derived classes are then added using the method AddSingleCanvas(TCanvasHandleBase* handleClass).

There is no substantial difference between the two methods. The second method is mainly meant to allow the user to separate the methods into separate files for code cleaniness.

Examples of both these methods are available in examples/display_example.cxx

The actual ROOT GUI is encapsulated in a separate class TMainDisplayWindow. The TRootanaDisplay has an instance of this TMainDisplayWindow class. Users will be need to access the TMainDisplayWindow by calling

TRootanaDisplay::GetDisplayWindow()

in order to grab the particular canvas that we want plot on.

There is also the functionality to add sub-tab groups to a particular tab, so that you can have a set of tabs of tabs. To use this functionality you use the syntax

AddSingleCanvas(..., <tab name="" string>="">)

to add a new tab to the top level tab named 'tab name string'.

Definition at line 57 of file TRootanaDisplay.hxx.

---

Constructor & Destructor Documentation

TRootanaDisplay::TRootanaDisplay

(

)

TRootanaDisplay::~TRootanaDisplay

(

)

[virtual]

Definition at line 27 of file TRootanaDisplay.cxx.

References fCanvasHandlers.

                                  {

  for(unsigned int i = 0; i < fCanvasHandlers.size(); i++)
    delete fCanvasHandlers[i].second;

};

---

Member Function Documentation

virtual void TRootanaDisplay::AddAllCanvases

(

)

[pure virtual]

User must.

Implemented in MyTestLoop, and MyTestLoop.

Referenced by InitializeMainWindow().

Here is the caller graph for this function:

void TRootanaDisplay::AddSingleCanvas	(	TCanvasHandleBase *	handleClass,
		std::string	subtab_name = std::string("")
	)

Add a new canvas, using a TCanvasHandleBase class. TRootanaDisplay will take ownership of pointer and delete memory it points to.

Definition at line 74 of file TRootanaDisplay.cxx.

References TMainDisplayWindow::AddCanvas(), fCanvasHandlers, TMainDisplayWindow::GetCompositeFrame(), GetDisplayWindow(), TMainDisplayWindow::GetSubTab(), TCanvasHandleBase::GetTabName(), and TCanvasHandleBase::SetUpCompositeFrame().

                                                                                          {
  
  std::pair<int,int> index = GetDisplayWindow()->AddCanvas(handleClass->GetTabName(),subtab_name);

  std::pair< std::pair<int,int>, TCanvasHandleBase*> tmp(index,handleClass);
  
  fCanvasHandlers.push_back(tmp);
  // Now set up the embedded canvas, if user so desires.
  TGCompositeFrame* embed = GetDisplayWindow()->GetCompositeFrame(index);//ssGetTab()->GetTabContainer(tab_index);
  handleClass->SetUpCompositeFrame(embed,this);

  // If we just created a new sub-tab, grab the tab and add
  // call-back to UpdatePlot
  if(index.second == 0){
    TGTab* tab = GetDisplayWindow()->GetSubTab(index.first);
    tab->Connect("Selected(Int_t)", "TRootanaDisplay", this, "UpdatePlotsAction()");
  }


}

Here is the call graph for this function:

void TRootanaDisplay::AddSingleCanvas	(	std::string	name,
		std::string	subtab_name = std::string("")
	)			[inline]

Add a new canvas; user will interactively fill it.

Definition at line 70 of file TRootanaDisplay.hxx.

References TMainDisplayWindow::AddCanvas(), and fMainWindow.

Referenced by MyTestLoop::AddAllCanvases().

                                                                             {
    fMainWindow->AddCanvas(name,subtab_name);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void TRootanaDisplay::BeginRun	(	int	transition,
		int	run,
		int	time
	)			[private, virtual]

Called before the first event of a file is read, but you should prefer Initialize() for general initialization. This method will be called once for each input file.

Reimplemented from TRootanaEventLoop.

Reimplemented in MyTestLoop.

Definition at line 163 of file TRootanaDisplay.cxx.

References fCanvasHandlers, and UpdatePlotsAction().

                                                             {
  
  std::cout << "Begin of run " << run << " at time " << time << std::endl;
  for(unsigned int i = 0; i < fCanvasHandlers.size(); i++)    
    fCanvasHandlers[i].second->BeginRun(transition,run,time);
  UpdatePlotsAction();
}

Here is the call graph for this function:

bool TRootanaEventLoop::CheckEventID

(

int

eventId

)

[inherited]

Little helper method to check if EventID matchs requested EventID list.

Definition at line 135 of file TRootanaEventLoop.cxx.

References TRootanaEventLoop::fProcessEventIDs.

Referenced by TRootanaEventLoop::ProcessMidasFile().

                                               {

  // If we didn't specify list of accepted IDs, then accept all.
  if(fProcessEventIDs.size()==0) return true;

  // Otherwise check event ID against list
  for(unsigned int i = 0; i < fProcessEventIDs.size(); i++){
    if(fProcessEventIDs[i] == (eventId & 0xFFFF))
      return true;
  }
  
  return false;
}

Here is the caller graph for this function:

bool TRootanaEventLoop::CheckOption

(

std::string

option

)

[virtual, inherited]

Check an option and return true if it is valid. The return value is used to flag errors during option handling. If the options are valid, then CheckOption should return true to indicate success. If there is a problem processing the options, then CheckOption should return false. If this returns false, then the event loop will print the Usage message and exit with a non zero value (i.e. indicate failure).

Reimplemented in MyTestLoop.

Definition at line 131 of file TRootanaEventLoop.cxx.

Referenced by TRootanaEventLoop::ExecuteLoop().

{return false;}

Here is the caller graph for this function:

bool TRootanaDisplay::CheckOptionRAD

(

std::string

option

)

[inline, virtual]

This is a special version of CheckOption that is only used by TRootanaDisplay. This is just so that users still have the ability to set options for executables derived from TRootanaDisplay.

Reimplemented from TRootanaEventLoop.

Definition at line 131 of file TRootanaDisplay.hxx.

References fNumberSkipEventsOffline.

                                       {
    if(option.find("-s") != std::string::npos){
      std::string sub = option.substr(2);
      fNumberSkipEventsOffline = atoi(sub.c_str());
      printf("Will process %i events before plotting first event.\n",fNumberSkipEventsOffline);
      return true;
    }
    return false;
  }

void TRootanaEventLoop::CloseRootFile

(

)

[inherited]

Cloe output ROOT file.

Definition at line 456 of file TRootanaEventLoop.cxx.

References TRootanaEventLoop::fOutputFile.

Referenced by TRootanaEventLoop::ProcessMidasFile(), QuitButtonAction(), and TRootanaEventLoop::~TRootanaEventLoop().

                                     {

  if(fOutputFile) {
                std::cout << "Closing ROOT file " << std::endl;
    fOutputFile->Write();
    fOutputFile->Close();
    fOutputFile=0;
  } 

}

Here is the caller graph for this function:

bool TRootanaEventLoop::CreateOutputFile	(	std::string	name,
		std::string	options = "RECREATE"
	)			[inline, protected, inherited]

Definition at line 198 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fOutputFile.

                                                                       {
    
    fOutputFile = new TFile(name.c_str(),options.c_str());
    
    return true;
  }

template<typename T >

static void TRootanaEventLoop::CreateSingleton

(

)

[inline, static, inherited]

This static templated function will make it a little easier for users to create the singleton instance.

Definition at line 125 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fTRootanaEventLoop.

  {
    if(fTRootanaEventLoop)
      std::cout << "Singleton has already been created" << std::endl;
    else
      fTRootanaEventLoop = new T();
  } 

void TRootanaEventLoop::DisableAutoMainWindow

(

)

[inline, inherited]

Disable automatic creation of MainWindow.

Definition at line 135 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fCreateMainWindow.

{  fCreateMainWindow = false;}

void TRootanaEventLoop::DisableRootOutput

(

bool

disable = true

)

[inline, inherited]

Definition at line 157 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fDisableRootOutput.

Referenced by MyTestLoop::MyTestLoop().

{fDisableRootOutput = disable;};

Here is the caller graph for this function:

void TRootanaDisplay::EndRun	(	int	transition,
		int	run,
		int	time
	)			[private, virtual]

Called after the last event of a file is read, but you should prefer Finalize() for general finalization. This method will be called once for each input file.

Reimplemented from TRootanaEventLoop.

Reimplemented in MyTestLoop.

Definition at line 171 of file TRootanaDisplay.cxx.

References fCanvasHandlers, and UpdatePlotsAction().

Referenced by QuitButtonAction().

                                                           {

  std::cout << "End of run " << run << " at time " << time << std::endl;
  for(unsigned int i = 0; i < fCanvasHandlers.size(); i++)
    fCanvasHandlers[i].second->EndRun(transition,run,time);
  UpdatePlotsAction();

}

Here is the call graph for this function:

Here is the caller graph for this function:

void TRootanaDisplay::EventSkipButtonPushed

(

)

[inline]

Method for when skip event button is pushed (online mode).

Definition at line 98 of file TRootanaDisplay.hxx.

References fMainWindow, fNumberSkipEventsOnline, and TMainDisplayWindow::GetSkipEventButton().

                              {
    fNumberSkipEventsOnline = fMainWindow->GetSkipEventButton()->GetNumberEntry()->GetIntNumber();
  }

Here is the call graph for this function:

int TRootanaEventLoop::ExecuteLoop	(	int	argc,
		char *	argv[]
	)			[inherited]

Method to actually process the Midas information, either as file or online.

Definition at line 177 of file TRootanaEventLoop.cxx.

References TDirectory::cd(), TRootanaEventLoop::CheckOption(), TRootanaEventLoop::CheckOptionRAD(), TRootanaEventLoop::fApp, TRootanaEventLoop::fBufferName, TRootanaEventLoop::fCreateMainWindow, TRootanaEventLoop::Finalize(), TRootanaEventLoop::fIsOffline, TRootanaEventLoop::fMaxEvents, TRootanaEventLoop::fOnlineHistDir, TRootanaEventLoop::fUseBatchMode, TRootanaEventLoop::Initialize(), TRootanaEventLoop::PrintHelp(), TRootanaEventLoop::ProcessMidasFile(), and StartNetDirectoryServer().

Referenced by main().

                                                        {
  
  setbuf(stdout,NULL);
  setbuf(stderr,NULL);
  
  signal(SIGILL,  SIG_DFL);
  signal(SIGBUS,  SIG_DFL);
  signal(SIGSEGV, SIG_DFL);

  std::vector<std::string> args;
  for (int i=0; i<argc; i++)
    {
      if (strcmp(argv[i],"-h")==0)
        PrintHelp(); // does not return
      args.push_back(argv[i]);
    }
  
  
  if(fUseBatchMode){ // Disable creating extra window if batch mode requested.
    fCreateMainWindow = false;
  }
    
  if(gROOT->IsBatch() && !fUseBatchMode) {
    printf("Cannot run in batch mode\n");
    return 1;
  }

  bool forceEnableGraphics = false;
  bool testMode = false;
  int  tcpPort = 0;
  int  rhttpdPort = 0; // ROOT THttpServer port
  const char* hostname = NULL;
  const char* exptname = NULL;
  
  for (unsigned int i=1; i<args.size(); i++) // loop over the commandline options
    {
      const char* arg = args[i].c_str();
      //printf("argv[%d] is %s\n",i,arg);
      
      if (strncmp(arg,"-e",2)==0)  // Event cutoff flag (only applicable in offline mode)
        fMaxEvents = atoi(arg+2);
      else if (strncmp(arg,"-m",2)==0) // Enable memory debugging
        ;//      gEnableShowMem = true;
      else if (strncmp(arg,"-P",2)==0) // Set the histogram server port
        tcpPort = atoi(arg+2);
#ifdef HAVE_THTTP_SERVER
      else if (strncmp(arg,"-r",2)==0) // Set the THttpdServer port
        rhttpdPort = atoi(arg+2);
#endif
      else if (strcmp(arg,"-T")==0)
        testMode = true;
      else if (strcmp(arg,"-g")==0)
        forceEnableGraphics = true;
      else if (strncmp(arg,"-H",2)==0)
        hostname = strdup(arg+2);
      else if (strncmp(arg,"-E",2)==0)
        exptname = strdup(arg+2);
      else if (strncmp(arg,"-b",2)==0){
        fBufferName = std::string(arg+2);        
      }else if (strcmp(arg,"-h")==0)
        PrintHelp(); // does not return
      else if(arg[0] == '-')// Check if a TRootanaDisplay or user-defined options
        if(!CheckOptionRAD(args[i]))
          if(!CheckOption(args[i]))
            PrintHelp(); // does not return
    }
    
  // Do quick check if we are processing online or offline.
  // Want to know before we initialize.
  fIsOffline = false;  
  for (unsigned int i=1; i<args.size(); i++){
    const char* arg = args[i].c_str();
    if (arg[0] != '-')  
      {  
        fIsOffline = true;
      }
  }


  MainWindow *mainWindow=0;
  if(fCreateMainWindow){
    std::cout << "Create main window! " << std::endl;
    mainWindow = new MainWindow(gClient->GetRoot(), 200, 300);
  }

   gROOT->cd();
   fOnlineHistDir = new TDirectory("rootana", "rootana online plots");

#ifdef HAVE_LIBNETDIRECTORY
   if (tcpPort)
     StartNetDirectoryServer(tcpPort, fOnlineHistDir);
#else
   if (tcpPort)
     fprintf(stderr,"ERROR: No support for the TNetDirectory server!\n");
#endif

#ifdef HAVE_THTTP_SERVER

   THttpServer *root_http_serv; // = new THttpServer("http:8080");
   if(rhttpdPort){
     char address[100];
     sprintf(address,"http:%i",rhttpdPort);
     root_http_serv = new THttpServer(address);
   }
#endif
  
   // Initialize the event loop with user initialization.
   Initialize();

   for (unsigned int i=1; i<args.size(); i++){
     const char* arg = args[i].c_str();
     if (arg[0] != '-')  
       {  
           ProcessMidasFile(fApp,arg);
       }
   }

   if (testMode){
     std::cout << "Entering test mode." << std::endl;
     fOnlineHistDir->cd();
     TH1D* hh = new TH1D("test", "test", 100, 0, 100);
     hh->Fill(1);
     hh->Fill(10);
     hh->Fill(50);
     
     fApp->Run(kTRUE);
     if(fCreateMainWindow) delete mainWindow;
     return 0;
   }

   // if we processed some data files,
   // do not go into online mode.
   if (fIsOffline){
     if(fCreateMainWindow) delete mainWindow;
     return 0;
   }
 
#ifdef HAVE_MIDAS
   ProcessMidasOnline(fApp, hostname, exptname);;
#endif
   
   if(fCreateMainWindow) delete mainWindow;
   
   Finalize();
   
   return 0;
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TRootanaEventLoop::Finalize

(

)

[virtual, inherited]

Called after the last event has been processed, but before any open output files are closed.

Definition at line 125 of file TRootanaEventLoop.cxx.

Referenced by TRootanaEventLoop::ExecuteLoop().

{};

Here is the caller graph for this function:

TRootanaEventLoop & TRootanaEventLoop::Get

(

void

)

[static, inherited]

Definition at line 72 of file TRootanaEventLoop.cxx.

References TRootanaEventLoop::fTRootanaEventLoop.

Referenced by main().

                                              {
  
  if(!fTRootanaEventLoop){
    std::cerr << "Singleton Not Instantiated! " 
              << " Need to call something like SomeClass::CreateSingleton<SomeClass>(); Exiting!"
              <<std::endl; exit(0);
  }
  return *fTRootanaEventLoop;
}

Here is the caller graph for this function:

int TRootanaEventLoop::GetCurrentRunNumber

(

)

const [inline, inherited]

Current Run Number.

Definition at line 107 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fCurrentRunNumber.

Referenced by MyTestLoop::ProcessMidasEvent(), QuitButtonAction(), and UpdatePlotsAction().

{return fCurrentRunNumber;};

Here is the caller graph for this function:

TDataContainer* TRootanaEventLoop::GetDataContainer

(

)

[inline, inherited]

Method to get the data container that event loop owns.

Definition at line 49 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fDataContainer.

{return fDataContainer;};

std::string TRootanaDisplay::GetDisplayName

(

)

[inline]

Get Display name.

Definition at line 123 of file TRootanaDisplay.hxx.

References fDisplayName.

Referenced by UpdatePlotsAction().

{return fDisplayName;}

Here is the caller graph for this function:

TMainDisplayWindow* TRootanaDisplay::GetDisplayWindow

(

)

[inline]

Retrieve the main display window, so that users can do things like grab the canvases and update them.

Definition at line 82 of file TRootanaDisplay.hxx.

References fMainWindow.

Referenced by AddSingleCanvas(), InitializeMainWindow(), MyTestLoop::PlotCanvas(), and UpdatePlotsAction().

{ return fMainWindow;}

Here is the caller graph for this function:

VirtualOdb* TRootanaEventLoop::GetODB

(

)

[inline, inherited]

Get pointer to ODB variables.

Definition at line 141 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fODB.

{return fODB;}

bool TRootanaEventLoop::GetSuppressTimestampWarnings

(

)

[inline, inherited]

Suppress timestamp warnings? true = suppress warnings.

Definition at line 189 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fSuppressTimestampWarnings.

{ return fSuppressTimestampWarnings;};

void TRootanaDisplay::Initialize

(

void

)

[inline, virtual]

Called after the arguments are processes but before reading the first event is read

Reimplemented from TRootanaEventLoop.

Definition at line 127 of file TRootanaDisplay.hxx.

References InitializeMainWindow().

                   {
    InitializeMainWindow();
  }

Here is the call graph for this function:

void TRootanaDisplay::InitializeMainWindow

(

)

[private]

Method to initialize the Main display window.

Definition at line 34 of file TRootanaDisplay.cxx.

References AddAllCanvases(), TMainDisplayWindow::BuildWindow(), fMainWindow, fNumberSkipEventsOnline, GetDisplayWindow(), TMainDisplayWindow::GetNextButton(), TMainDisplayWindow::GetQuitButton(), TMainDisplayWindow::GetResetButton(), TMainDisplayWindow::GetSkipEventButton(), TMainDisplayWindow::GetTab(), TRootanaEventLoop::IsOffline(), and TRootanaEventLoop::IsOnline().

Referenced by Initialize().

                                          {

  fMainWindow = new TMainDisplayWindow(gClient->GetRoot(),1200,800,IsOffline()); 
  
  // Link the a bunch of buttons in TMainWindowDisplay to functions in TRootanaDisplay.
  // This bit of ROOT magic requires that the TRootanaDisplay class get rootcint-ed.
  // It also requires that TRootanaDisplay methods be public (protected doesn't work).

  // The reset button
  fMainWindow->GetResetButton()->Connect("Clicked()", "TRootanaDisplay", this, "Reset()");

  // The tab buttons
  fMainWindow->GetTab()->Connect("Selected(Int_t)", "TRootanaDisplay", this, "UpdatePlotsAction()");

  // The quit button
  fMainWindow->GetQuitButton()->Connect("Clicked()", "TRootanaDisplay", this, "QuitButtonAction()");


  // The next button
  if(IsOffline())
    fMainWindow->GetNextButton()->Connect("Clicked()", "TRootanaDisplay", this, "NextButtonPushed()");

  // The event skip counter
  if(IsOnline()){
    TGNumberEntry *skipButton = fMainWindow->GetSkipEventButton();
    skipButton->Connect("ValueSet(Long_t)", "TRootanaDisplay",this, "EventSkipButtonPushed()");
    skipButton->GetNumberEntry()->Connect("ReturnPressed()", "TRootanaDisplay", this, "EventSkipButtonPushed()");
    fNumberSkipEventsOnline = skipButton->GetNumberEntry()->GetIntNumber();    
  }

  // Let the user add all the canvases they want.
  AddAllCanvases();

  // Now map out window.
  GetDisplayWindow()->BuildWindow();


}

Here is the call graph for this function:

Here is the caller graph for this function:

bool TRootanaEventLoop::IsOffline

(

)

const [inline, inherited]

Are we processing offline data?

Definition at line 104 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fIsOffline.

Referenced by InitializeMainWindow().

{return fIsOffline;};

Here is the caller graph for this function:

bool TRootanaEventLoop::IsOnline

(

)

const [inline, inherited]

Are we processing online data?

Definition at line 101 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fIsOffline.

Referenced by InitializeMainWindow(), ProcessMidasEvent(), QuitButtonAction(), and UpdatePlotsAction().

{return !fIsOffline;};

Here is the caller graph for this function:

bool TRootanaEventLoop::IsRootFileValid

(

)

[inline, inherited]

Check if output ROOT file is valid and open.

Definition at line 151 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fOutputFile.

                        {    
    if(fOutputFile) return true;
    return false;
  }

int TRootanaEventLoop::IsRootOutputEnabled

(

)

[inline, inherited]

Definition at line 159 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fDisableRootOutput.

{return !fDisableRootOutput;};

void TRootanaDisplay::NextButtonPushed

(

)

[inline]

Method for when next button is pushed (offline mode).

Definition at line 94 of file TRootanaDisplay.hxx.

References waitingForNextButton.

                         {
    waitingForNextButton = false;
  }

void TRootanaEventLoop::OpenRootFile	(	int	run,
		std::string	midasFilename = std::string("")
	)			[inherited]

Open output ROOT file.

Definition at line 422 of file TRootanaEventLoop.cxx.

References TRootanaEventLoop::fDisableRootOutput, TRootanaEventLoop::fOutputFile, TRootanaEventLoop::fOutputFilename, NetDirectoryExport(), and TRootanaEventLoop::SetFullOutputFileName().

Referenced by TRootanaEventLoop::ProcessMidasFile().

                                                                    {

  if(fDisableRootOutput) return;

  if(fOutputFile) {
    fOutputFile->Write();
    fOutputFile->Close();
    fOutputFile=0;
  }  

  char filename[1024];
        // This is the default filename, using fOutputFilename
        sprintf(filename, "%s%08d.root",fOutputFilename.c_str(), run);

        // See if user has implemented a function where they specify 
        // the root file name using the midas file name...
        // Only works offline, because we need midas file name
        if(midasFilename.compare("") != 0){
                std::string fullname = SetFullOutputFileName(run,midasFilename);
                if(fullname.compare("") != 0){
                        sprintf(filename, "%s",fullname.c_str());
                }
        }
        
  fOutputFile = new TFile(filename,"RECREATE");
  std::cout << "Opened output file with name : " << filename << std::endl;


#ifdef HAVE_LIBNETDIRECTORY
  NetDirectoryExport(fOutputFile, "outputFile");
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void TRootanaDisplay::PlotCanvas

(

TDataContainer &

dataContainer

)

[inline, virtual]

This method can be implemented by users to plotting of current canvas.

Reimplemented in MyTestLoop, and MyTestLoop.

Definition at line 88 of file TRootanaDisplay.hxx.

Referenced by UpdatePlotsAction().

{};

Here is the caller graph for this function:

virtual bool TRootanaEventLoop::PreFilter

(

TDataContainer &

dataContainer

)

[inline, virtual, inherited]

The PreFilter method allows user to specify whether to ignore a particular event. Specifically, if PreFilter returns

true -> then ProcessMidasEvent will be called or false -> then ProcessMidasEvent will not be called

This is particularly useful for the RootanaDisplay, where you might want to only process and plot certain events.

Definition at line 98 of file TRootanaEventLoop.hxx.

Referenced by TRootanaEventLoop::ProcessMidasFile().

{return true;}

Here is the caller graph for this function:

bool TRootanaDisplay::ProcessMidasEvent

(

TDataContainer &

dataContainer

)

[private, virtual]

Process each midas event.

Implements TRootanaEventLoop.

Reimplemented in MyTestLoop.

Definition at line 96 of file TRootanaDisplay.cxx.

References fCachedDataContainer, fCanvasHandlers, fMainWindow, fNumberProcessed, fNumberSkipEventsOffline, fNumberSkipEventsOnline, fQuitPushed, TMainDisplayWindow::IsDisplayPaused(), TRootanaEventLoop::IsOnline(), TMainDisplayWindow::ResetSize(), SetCachedDataContainer(), UpdateHistograms(), UpdatePlotsAction(), and waitingForNextButton.

                                                                    {

  fMainWindow->ResetSize();
  fNumberProcessed++;

  // Only update histograms if we are "offline" or "online and but paused".
  // This ensures that we don't update if the user pressed 'pause' since the 
  // last event.
  if(!IsOnline() || (IsOnline() && !fMainWindow->IsDisplayPaused())){
    SetCachedDataContainer(dataContainer);
    
    // Perform any histogram updating from user code.
    UpdateHistograms(*fCachedDataContainer);
    for(unsigned int i = 0; i < fCanvasHandlers.size(); i++)
      fCanvasHandlers[i].second->UpdateCanvasHistograms(*fCachedDataContainer);
  }  

  // If processing online and if processing is not paused, then just plot and return
  if(IsOnline() && !fMainWindow->IsDisplayPaused() ){
       
    // Do canvas plotting from user code; 
    // only do plot if we have processed enough events
    if(fNumberSkipEventsOnline == 1 || fNumberProcessed % fNumberSkipEventsOnline  == 1){      
      UpdatePlotsAction();
    }
    
    return true;
  }

  // If processing offline, make sure we have skipped the right number of events.
  if(!IsOnline() && fNumberSkipEventsOffline >= fNumberProcessed){
    return true;
  }

  UpdatePlotsAction();

  // If offline, then keep looping till the next event button is pushed.
  // If online, then keep looping till the resume button is pushed.
  waitingForNextButton = true;
  while(1){
    
    // Add some sleeps; otherwise program takes 100% of CPU...
    usleep(1000);

    // ROOT signal/slot trick; this variable will magically 
    // get changed to false once the next button is pushed.
    if(!waitingForNextButton) break;

    // Alternately, break out if in online mode and 
    // no longer in paused state.  Again, the state of variable
    // will be changed by ROOT signal/slot callback.
    if(IsOnline() && !fMainWindow->IsDisplayPaused()) break;    
      
                // Check if quit button has been pushed.  See QuitButtonAction() for details
                if(IsOnline() && fQuitPushed) break;

    // Resize windows, if needed.
    fMainWindow->ResetSize();

    // handle GUI events
    bool result = gSystem->ProcessEvents(); 
    
  }
  return true;

}

Here is the call graph for this function:

int TRootanaEventLoop::ProcessMidasFile	(	TApplication *	app,
		const char *	fname
	)			[inherited]

Treat the begin run and end run events differently.

Definition at line 328 of file TRootanaEventLoop.cxx.

References TRootanaEventLoop::BeginRun(), TRootanaEventLoop::CheckEventID(), TDataContainer::CleanupEvent(), TMidasFile::Close(), TRootanaEventLoop::CloseRootFile(), TRootanaEventLoop::EndRun(), TRootanaEventLoop::fCurrentRunNumber, TRootanaEventLoop::fDataContainer, TRootanaEventLoop::fMaxEvents, TRootanaEventLoop::fODB, TMidasEvent::GetData(), TMidasEvent::GetSerialNumber(), gUseOnlyRecent, TMidasFile::Open(), TRootanaEventLoop::OpenRootFile(), TRootanaEventLoop::PreFilter(), PrintCurrentStats(), TRootanaEventLoop::ProcessMidasEvent(), raTotalEventsProcessed, raTotalEventsSkippedForAge, TMidasFile::Read(), and TDataContainer::SetMidasEventPointer().

Referenced by TRootanaEventLoop::ExecuteLoop().

{
  TMidasFile f;
  bool tryOpen = f.Open(fname);

  if (!tryOpen){
    printf("Cannot open input file \"%s\"\n",fname);
    return -1;
  }

  // This parameter is irrelevant for offline processing.
  gUseOnlyRecent = false;

  int i=0;
  while (1)
    {
      TMidasEvent event;
      if (!f.Read(&event))
        break;
      
      /// Treat the begin run and end run events differently.
      int eventId = event.GetEventId();

      

      if ((eventId & 0xFFFF) == 0x8000){// begin run event
        
        event.Print();
        
        // Load ODB contents from the ODB XML file
        if (fODB) delete fODB;
        fODB = new XmlOdb(event.GetData(),event.GetDataSize());
        
        fCurrentRunNumber = event.GetSerialNumber();
        OpenRootFile(fCurrentRunNumber,fname);
        BeginRun(0,event.GetSerialNumber(),0);
        raTotalEventsProcessed = 0;
        raTotalEventsSkippedForAge = 0;
        
      } else if ((eventId & 0xFFFF) == 0x8001){// end run event
          
                                event.Print();
        //EndRun(0,fCurrentRunNumber,0);
        

      } else if ((eventId & 0xFFFF) == 0x8002){

        event.Print(); 
        printf("Log message: %s\n", event.GetData()); 

      }else if(CheckEventID(eventId)){ // all other events; check that this event ID should be processed.

        // Set the bank list for midas event.
        event.SetBankList();
        
        // Set the midas event pointer in the physics event.
        fDataContainer->SetMidasEventPointer(event);
        
        //ProcessEvent if prefilter is satisfied...
                                if(PreFilter(*fDataContainer))
                                         ProcessMidasEvent(*fDataContainer);
        
        // Cleanup the information for this event.
        fDataContainer->CleanupEvent();
        
      }
 
      PrintCurrentStats();

      // Check if we have processed desired number of events.
      i++;
      if ((fMaxEvents!=0)&&(i>=fMaxEvents)){
        printf("Reached event %d, exiting loop.\n",i);
        break;
      }
    }
  
  f.Close(); 

  EndRun(0,fCurrentRunNumber,0);
  CloseRootFile();  

  // start the ROOT GUI event loop
  //  app->Run(kTRUE);

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TRootanaEventLoop::ProcessThisEventID

(

int

eventID

)

[inline, inherited]

Provide a way to force program to only process certain event IDs. This method can be called repeatedly to specify several different event IDs to accept. If the method is not called then all eventIDs are accepted.

Definition at line 177 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fProcessEventIDs.

                                      {
    fProcessEventIDs.push_back(eventID);
  };

void TRootanaDisplay::QuitButtonAction

(

)

Method to call when 'quit' button is pressed.

Definition at line 234 of file TRootanaDisplay.cxx.

References TRootanaEventLoop::CloseRootFile(), EndRun(), fQuitPushed, TRootanaEventLoop::GetCurrentRunNumber(), and TRootanaEventLoop::IsOnline().

{
  // If we are offline, then we close the ROOT file here.
  // If we are online then the control will return to TRootanaEventLoop::ProcessMidasOnline
  // which will take care of closing the file.

  if(!IsOnline()){
    EndRun(0,GetCurrentRunNumber(),0);
    CloseRootFile();  
  }

        // Set a flag so that we can breakout of loop if 
        // we are ONLINE and PAUSED.
        // It is odd that gApplication->Terminate(0) doesn't 
        // finish, but somehow it seems to wait for the the 
        // RootanaDisplay::ProcessMidasEvent() to finish.
        fQuitPushed = true;
  gApplication->Terminate(0);   
}

Here is the call graph for this function:

void TRootanaDisplay::Reset

(

)

This method calls a couple other methods for resets the histograms. This method is attached using the ROOT signal/input system to the reset button on the canvas.

Definition at line 224 of file TRootanaDisplay.cxx.

References fCanvasHandlers, ResetHistograms(), and UpdatePlotsAction().

                           {
  // Call the reset functions defined in user event loop.
  ResetHistograms();
  // Call the user defined canvas classes.
  for(unsigned int i = 0; i < fCanvasHandlers.size(); i++)
      fCanvasHandlers[i].second->ResetCanvasHistograms();
  UpdatePlotsAction();
}

Here is the call graph for this function:

virtual void TRootanaDisplay::ResetHistograms

(

)

[inline, virtual]

This method can be implemented by users to plotting of current canvas.

Reimplemented in MyTestLoop, and MyTestLoop.

Definition at line 91 of file TRootanaDisplay.hxx.

Referenced by Reset().

{};

Here is the caller graph for this function:

void TRootanaDisplay::SetCachedDataContainer

(

TDataContainer &

dataContainer

)

[inline, private]

Set the cached copy of midas dataContainer. !!! This is very questionable! Caching each dataContainer might add a considerable overhead to the processing!

Definition at line 189 of file TRootanaDisplay.hxx.

References fCachedDataContainer.

Referenced by ProcessMidasEvent().

                                                            {
    if(fCachedDataContainer) delete fCachedDataContainer;
    fCachedDataContainer = new TDataContainer(dataContainer);
  }

Here is the caller graph for this function:

void TRootanaEventLoop::SetCurrentRunNumber

(

int

run

)

[inline, inherited]

Current Run Number.

Definition at line 110 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fCurrentRunNumber.

{fCurrentRunNumber = run;};

void TRootanaDisplay::SetDisplayName

(

std::string

name

)

[inline]

Set Display name.

Definition at line 125 of file TRootanaDisplay.hxx.

References fDisplayName.

Referenced by MyTestLoop::AddAllCanvases().

{fDisplayName = name;}

Here is the caller graph for this function:

virtual std::string TRootanaEventLoop::SetFullOutputFileName	(	int	run,
		std::string	midasFilename
	)			[inline, virtual, inherited]

This is an alternative, more complicated way of setting the output ROOT filename. In this case the user is given the run number and the midas file name and, from that information, constructs the output ROOT filename themselves.

Reimplemented in Analyzer.

Definition at line 168 of file TRootanaEventLoop.hxx.

Referenced by TRootanaEventLoop::OpenRootFile().

                                                                                 {
                return std::string("");
        }

Here is the caller graph for this function:

void TRootanaDisplay::SetNumberSkipEvent

(

int

number

)

[inline]

Function so that user can specify at outset how many events to skip before refreshing display (in online mode).

Definition at line 116 of file TRootanaDisplay.hxx.

References fMainWindow, fNumberSkipEventsOnline, and TMainDisplayWindow::GetSkipEventButton().

Referenced by MyTestLoop::AddAllCanvases().

                                     {
    fNumberSkipEventsOnline = number;
    if(fMainWindow->GetSkipEventButton())
      fMainWindow->GetSkipEventButton()->GetNumberEntry()->SetIntNumber(number);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void TRootanaEventLoop::SetOnlineName

(

std::string

name

)

[inline, inherited]

Definition at line 172 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fOnlineName.

{fOnlineName = name;};

void TRootanaEventLoop::SetOutputFilename

(

std::string

name

)

[inline, inherited]

Set the output filename. File name will be XXX.root, where XXX is run number

Definition at line 163 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fOutputFilename.

Referenced by MyTestLoop::MyTestLoop().

{fOutputFilename = name;};

Here is the caller graph for this function:

void TRootanaEventLoop::SuppressTimestampWarnings

(

)

[inline, inherited]

Suppress the warning methods regarding old timestamp events for online ie warnings about analyzer falling behind data taking.

Definition at line 186 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fSuppressTimestampWarnings.

{ fSuppressTimestampWarnings = true;};

virtual void TRootanaDisplay::UpdateHistograms

(

TDataContainer &

dataContainer

)

[inline, virtual]

This method can be implemented by users to update user histograms.

Reimplemented in MyTestLoop, and MyTestLoop.

Definition at line 85 of file TRootanaDisplay.hxx.

Referenced by ProcessMidasEvent().

{};

Here is the caller graph for this function:

void TRootanaDisplay::UpdatePlotsAction

(

)

This is a generic action to call when some button gets pushed. Also called in regular event handling loop

Definition at line 182 of file TRootanaDisplay.cxx.

References fCachedDataContainer, fCanvasHandlers, fMainWindow, TMainDisplayWindow::GetCurrentEmbeddedCanvas(), TRootanaEventLoop::GetCurrentRunNumber(), TMainDisplayWindow::GetCurrentTabIndex(), GetDisplayName(), GetDisplayWindow(), TMainDisplayWindow::GetMain(), TDataContainer::GetMidasData(), TMidasEvent::GetSerialNumber(), TRootanaEventLoop::IsOnline(), PlotCanvas(), and TMainDisplayWindow::ResetSize().

Referenced by BeginRun(), EndRun(), ProcessMidasEvent(), and Reset().

                                       {

  if(!fCachedDataContainer){
    char displayTitle[200];
    sprintf(displayTitle,"%s (): run %i (no events yet)",
            GetDisplayName().c_str(),GetCurrentRunNumber());
    GetDisplayWindow()->GetMain()->SetWindowName(displayTitle);
    return;
  }
    
  // Execute the plotting actions from user event loop.
  PlotCanvas(*fCachedDataContainer);
  
  // See if we find a user class that describes this tab.
  std::pair<int,int> tabdex = GetDisplayWindow()->GetCurrentTabIndex();
  for(unsigned int i = 0; i < fCanvasHandlers.size(); i++){
    if(tabdex == fCanvasHandlers[i].first){
      TRootEmbeddedCanvas* embed = GetDisplayWindow()->GetCurrentEmbeddedCanvas();
      fCanvasHandlers[i].second->PlotCanvas(*fCachedDataContainer,embed);
    }
  }
    
  
  // Set the display title
  char displayTitle[200];
  if(IsOnline())
    sprintf(displayTitle,"%s (online): run %i event %i",
            GetDisplayName().c_str(),GetCurrentRunNumber(),
            fCachedDataContainer->GetMidasData().GetSerialNumber());
  else
    sprintf(displayTitle,"%s (offline): run %i event %i",
            GetDisplayName().c_str(),GetCurrentRunNumber(),
            fCachedDataContainer->GetMidasData().GetSerialNumber());
    
  GetDisplayWindow()->GetMain()->SetWindowName(displayTitle);


  // Update canvas and window sizes    
  fMainWindow->ResetSize();
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TRootanaEventLoop::Usage

(

void

)

[virtual, inherited]

Called when there is a usage error. This code should print a usage message and then return.

Reimplemented in MyTestLoop.

Definition at line 127 of file TRootanaEventLoop.cxx.

Referenced by TRootanaEventLoop::PrintHelp().

{};

Here is the caller graph for this function:

void TRootanaDisplay::UsageRAD

(

void

)

[inline, virtual]

Also a special version of usage for TRootanaDisplay. See CheckOptionRAD.

Reimplemented from TRootanaEventLoop.

Definition at line 140 of file TRootanaDisplay.hxx.

                 {
    printf("\t-s: will process specified number of events before displaying (for display programs)\n");
  }

void TRootanaEventLoop::UseBatchMode

(

)

[inline, inherited]

Use a batch mode, where we don't check ROOT status.

Definition at line 138 of file TRootanaEventLoop.hxx.

References TRootanaEventLoop::fUseBatchMode.

{  fUseBatchMode = true;}

void TRootanaEventLoop::UseOnlyRecent

(

bool

setting = true

)

[inherited]

Method to set whether analyzer should operate in GET_RECENT mode, where we only process data that is less than 1 second old (this is not default). Setting true will use this option.

Definition at line 416 of file TRootanaEventLoop.cxx.

References gUseOnlyRecent.

                                                 { 

  gUseOnlyRecent = setting;
};

---

Member Data Documentation

TDataContainer* TRootanaDisplay::fCachedDataContainer [private]

We keep a cached copy of the midas event (so that it can used for callback).

Definition at line 184 of file TRootanaDisplay.hxx.

Referenced by ProcessMidasEvent(), SetCachedDataContainer(), and UpdatePlotsAction().

std::vector< std::pair<std::pair<int,int> ,TCanvasHandleBase*> > TRootanaDisplay::fCanvasHandlers [private]

This is a vector of user-defined canvas handler classes. The first part of pair is the tab number.

Definition at line 199 of file TRootanaDisplay.hxx.

Referenced by AddSingleCanvas(), BeginRun(), EndRun(), ProcessMidasEvent(), Reset(), UpdatePlotsAction(), and ~TRootanaDisplay().

std::string TRootanaDisplay::fDisplayName [private]

Display name.

Definition at line 195 of file TRootanaDisplay.hxx.

Referenced by GetDisplayName(), and SetDisplayName().

TMainDisplayWindow* TRootanaDisplay::fMainWindow [private]

The pointer to our display window.

Definition at line 167 of file TRootanaDisplay.hxx.

Referenced by AddSingleCanvas(), EventSkipButtonPushed(), GetDisplayWindow(), InitializeMainWindow(), ProcessMidasEvent(), SetNumberSkipEvent(), and UpdatePlotsAction().

int TRootanaDisplay::fNumberProcessed [private]

Definition at line 161 of file TRootanaDisplay.hxx.

Referenced by ProcessMidasEvent().

int TRootanaDisplay::fNumberSkipEventsOffline [private]

Variable to keep track of how many events to skip when running offline; defined by command line argument.

Definition at line 158 of file TRootanaDisplay.hxx.

Referenced by CheckOptionRAD(), and ProcessMidasEvent().

int TRootanaDisplay::fNumberSkipEventsOnline [private]

Variable to keep track of how many events to skip before updating display; we have separate variable for online and offline modes.

Definition at line 154 of file TRootanaDisplay.hxx.

Referenced by EventSkipButtonPushed(), InitializeMainWindow(), ProcessMidasEvent(), and SetNumberSkipEvent().

TDirectory* TRootanaEventLoop::fOnlineHistDir [protected, inherited]

TDirectory for online histograms.

Definition at line 212 of file TRootanaEventLoop.hxx.

Referenced by TRootanaEventLoop::ExecuteLoop(), MyTestLoop::ProcessMidasEvent(), and TRootanaEventLoop::TRootanaEventLoop().

bool TRootanaDisplay::fQuitPushed [private]

Flag to keep track of if quite button has been pushed.

Definition at line 164 of file TRootanaDisplay.hxx.

Referenced by ProcessMidasEvent(), and QuitButtonAction().

TRootanaEventLoop * TRootanaEventLoop::fTRootanaEventLoop = NULL [static, protected, inherited]

The static pointer to the singleton instance.

Definition at line 209 of file TRootanaEventLoop.hxx.

Referenced by TRootanaEventLoop::CreateSingleton(), and TRootanaEventLoop::Get().

bool TRootanaDisplay::waitingForNextButton [private]

Definition at line 150 of file TRootanaDisplay.hxx.

Referenced by NextButtonPushed(), and ProcessMidasEvent().

---

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

• libAnalyzerDisplay/TRootanaDisplay.hxx
• libAnalyzerDisplay/TRootanaDisplay.cxx