TGo4EventProcessor.h

Go to the documentation of this file.

// $Id$
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum fuer 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 <cmath>

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 TF1;
class TCanvas;

class TGo4Condition;
class TGo4WinCond;
class TGo4PolyCond;
class TGo4ShapedCond;
class TGo4ListCond;
class TGo4RollingGraph;

#ifndef TGo4EllipseCond
#define TGo4EllipseCond TGo4ShapedCond
#endif

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() const { 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 = nullptr);

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

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

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

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

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

      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 = nullptr);

      TH1 *GetHistogram(const char *name);

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

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

      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, ...)
       #if defined(__GNUC__) && !defined(__CINT__)
         __attribute__((format(printf, 3, 4)))
       #endif
      ;

      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*/
      void Clear(Option_t *opt = "") override;

      void SetMakeWithAutosave(Bool_t on = kTRUE);

      Bool_t IsObjMade() const;

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

      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 = nullptr, const char *ytitle = nullptr, const char *ztitle = nullptr);

      TGraph *MakeGraph(const char *fullname, const char *title, Int_t points = 0, Double_t *xvalues = nullptr,
                        Double_t *yvalues = nullptr);

      TGraph *MakeGraph(const char *fullname, const char *title, TF1 *function);

      TGo4RollingGraph *MakeRollingGraph(const char *fullname, const char *title, Int_t points = 0, Int_t average = 1);

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

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

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

      TGo4ShapedCond *MakeEllipseCond(const char *fullname,
                                      Int_t npoints,
                                      Double_t cx, Double_t cy, Double_t a1, Double_t a2, Double_t theta = 0,
                                      const char *HistoName = nullptr);

      TGo4ShapedCond *MakeCircleCond(const char *fullname,
                                     Int_t npoints, Double_t cx, Double_t cy, Double_t r,
                                     const char *HistoName = nullptr);

      TGo4ShapedCond *MakeBoxCond(const char *fullname, Double_t cx, Double_t cy, Double_t a1, Double_t a2, Double_t theta,
                                  const char *HistoName = nullptr);

     TGo4ShapedCond *MakeFreeShapeCond(const char *fullname,
                                     Int_t npoints,
                                     Double_t (*points) [2],
                                     const char *HistoName = nullptr);

      TGo4ListCond *MakeListCond(const char *fullname, const Int_t num, const Int_t * values,  const char *HistoName = nullptr);

      TGo4ListCond *MakeListCond(const char *fullname, const Int_t start, const Int_t stop, const Int_t step = 1,  const char *HistoName = nullptr);

      TGo4ListCond *MakeListCond(const char *fullname, const char *title, const char *HistoName = nullptr);

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

      Long64_t ExecuteScript(const char *script_name);

      Long64_t ExecutePython(const char *macro_name, Int_t *errcode = nullptr);

      Long64_t ExecuteLine(const char *command, Int_t *errcode = nullptr);

      /* 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() const { 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() const { 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() {}

   private:

      TGo4EventElement *fxInputEvent{nullptr}; 

      TGo4EventCalibration *fxCalibration{nullptr};

      Bool_t fbKeepInputEvent{kFALSE}; 

      Bool_t fbKeepOutputEvent{kFALSE}; 

      ClassDefOverride(TGo4EventProcessor,3)
};

#endif //TGO4EVENTPROCESSOR_H