TGo4AnalysisStep.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 TGO4ANALYSISSTEP_H
#define TGO4ANALYSISSTEP_H

#include "TNamed.h"
#include "TString.h"

class TFolder;

class TGo4Parameter;
class TGo4Condition;
class TGo4Fitter;

class TGo4Analysis;
class TGo4AnalysisStepStatus;
class TGo4AnalysisStatus;
class TGo4Condition;
class TGo4Fitter;
class TGo4EventProcessorParameter;
class TGo4EventStoreParameter;
class TGo4EventSourceParameter;

class TGo4EventElement;
class TGo4EventFactory;
class TGo4EventSource;
class TGo4EventStore;
//class TGo4EventProcessor;
#include "TGo4EventProcessor.h"

class TGo4AnalysisStep : public TNamed {
  public:

    TGo4AnalysisStep();
    TGo4AnalysisStep(const char *name,
                     TGo4EventFactory *eventfactory,
                     TGo4EventSourceParameter *sourcetype = nullptr,
                     TGo4EventStoreParameter *storetype = nullptr,
                     TGo4EventProcessorParameter *processortype = nullptr);

    virtual ~TGo4AnalysisStep();

    void SetEventSource(TGo4EventSourceParameter *kind);

    Bool_t IsEventSourceParam() const;

    void NewEventSource(TGo4EventSourceParameter *kind);

    TGo4EventSourceParameter *GetEventSource() const { return fxSourceType; }

    void CloseEventSource();

    void SetEventStore(TGo4EventStoreParameter *kind);

    TGo4EventStoreParameter *GetEventStore() const { return fxStoreType; }

    Bool_t IsEventStoreParam() const;

    void NewEventStore(TGo4EventStoreParameter *kind);

    void CloseEventStore();

    void SetEventProcessor(TGo4EventProcessorParameter *kind);

    void NewEventProcessor(TGo4EventProcessorParameter *kind);

    void CloseEventProcessor();

    void NewInputEvent();

    void DeleteInputEvent();

    void NewOutputEvent();

    void DeleteOutputEvent();

    virtual void InitEventClasses();

    void SetSourceEnabled(Bool_t on = kTRUE) { fbSourceEnabled = on; }

    void SetStoreEnabled(Bool_t on = kTRUE) { fbStoreEnabled = on; }

    void SetProcessEnabled(Bool_t on = kTRUE) { fbProcessEnabled = on; }

    void SetErrorStopEnabled(Bool_t on) { fbErrorStopEnabled = on; }

    void ResetErrorStop() { fbErrorStopped = 0; }

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

    void SetPreviousStep(TGo4AnalysisStep *pre) { fxPrevious = pre; }

    TGo4AnalysisStep *GetPreviousStep() const { return fxPrevious; }

    TGo4EventElement *GetOutputEvent() const { return fxOutputEvent; }

    TGo4EventElement *GetInputEvent() const { return fxInputEvent; }

    TGo4EventProcessor *GetEventProcessor() const { return fxEventProcessor; }

    TGo4EventFactory *GetStepFactory() const { return fxEventFactory; }

    Bool_t IsStoreEnabled() const { return fbStoreEnabled; }

    Bool_t IsStoreImplemented() const { return fbStoreImplemented; }

    Bool_t IsSourceImplemented() const { return fbSourceImplemented; }

    Bool_t IsSourceEnabled() const { return fbSourceEnabled; }

    Bool_t IsProcessEnabled() const { return fbProcessEnabled; }

    Bool_t IsKeepInputEvent() const { return fxEventProcessor ? fxEventProcessor->IsKeepInputEvent() : kFALSE; }

    Bool_t IsKeepOutputEvent() const { return fxEventProcessor ? fxEventProcessor->IsKeepOutputEvent() : kFALSE; }

    Bool_t IsErrorStopped() const { return fbErrorStopped; }

    Bool_t IsErrorStopEnabled() const { return fbErrorStopEnabled; }

    Int_t GetProcessStatus() const { return fiProcessStatus; }

    const char *GetStatusMessage() const { return fcStatusMessage.Data(); }

    void SetStatusMessage(const char *txt) { fcStatusMessage = txt; }

    Bool_t IsMatchingPrevious() const;

    const char *GetEventStoreName() const;

    const char *GetEventSourceName() const;

    void StoreCalibration();

    Int_t Store(TGo4Parameter *cali);

    Int_t Store(TGo4Condition *conny);

    Int_t Store(TGo4Fitter *fitter);

    Int_t Store(TFolder *fold);

    void Process();

    void Close();

    void SetStatus(TGo4AnalysisStepStatus *state);

    TGo4AnalysisStepStatus *CreateStatus();

  private:

    TGo4Analysis *fxOwner{nullptr};                       

    TGo4AnalysisStep *fxPrevious{nullptr};               

    TGo4EventFactory *fxEventFactory{nullptr};

     TGo4EventStore *fxEventStore{nullptr};

    TGo4EventSource *fxEventSource{nullptr};

    TGo4EventProcessor *fxEventProcessor{nullptr};

    TGo4EventElement *fxInputEvent{nullptr};

    TGo4EventElement *fxOutputEvent{nullptr};

    TGo4EventSourceParameter *fxSourceType{nullptr};

    TGo4EventStoreParameter *fxStoreType{nullptr};

    TGo4EventProcessorParameter *fxProcessorType{nullptr};

    Bool_t fbSourceEnabled{kFALSE};

    Bool_t fbSourceImplemented{kFALSE};

    Bool_t fbStoreEnabled{kFALSE};

    Bool_t fbStoreImplemented{kFALSE};

    Bool_t fbProcessEnabled{kFALSE};

    Bool_t fbErrorStopEnabled{kFALSE};

    Bool_t fbErrorStopped{kFALSE};

    Int_t fiProcessStatus{0};

    TString fcStatusMessage;   

  ClassDefOverride(TGo4AnalysisStep,1)
};

#endif