OpalData.h

Go to the documentation of this file.

#ifndef OPAL_OpalData_HH
#define OPAL_OpalData_HH

// ------------------------------------------------------------------------
// $RCSfile: OpalData.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.4.2 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: OpalData
//
// ------------------------------------------------------------------------
//
// $Date: 2004/11/12 20:10:11 $
// $Author: adelmann $
//
// ------------------------------------------------------------------------
#include "AbstractObjects/ObjectFunction.h"

#include <iosfwd>
#include <string>
#include <vector>
#include <map>
#include <stack>

template <class T = double, unsigned Dim = 3>
class PartBunchBase;

class EnvelopeBunch;
class AttributeBase;
class Object;
class Table;
class ValueDefinition;
class DataSink;
class BoundaryGeometry;

// store element name, max phase
typedef std::pair<std::string, double > MaxPhasesT;
typedef std::map<double, double> energyEvolution_t;
typedef energyEvolution_t::value_type energyEvData_t;



// Class OpalData
// ------------------------------------------------------------------------
//  The OPAL object holds all global data required for an OPAL execution.
//  In particular it contains the main Directory, which allows retrieval
//  of command objects by their name.  For other data refer to the
//  implementation file.

class OpalData {

public:

    static OpalData *getInstance();

    static void deleteInstance();

    static void stashInstance();

    static OpalData *popInstance();

    ~OpalData();

    enum class OPENMODE {
        WRITE,
        APPEND,
        UNDEFINED
    };

    void reset();

    //  Loop over the directory and apply the given functor object to each
    //  object in turn.
    void apply(const ObjectFunction &);

    //  No replacement is allowed; if an object with the same name exists,
    //  throw [b]OpalException[/b].
    void create(Object *newObject);

    //  Replacement is allowed; however [b]OpalException[/b] is thrown,
    //  if the replacement cannot be done.
    void define(Object *newObject);

    //  Identified by [b]name[/b].
    void erase(const std::string &name);

    //  Identified by [b]name[/b].
    Object *find(const std::string &name);

    double getP0() const;

    //  Force re-evaluation of all expressions before next command is
    //  executed.
    //  Also set the [b]modified[/b] flag in [b]object[/b], if not NULL.
    void makeDirty(Object *object);

    //  Loop over the directory and print each object whose name matches
    //  the regular expression [b]pattern[/b].
    void printNames(std::ostream &stream, const std::string &pattern);

    //  Register the table [b]t[/b].
    //  Registered tables are invalidated to be refilled when an object
    //  on which they depend is changed or replaced.
    void registerTable(Table *t);

    void unregisterTable(Table *t);

    //  Registered expressions are invalidated to be recomputed when
    //  any object in the directory is changed or replaced.
    void registerExpression(AttributeBase *);

    void unregisterExpression(AttributeBase *);

    void setP0(ValueDefinition *p0);

    void storeTitle(const std::string &);

    void printTitle(std::ostream &);

    std::string getTitle();

    //  Loop over the directory and notify all objects to update themselves.
    void update();

    //  This functor is used to clear the reference count stored in an object.
    struct ClearReference: public ObjectFunction {
        virtual void operator()(Object *) const;
    };

    std::vector<std::string> getAllNames();

    bool isInOPALCyclMode();
    bool isInOPALTMode();
    bool isInOPALEnvMode();
    bool isOptimizerRun();

    void setInOPALCyclMode();
    void setInOPALTMode();
    void setInOPALEnvMode();
    void setOptimizerFlag();

    bool isInPrepState();
    void setInPrepState(bool state);

    bool hasPriorTrack();

    void setPriorTrack(const bool &value = true);

    bool inRestartRun();

    void setRestartRun(const bool &value = true);

    void setRestartStep(int s);

    int getRestartStep();

    std::string getInputFn();

    std::string getInputBasename();

    void storeInputFn(const std::string &fn);

    std::string getRestartFileName();

    void setRestartFileName(std::string s);

    bool hasRestartFile();

    void setRestartDumpFreq(const int &N);

    int getRestartDumpFreq() const;

    void setOpenMode(OPENMODE openMode);
    OPENMODE getOpenMode() const;

    void setLastStep(const int &step);

    int getLastStep() const;

    bool hasBunchAllocated();

    void bunchIsAllocated();

    PartBunchBase<double, 3> *getPartBunch();

    void setPartBunch(PartBunchBase<double, 3> *p);

    bool hasDataSinkAllocated();

    DataSink *getDataSink();

    void setDataSink(DataSink *s);

    bool hasSLBunchAllocated();

    void slbunchIsAllocated();

    EnvelopeBunch *getSLPartBunch();

    void setSLPartBunch(EnvelopeBunch *p);

    void   setGlobalPhaseShift(double shift);
    double getGlobalPhaseShift();

    void setGlobalGeometry(BoundaryGeometry *bg);
    BoundaryGeometry *getGlobalGeometry();


    bool hasGlobalGeometry();

    void setMaxPhase(std::string elName, double phi);

    std::vector<MaxPhasesT>::iterator getFirstMaxPhases();
    std::vector<MaxPhasesT>::iterator getLastMaxPhases();
    int getNumberOfMaxPhases();

    void addEnergyData(double spos, double ekin);
    energyEvolution_t::iterator getFirstEnergyData();
    energyEvolution_t::iterator getLastEnergyData();

    unsigned long long getMaxTrackSteps();
    void setMaxTrackSteps(unsigned long long s);
    void incMaxTrackSteps(unsigned long long s);

    void addProblemCharacteristicValue(const std::string &name, unsigned int value);
    const std::map<std::string, unsigned int> &getProblemCharacteristicValues() const;

    void storeArguments(int argc, char *argv[]);
    std::vector<std::string> getArguments();

private:

    static bool isInstantiated;
    static OpalData *instance;
    static std::stack<OpalData*> stashedInstances;

    OpalData();

    // Not implemented.
    OpalData(const OpalData &);
    void operator=(const OpalData &);

    // The private implementation details.
    struct OpalDataImpl *p;
};

//extern OpalData OPAL;

#endif // OPAL_OpalData_HH