OpalData.cpp

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/>.
//
#include "AbstractObjects/OpalData.h"

#include "AbstractObjects/Attribute.h"
#include "AbstractObjects/Directory.h"
#include "AbstractObjects/Expressions.h"
#include "AbstractObjects/Object.h"
#include "AbstractObjects/ObjectFunction.h"
#include "AbstractObjects/Table.h"
#include "AbstractObjects/ValueDefinition.h"
#include "Algorithms/PartBunchBase.h"
#include "Attributes/Attributes.h"
#include "OpalParser/OpalParser.h"
#include "Parser/FileStream.h"
#include "Parser/StringStream.h"
#include "Physics/Units.h"
#include "Structure/BoundaryGeometry.h"
#include "Structure/DataSink.h"
#include "Utilities/OpalException.h"
#include "Utilities/Options.h"
#include "Utilities/RegularExpression.h"
#include "ValueDefinitions/RealVariable.h"
#include "ValueDefinitions/StringConstant.h"

#include <iostream>
#include <list>
#include <set>
#include <algorithm>


#define MAX_NUM_INSTANCES 10


void OpalData::ClearReference::operator()(Object *object) const {
    object->clear();
}


// Struct OpalDataImpl.
// ------------------------------------------------------------------------
struct OpalDataImpl {
    OpalDataImpl();
    ~OpalDataImpl();

    // The main object directory.
    Directory mainDirectory;

    // The value of the global momentum.
    ValueDefinition *referenceMomentum;

    // The flag telling that something has changed.
    bool modified;

    // Directory of tables, for recalculation when something changes.
    std::list<Table *> tableDirectory;
    typedef std::list<Table *>::iterator tableIterator;

    // The set of expressions to be invalidated when something changes.
    std::set <AttributeBase *> exprDirectory;
    typedef std::set<AttributeBase *>::iterator exprIterator;

    // The page title from the latest TITLE command.
    std::string itsTitle_m;

    bool hasPriorRun_m;

    // true if we restart a simulation
    bool isRestart_m;

    // Where to resume in a restart run
    int restartStep_m;

    // Where to resume in a restart run
    std::string restartFn_m;

    // true if the name of a restartFile is specified
    bool hasRestartFile_m;

    // dump frequency as found in restart file
    int restart_dump_freq_m;

    // Input file name
    std::string inputFn_m;

    std::set<std::string> outFiles_m;

    OpalData::OpenMode openMode_m = OpalData::OpenMode::WRITE;

    // last step of a run
    int last_step_m;

    bool hasBunchAllocated_m;
    // The particle bunch to be tracked.
    PartBunchBase<double, 3> *bunch_m;

    bool hasDataSinkAllocated_m;

    DataSink *dataSink_m;

    // In units of seconds. This is half of tEmission
    double gPhaseShift_m;

    BoundaryGeometry *bg_m;

    std::vector<MaxPhasesT> maxPhases_m;
    energyEvolution_t energyEvolution_m;

    // The cartesian mesh
    Mesh_t *mesh_m;

    // The field layout f
    FieldLayout_t *FL_m;

    // The particle layout
    Layout_t *PL_m;

    // the accumulated (over all TRACKs) number of steps
    unsigned long long maxTrackSteps_m;

    bool isInOPALCyclMode_m;
    bool isInOPALTMode_m;
    bool isOptimizerFlag_m;
    bool isInPrepState_m;

    std::map<std::string, unsigned int> problemSize_m;

    std::vector<std::string> arguments_m;
};


OpalDataImpl::OpalDataImpl():
    mainDirectory(), referenceMomentum(0), modified(false), itsTitle_m(),
    hasPriorRun_m(false),
    isRestart_m(false),
    restartStep_m(0),
    hasRestartFile_m(false),
    restart_dump_freq_m(1), last_step_m(0),
    hasBunchAllocated_m(false),
    hasDataSinkAllocated_m(false),
    gPhaseShift_m(0.0),
    maxTrackSteps_m(0),
    isInOPALCyclMode_m(false),
    isInOPALTMode_m(false),
    isOptimizerFlag_m(false),
    isInPrepState_m(false)
{
    bunch_m    = nullptr;
    dataSink_m = nullptr;
    bg_m       = nullptr;
    mesh_m     = nullptr;
    FL_m       = nullptr;
    PL_m       = nullptr;
}

