TGo4AnalysisStep.h

Go to the documentation of this file.

// $Id: TGo4AnalysisStep.h 832 2012-01-12 16:05:43Z 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 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 = 0,
                     TGo4EventStoreParameter* storetype = 0,
                     TGo4EventProcessorParameter* processortype = 0);

    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() { return fxEventProcessor ? fxEventProcessor->IsKeepInputEvent() : kFALSE; }

    Bool_t IsKeepOutputEvent() { 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 char* GetEventStoreName();

    const char* GetEventSourceName();

    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;                       

    TGo4AnalysisStep * fxPrevious;               

    TGo4EventFactory * fxEventFactory;

     TGo4EventStore * fxEventStore;

    TGo4EventSource * fxEventSource;

    TGo4EventProcessor * fxEventProcessor;

    TGo4EventElement * fxInputEvent;

    TGo4EventElement * fxOutputEvent;

    TGo4EventSourceParameter* fxSourceType;

    TGo4EventStoreParameter* fxStoreType;

    TGo4EventProcessorParameter* fxProcessorType;

    Bool_t fbSourceEnabled;

    Bool_t fbSourceImplemented;

    Bool_t fbStoreEnabled;

    Bool_t fbStoreImplemented;

    Bool_t fbProcessEnabled;

    Bool_t fbErrorStopEnabled;

    Bool_t fbErrorStopped;

    Int_t fiProcessStatus;

    TString fcStatusMessage;   

  ClassDef(TGo4AnalysisStep,1)
};

#endif //TGO4ANALYSISSTEP_H