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 <iosfwd>
#include <map>
#include <stack>
#include <string>
#include <vector>
#include "AbstractObjects/ObjectFunction.h"
#include "OPALTypes.h"
 
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);
    void printAllNames(std::ostream& stream);
 
    //  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();
 
    PartBunch_t* getPartBunch();
 
    void setPartBunch(PartBunch_t* 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;  // \todo should be a smart pointer and we then should get ridd of
                                // deleteInstance
    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