OpalDataImpl::~OpalDataImpl() {
    // Make sure the main directory is cleared before the directories
    // for tables and expressions are deleted.
    delete mesh_m;// somehow this needs to be deleted first
    delete FL_m;
    //delete PL_m; //this gets deleted by FL_m

    delete bunch_m;
    delete bg_m;
    delete dataSink_m;

    mainDirectory.erase();
    tableDirectory.clear();
    exprDirectory.clear();
}

bool OpalData::isInstantiated = false;
OpalData *OpalData::instance = nullptr;
std::stack<OpalData*> OpalData::stashedInstances;

OpalData *OpalData::getInstance() {
    if (!isInstantiated) {
        instance = new OpalData();
        isInstantiated = true;
        return instance;
    } else {
        return instance;
    }
}

void OpalData::deleteInstance() {
    delete instance;
    instance = nullptr;
    isInstantiated = false;
}

void OpalData::stashInstance() {
    if (!isInstantiated) return;
    if (stashedInstances.size() + 1 > MAX_NUM_INSTANCES) {
        throw OpalException("OpalData::stashInstance()",
                            "too many OpalData instances stashed");
    }
    stashedInstances.push(instance);
    instance = nullptr;
    isInstantiated = false;
}

OpalData *OpalData::popInstance() {
    if (stashedInstances.size() == 0) {
        throw OpalException("OpalData::popInstance()",
                            "no OpalData instances stashed");
    }
    if (isInstantiated) deleteInstance();
    instance = stashedInstances.top();
    isInstantiated = true;
    stashedInstances.pop();

    return instance;
}

unsigned long long OpalData::getMaxTrackSteps() {
    return p->maxTrackSteps_m;
}

void OpalData::setMaxTrackSteps(unsigned long long s) {
    p->maxTrackSteps_m = s;
}

void OpalData::incMaxTrackSteps(unsigned long long s) {
    p->maxTrackSteps_m += s;
}

OpalData::OpalData() {
    p = new OpalDataImpl();
}

OpalData::~OpalData() {
    delete p;
}

void OpalData::reset() {
    delete p;
    p = new OpalDataImpl();
    p->hasPriorRun_m = false;
    p->isRestart_m = false;
    p->hasRestartFile_m = false;
    p->hasBunchAllocated_m = false;
    p->hasDataSinkAllocated_m = false;
    p->gPhaseShift_m = 0.0;
    p->maxPhases_m.clear();
    p->isInOPALCyclMode_m = false;
    p->isInOPALTMode_m = false;
    p->isInPrepState_m = false;
    p->isOptimizerFlag_m = false;
}

bool OpalData::isInOPALCyclMode() {
    return p->isInOPALCyclMode_m;
}

bool OpalData::isInOPALTMode() {
    return  p->isInOPALTMode_m;
}

bool OpalData::isOptimizerRun() {
    return p->isOptimizerFlag_m;
}

void OpalData::setInOPALCyclMode() {
    p->isInOPALCyclMode_m = true;
}

void OpalData::setInOPALTMode() {
    p->isInOPALTMode_m = true;
}

void OpalData::setOptimizerFlag() {
    p->isOptimizerFlag_m = true;
}

bool OpalData::isInPrepState() {
    return p->isInPrepState_m;
}

void OpalData::setInPrepState(bool state) {
    p->isInPrepState_m = state;
}

bool OpalData::hasPriorTrack() {
    return p->hasPriorRun_m;
}

void OpalData::setPriorTrack(const bool &value) {
    p->hasPriorRun_m = value;
}

bool OpalData::inRestartRun() {
    return p->isRestart_m;
}

void OpalData::setRestartRun(const bool &value) {
    p->isRestart_m = value;
}

void OpalData::setRestartStep(int s) {
    p->restartStep_m = s;
}

int OpalData::getRestartStep() {
    return p->restartStep_m;
}

std::string OpalData::getRestartFileName() {
    return p->restartFn_m;
}

void OpalData::setRestartFileName(std::string s) {
    p->restartFn_m = s;
    p->hasRestartFile_m = true;
}

bool OpalData::hasRestartFile() {
    return p->hasRestartFile_m;
}

