---

/Go4Analysis/TGo4AnalysisStep.h

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE 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"

#include "Go4Log/TGo4Log.h"

#include "Go4Event/TGo4EventElement.h"
#include "Go4Event/TGo4EventProcessor.h"
#include "Go4Event/TGo4EventStore.h"
#include "Go4Event/TGo4EventSource.h"
#include "Go4Event/TGo4EventFactory.h"

#include "Go4Event/TGo4EventProcessorParameter.h"
#include "Go4Event/TGo4EventStoreParameter.h"
#include "Go4Event/TGo4EventSourceParameter.h"

class TGo4Analysis;
class TGo4AnalysisStepStatus;
class TGo4AnalysisStatus;
class TGo4Condition;
class TGo4Fitter;

class TGo4AnalysisStep : public TNamed {
  public:

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

    TGo4AnalysisStep();

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

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

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

---