TGo4AnalysisStep.h

Go to the documentation of this file.

//-------------------------------------------------------------
//        Go4 Release Package v3.04-01 (build 30401)
//                      28-November-2008
//---------------------------------------------------------------
//   The GSI Online Offline Object Oriented (Go4) Project
//   Experiment Data Processing at EE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    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;

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


    void NewEventSource(TGo4EventSourceParameter * kind);

    void CloseEventSource();

    void SetEventStore(TGo4EventStoreParameter* kind);

    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() { return fxPrevious; }

    TGo4EventElement* GetOutputEvent() { return fxOutputEvent; }

    TGo4EventElement* GetInputEvent() { return fxInputEvent; }

    TGo4EventProcessor * GetEventProcessor() { return fxEventProcessor; }

    TGo4EventFactory * GetStepFactory() {return fxEventFactory; }

    Bool_t IsStoreEnabled() { return fbStoreEnabled; }

    Bool_t IsStoreImplemented() { return fbStoreImplemented; }

    Bool_t IsSourceImplemented() { return fbSourceImplemented; }

    Bool_t IsSourceEnabled() { return fbSourceEnabled; }

    Bool_t IsProcessEnabled() { return fbProcessEnabled; }

    Bool_t IsErrorStopped() { return fbErrorStopped; }

    Bool_t IsErrorStopEnabled() { return fbErrorStopEnabled; }

    Int_t GetProcessStatus() { return fiProcessStatus; }

    const char* GetStatusMessage() { fcBuffer = fcStatusMessage; return fcBuffer.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;   

    TString fcBuffer; 

  ClassDef(TGo4AnalysisStep,1)
};

#endif //TGO4ANALYSISSTEP_H

//----------------------------END OF GO4 SOURCE FILE ---------------------

---