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