void OpalData::setRestartDumpFreq(const int &N) {
    p->restart_dump_freq_m = N;
}

int OpalData::getRestartDumpFreq() const {
    return p->restart_dump_freq_m;
}

void OpalData::setOpenMode(OpenMode openMode) {
    p->openMode_m = openMode;
}

OpalData::OpenMode OpalData::getOpenMode() const {
    return p->openMode_m;
}

void OpalData::setLastStep(const int &step) {
    p->last_step_m = step;
}

int OpalData::getLastStep() const {
    return p->last_step_m;
}

bool OpalData::hasBunchAllocated() {
    return p->hasBunchAllocated_m;
}

void OpalData::bunchIsAllocated() {
    p->hasBunchAllocated_m = true;
}

void OpalData::setPartBunch(PartBunchBase<double, 3> *b) {
    p->bunch_m = b;
}

PartBunchBase<double, 3> *OpalData::getPartBunch() {
    return p->bunch_m;
}

bool OpalData::hasDataSinkAllocated() {
    return p->hasDataSinkAllocated_m;
}

void OpalData::setDataSink(DataSink *s) {
    p->dataSink_m = s;
    p->hasDataSinkAllocated_m = true;
}

DataSink *OpalData::getDataSink() {
    return p->dataSink_m;
}

void OpalData::setMaxPhase(std::string elName, double phi) {
    p->maxPhases_m.push_back(MaxPhasesT(elName, phi));
}

std::vector<MaxPhasesT>::iterator OpalData::getFirstMaxPhases() {
    return p->maxPhases_m.begin();
}

std::vector<MaxPhasesT>::iterator OpalData::getLastMaxPhases() {
    return p->maxPhases_m.end();
}

int OpalData::getNumberOfMaxPhases() {
    return p->maxPhases_m.size();
}

void OpalData::addEnergyData(double spos, double ekin) {
    p->energyEvolution_m.insert(std::make_pair(spos, ekin));
}

energyEvolution_t::iterator OpalData::getFirstEnergyData() {
    return p->energyEvolution_m.begin();
}

energyEvolution_t::iterator OpalData::getLastEnergyData() {
    return p->energyEvolution_m.end();
}


// Mesh_t* OpalData::getMesh() {
//  return p->mesh_m;
// }

// FieldLayout_t* OpalData::getFieldLayout() {
//  return p->FL_m;
// }

// Layout_t* OpalData::getLayout() {
//  return p->PL_m;
// }

// void OpalData::setMesh(Mesh_t *mesh) {
//  p->mesh_m = mesh;
// }

// void OpalData::setFieldLayout(FieldLayout_t *fieldlayout) {
//  p->FL_m = fieldlayout;
// }

// void OpalData::setLayout(Layout_t *layout) {
//  p->PL_m = layout;
// }

void OpalData::setGlobalPhaseShift(double shift) {
    p->gPhaseShift_m = shift;
}

double OpalData::getGlobalPhaseShift() {
    return p->gPhaseShift_m;
}

void OpalData::setGlobalGeometry(BoundaryGeometry *bg) {
    p->bg_m = bg;
}

BoundaryGeometry *OpalData::getGlobalGeometry() {
    return p->bg_m;
}

bool OpalData::hasGlobalGeometry() {
    return p->bg_m != nullptr;
}

void OpalData::apply(const ObjectFunction &fun) {
    for (ObjectDir::iterator i = p->mainDirectory.begin();
        i != p->mainDirectory.end(); ++i) {
        fun(&*i->second);
    }
}

void OpalData::create(Object *newObject) {
    // Test for existing node with same name.
    const std::string name = newObject->getOpalName();
    Object *oldObject = p->mainDirectory.find(name);

    if (oldObject != nullptr) {
        throw OpalException("OpalData::create()",
                            "You cannot replace the object \"" + name + "\".");
    } else {
        p->mainDirectory.insert(name, newObject);
    }
}

