OpalData.h

Go to the documentation of this file.

//
// Class OpalData
//   The global OPAL structure.
//   The OPAL object holds all global data required for a 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.
//
// Copyright (c) 200x - 2021, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef OPAL_OpalData_HH
#define OPAL_OpalData_HH

#include "AbstractObjects/ObjectFunction.h"

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

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

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;


class OpalData {

public:

    static OpalData *getInstance();

    static void deleteInstance();

    static void stashInstance();

    static OpalData *popInstance();

    ~OpalData();

    enum class OpenMode: unsigned short {
        UNDEFINED,
        WRITE,
        APPEND
    };

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

    //  Loop over the directory and return a list of names of all objects
    std::vector<std::string> getAllNames() const;

    //  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::map<std::string, std::string> getVariableData();
    std::vector<std::string> getVariableNames();

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

    void setInOPALCyclMode();
    void setInOPALTMode();
    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 getAuxiliaryOutputDirectory() const;

    std::string getInputFn();

    std::string getInputBasename();

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

    void checkAndAddOutputFileName(const std::string &outfn);

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

    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