Go4Event/TGo4EventProcessor.h

Go to the documentation of this file.

// $Id: TGo4EventProcessor.h 1174 2014-03-05 12:12:05Z linev $
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum f�r Schwerionenforschung GmbH
//                     Planckstr. 1, 64291 Darmstadt, Germany
// Contact:            http://go4.gsi.de
//-----------------------------------------------------------------------
// This software can be used under the license agreements as stated
// in Go4License.txt file which is part of the distribution.
//-----------------------------------------------------------------------

#ifndef TGO4EVENTPROCESSOR_H
#define TGO4EVENTPROCESSOR_H

#include "TGo4EventSource.h"

#include <math.h>

class TH1;
class TH1D;
class TH1F;
class TH1S;
class TH1I;
class TH1C;
class TH2;
class TH2D;
class TH2C;
class TH2F;
class TH2S;
class TH2I;
class TGraph;
class TMultiGraph;
class TCanvas;

class TGo4Condition;
class TGo4WinCond;
class TGo4PolyCond;
class TGo4CondArray;
class TGo4Picture;
class TGo4Parameter;

class TGo4MbsEvent;
class TGo4EventElement;
class TGo4EventCalibration;

class TGo4EventProcessor: public TGo4EventSource {
      friend class TGo4EventElement;

   public:

      TGo4EventProcessor(const char* name);

      virtual ~TGo4EventProcessor();

      void SetInputEvent(TGo4EventElement * raw) { fxInputEvent = raw; }

      inline TGo4EventElement * GetInputEvent() { return fxInputEvent; }

      virtual Bool_t CheckInputEvent(const char* classname);

      void SetCalibration(TGo4EventCalibration * cali) { fxCalibration = cali; }

      TGo4EventCalibration * GetCalibration() { return fxCalibration; }

      virtual Bool_t CheckCalibration(const char* classname);

      /* implemented by subclass to assign correct event structures*/
      virtual void InitEvent(TGo4EventElement*) {}

      /* implemented by subclass to do actual processing. For second step processors!*/
      virtual void FinalizeEvent() {}

      Bool_t AddObject(TNamed * anything, const char* subfolder = 0);

      Bool_t AddHistogram(TH1* his, const char* subfolder = 0, Bool_t replace = kTRUE);

      Bool_t AddParameter(TGo4Parameter* par, const char* subfolder = 0);

      Bool_t AddAnalysisCondition(TGo4Condition* con, const char* subfolder = 0);

      Bool_t AddPicture(TGo4Picture* pic, const char* subfolder = 0);

      Bool_t AddCanvas(TCanvas* can, const char* subfolder = 0);

      Bool_t RemoveHistogram(const char* name);

      Bool_t RemoveParameter(const char* name);

      Bool_t RemoveAnalysisCondition(const char* name);

      Bool_t RemovePicture(const char* name);

      Bool_t RemoveCanvas(const char* name);

      TNamed * GetObject(const char* name, const char* folder = 0);

      TH1* GetHistogram(const char* name);

      TGo4Parameter* GetParameter(const char* name, const char* par_class = 0);

      TGo4Condition* GetAnalysisCondition(const char* name, const char* cond_cl = 0);

      TGo4Picture* GetPicture(const char* name);

      TCanvas* GetCanvas(const char* name);

      TGo4EventElement* GetInputEvent(const char* stepname);

      TGo4EventElement* GetOutputEvent(const char* stepname);

      void Message(Int_t prio, const char* text, ...);

      void SendObjectToGUI(TNamed* ob);

      /* We overwrite the default TNamed::Clear that would
       *  erase our name and title!
       * Implement this method in your parameter class
       * if you would like to reset any values with the
       * eraser button in the gui remote browser*/
      virtual void Clear(Option_t* opt="");

      void SetMakeWithAutosave(Bool_t on = kTRUE);

      Bool_t IsObjMade();

      TH1* MakeTH1(char type, const char* fullname, const char* title,
            Int_t nbinsx, Double_t xlow, Double_t xup,
            const char* xtitle = 0, const char* ytitle = 0);

      TH2* MakeTH2(char type, const char* fullname, const char* title,
            Int_t nbinsx, Double_t xlow, Double_t xup,
            Int_t nbinsy, Double_t ylow, Double_t yup,
            const char* xtitle = 0, const char* ytitle = 0, const char* ztitle =0);

      TGo4WinCond* MakeWinCond(const char* fullname,
            Double_t xmin, Double_t xmax,
            const char* HistoName = 0);

      TGo4WinCond* MakeWinCond(const char* fullname,
            Double_t xmin, Double_t xmax,
            Double_t ymin, Double_t ymax,
            const char* HistoName = 0);

      TGo4PolyCond* MakePolyCond(const char* fullname,
            Int_t npoints,
            Double_t (*points) [2],
            const char* HistoName = 0);

      TGo4Parameter* MakeParameter(const char* fullname,
            const char* classname,
            const char* newcmd = 0);

      Long_t ExecuteScript(const char* script_name);

      /* if true, processor wants to continue with current content of input event
       * event is not refilled from event source, and all previous analysis steps are suspended*/
      Bool_t IsKeepInputEvent()
      {
         return fbKeepInputEvent;
      }

      /* Mark current input event for reprocessing in next cycle
       * In this case, all previous analysis steps are skipped until this is done*/
      void SetKeepInputEvent(Bool_t val=kTRUE)
      {
         fbKeepInputEvent = val;
      }

      /* if true, processor wants to continue filling current output event
       * Event is not stored, and all subsequent analysis steps are skipped*/
      Bool_t IsKeepOutputEvent()
      {
         return fbKeepOutputEvent;
      }

      /* Mark current input event for reprocessing in next cycle
       * In this case, all previous analysis steps are skipped until this is done*/
      void SetKeepOutputEvent(Bool_t val=kTRUE)
      {
         fbKeepOutputEvent = val;
      }

      virtual void UserPreLoop() {}

      virtual void UserPostLoop() {}

   protected:

      TGo4EventProcessor() : fxInputEvent(0), fxCalibration(0), fbKeepInputEvent(kFALSE), fbKeepOutputEvent(kFALSE) {}

   private:

      TGo4EventElement * fxInputEvent; 

      TGo4EventCalibration * fxCalibration;

      Bool_t fbKeepInputEvent; 

      Bool_t fbKeepOutputEvent; 

      ClassDef(TGo4EventProcessor,3)
};

#endif //TGO4EVENTPROCESSOR_H