void OpalData::define(Object *newObject) {
    // Test for existing node with same name.
    const std::string name = newObject->getOpalName();
    Object *oldObject = p->mainDirectory.find(name);

    if (oldObject != nullptr  &&  oldObject != newObject) {
        if (oldObject->isBuiltin()) {
            throw OpalException("OpalData::define()",
                                "The keyword \""
                                + name +
                                "\" is protected and can't be used to name an object.");
        } else if (! oldObject->canReplaceBy(newObject)) {
            throw OpalException("OpalData::define()",
                                "You cannot replace the already defined object \""
                                + name +
                                "\".");
        }
        if (Options::info) {
            INFOMSG("Replacing the object \"" << name << "\"." << endl);
        }

        // Erase all tables which depend on the new object.
        OpalDataImpl::tableIterator i = p->tableDirectory.begin();
        while(i != p->tableDirectory.end()) {
            // We must increment i before calling erase(name),
            // since erase(name) removes "this" from "tables".
            Table *table = *i++;
            const std::string &tableName = table->getOpalName();
        
            if (table->isDependent(name)) {
                if (Options::info) {
                    std::cerr << std::endl << "Erasing dependent table \""
                              << tableName << "\"." << std::endl;
                }

                // Remove table from directory.
                // This erases the table from the main directory,
                // and its destructor unregisters it from the table directory.
                erase(tableName);
            }
        }

        // Replace all references to this object.
        for (ObjectDir::iterator i = p->mainDirectory.begin();
             i != p->mainDirectory.end(); ++i) {
            (*i).second->replace(oldObject, newObject);
        }

        // Remove old object.
        erase(name);
    }

    // Force re-evaluation of expressions.
    p->modified = true;
    newObject->setDirty(true);
    p->mainDirectory.insert(name, newObject);

    // If this is a new definition of "P0", insert its definition.
    if (name == "P0") {
        if (ValueDefinition *p0 = dynamic_cast<ValueDefinition *>(newObject)) {
            setP0(p0);
        }
    }
}

void OpalData::erase(const std::string &name) {
    Object *oldObject = p->mainDirectory.find(name);

    if (oldObject != nullptr) {
        // Relink all children of "this" to "this->getParent()".
        for (ObjectDir::iterator i = p->mainDirectory.begin();
            i != p->mainDirectory.end(); ++i) {
            Object *child = &*i->second;
            if (child->getParent() == oldObject) {
                child->setParent(oldObject->getParent());
            }
        }
        // Remove the object.
        p->mainDirectory.erase(name);
    }
}

Object *OpalData::find(const std::string &name) {
    return p->mainDirectory.find(name);
}

double OpalData::getP0() const {
    return p->referenceMomentum->getReal() * Units::GeV2eV;
}

void OpalData::makeDirty(Object *obj) {
    p->modified = true;
    if (obj) obj->setDirty(true);
}

void OpalData::printNames(std::ostream &os, const std::string &pattern) {
    int column = 0;
    RegularExpression regex(pattern);
    os << std::endl << "Object names matching the pattern \""
       << pattern << "\":" << std::endl;

    for (ObjectDir::const_iterator index = p->mainDirectory.begin();
        index != p->mainDirectory.end(); ++index) {
        const std::string name = (*index).first;

        if (! name.empty()  &&  regex.match(name)) {
            os << name;

            if (column < 80) {
                column += name.length();

                do {
                    os << ' ';
                    column++;
                } while((column % 20) != 0);
            } else {
                os << std::endl;
                column = 0;
            }
        }
    }

    if (column) os << std::endl;
    os << std::endl;
}

std::vector<std::string> OpalData::getAllNames() const {
    std::vector<std::string> name_list;
    for (ObjectDir::const_iterator index = p->mainDirectory.begin();
        index != p->mainDirectory.end(); ++index) {
        const std::string name = (*index).first;
        name_list.push_back(name);
    }
    return name_list;
}


void OpalData::registerTable(Table *table) {
    p->tableDirectory.push_back(table);
}

void OpalData::unregisterTable(Table *table) {
    for (OpalDataImpl::tableIterator i = p->tableDirectory.begin();
        i != p->tableDirectory.end();) {
        OpalDataImpl::tableIterator j = i++;
        if (*j == table) p->tableDirectory.erase(j);
    }
}

void OpalData::registerExpression(AttributeBase *expr) {
    p->exprDirectory.insert(expr);
}

void OpalData::unregisterExpression(AttributeBase *expr) {
    p->exprDirectory.erase(expr);
}

void OpalData::setP0(ValueDefinition *p0) {
    p->referenceMomentum = p0;
}

void OpalData::storeTitle(const std::string &title) {
    p->itsTitle_m = title;
}

void OpalData::storeInputFn(const std::string &fn) {
    p->inputFn_m = fn;
}

void OpalData::printTitle(std::ostream &os) {
    os << p->itsTitle_m;
}

std::string OpalData::getTitle() {
    return p->itsTitle_m;
}

std::string OpalData::getAuxiliaryOutputDirectory() const {
    return "data";
}

std::string OpalData::getInputFn() {
    return p->inputFn_m;
}

std::string OpalData::getInputBasename() {
    std::string & fn = p->inputFn_m;
    int const pdot = fn.rfind(".");
    return fn.substr(0, pdot);
}

void OpalData::checkAndAddOutputFileName(const std::string &outfn) {
    if (p->outFiles_m.count(outfn) == 0) {
        p->outFiles_m.insert(outfn);
    } else if (!hasBunchAllocated()) {
        throw OpalException(
                "OpalData::checkAndAddOutputFileName",
                "Duplicate file name for output, '" + outfn + "', detected");
    }
}

void OpalData::update() {
    Inform msg("OpalData ");
    if (p->modified) {
        // Force re-evaluation of expressions.
        for (OpalDataImpl::exprIterator i = p->exprDirectory.begin();
            i != p->exprDirectory.end(); ++i) {
            (*i)->invalidate();
        }

        // Force refilling of dynamic tables.
        for (OpalDataImpl::tableIterator i = p->tableDirectory.begin();
            i != p->tableDirectory.end(); ++i) {
            (*i)->invalidate();
        }

        // Update all definitions.
        for (ObjectDir::iterator i = p->mainDirectory.begin();
            i != p->mainDirectory.end(); ++i) {
            (*i).second->update();
        }

        // Definitions are up-to-date.
        p->modified = false;
    }
}

std::map<std::string, std::string> OpalData::getVariableData() {
    std::map<std::string, std::string> udata;
    std::vector<std::string> uvars = this->getVariableNames();
    for (auto& uvar : uvars) {
        Object *tmpObject = OpalData::getInstance()->find(uvar);
        if (dynamic_cast<RealVariable*>(tmpObject)) {
            RealVariable* variable = dynamic_cast<RealVariable*>(OpalData::getInstance()->find(uvar));
            udata[uvar] = std::to_string(variable->getReal());
        } else if (dynamic_cast<StringConstant*>(tmpObject)) {
            StringConstant* variable = dynamic_cast<StringConstant*>(OpalData::getInstance()->find(uvar));
            udata[uvar] = variable->getString();
        } else {
            throw OpalException("OpalData::getVariableData()",
                                "Type of '" + uvar + "' not supported. "
                                "Only support for REAL and STRING.");
        }
    }
    return udata;
}

std::vector<std::string> OpalData::getVariableNames() {
    std::vector<std::string> result;

    for (ObjectDir::const_iterator index = p->mainDirectory.begin();
        index != p->mainDirectory.end(); ++index) {
        std::string tmpName = (*index).first;
        if (!tmpName.empty()) {
            Object *tmpObject = OpalData::getInstance()->find(tmpName);
            if (tmpObject) {
                if (!tmpObject || tmpObject->isBuiltin())
                    continue;
                if (tmpObject->getCategory() == "VARIABLE") {
                    result.push_back(tmpName);
                }
            }
        }
    }
    return result;
}

void OpalData::addProblemCharacteristicValue(const std::string &name, unsigned int value) {
    if (p->problemSize_m.find(name) != p->problemSize_m.end()) {
        p->problemSize_m.insert(std::make_pair(name, value));
    } else {
        p->problemSize_m[name] = value;
    }
}

const std::map<std::string, unsigned int> &OpalData::getProblemCharacteristicValues() const {
    return p->problemSize_m;
}

void OpalData::storeArguments(int argc, char *argv[]) {
    p->arguments_m.clear();
    for (int i = 0; i < argc; ++ i) {
        p->arguments_m.push_back(argv[i]);
    }
}

std::vector<std::string> OpalData::getArguments() {
    return p->arguments_m;
}