b2model_database.H

//------------------------------------------------------------------------
// b2model_database.H --
//
//
// written by Mathias Doreille, SMR SA
//            Silvio Merazzi, SMR SA <merazzi@smr.ch>
//            Thomas Blome <thomas.blome@dlr.de>
//
// Copyright (c) 2004-2024
//               SMR Engineering & Development SA
//               2502 Bienne, Switzerland
//
// Copyright (c) 2023 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
//                    Linder Höhe, 51147 Köln
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef __B2MODEL_DATABASE_H__
#define __B2MODEL_DATABASE_H__
 
#include <memory>
 
#include "b2ppconfig.h"
#include "model/b2initial_condition.H"
#include "model/b2model.H"
#include "model/b2solver.H"
#include "utils/b2allocator.H"
#include "utils/b2database.H"
#include "utils/b2dictionary.H"
#include "utils/b2object.H"
#include "utils/b2util.H"
 
namespace b2000::b2dbv3 {
 
extern Module module;
 
class Model : public b2000::Model, public DataBaseFieldSet {
public:
    Model() = default;
 
    ~Model() override;
 
    void set_parameters(const std::string& dbname, Dictionary* cmdline_set_ = nullptr) override;
 
    std::string get_logging_directory() override {
        return DataBaseFieldSet::get_logging_directory();
    }
 
    void init(const std::string& dbname = "", Dictionary* cmdline_set_ = nullptr) override;
 
    CaseList& get_case_list() override;
  
    const int get_handle() override;
 
    Domain& get_domain() override;
 
    NaturalBoundaryCondition& get_natural_boundary_condition(
          ObjectTypeIncomplete<NaturalBoundaryCondition>* bc_type) override;
 
    EssentialBoundaryCondition& get_essential_boundary_condition(
          ObjectTypeIncomplete<EssentialBoundaryCondition>* bc_type) override;
 
    ModelReductionBoundaryCondition& get_model_reduction_boundary_condition(
          ObjectTypeIncomplete<ModelReductionBoundaryCondition>* bc_type) override;
 
    InitialCondition& get_initial_condition() override;
 
    Solution& get_solution() override;
 
    Solver& get_solver() override;
 
    void set_case(b2000::Case& case_) override;
 
    Case* get_case() override { return current_case; }
 
    int get_subcase_id() const override { return current_subcase_id; }
 
    void set_subcase_id(const int subcase_id_) override;
 
    void get_subcase_ids(std::set<int>& subcase_ids_) const override;
 
    int b2ip_version_comp(int a1, int a2, int a3) {
        std::vector<mcInt32> b2ip_version(3);
        adir.get("VERSION", b2ip_version);
        if (a1 < b2ip_version[0]) {
            return 1;
        } else if (a1 > b2ip_version[0]) {
            return -1;
        }
        if (a2 < b2ip_version[1]) {
            return 1;
        } else if (a2 > b2ip_version[1]) {
            return -1;
        }
        if (a3 < b2ip_version[2]) {
            return 1;
        } else if (a3 > b2ip_version[2]) {
            return -1;
        }
        return 0;
    }
 
    using type_t = ObjectTypeComplete<Model, b2000::Model::type_t>;
    static type_t type;
 
protected:
    Case* current_case{};
    std::unique_ptr<Solver> solver{};
    Allocator allocator;
 
private:
    Dictionary* cmdline_set{};
    RTable adir;
    RTable strat;
    CaseList* case_list{};
    int current_subcase_id{};
    Domain* domain{};
    NaturalBoundaryCondition* natural_boundary_condition{};
    EssentialBoundaryCondition* essential_boundary_condition{};
    ModelReductionBoundaryCondition* model_reduction_boundary_condition{};
    std::unique_ptr<InitialCondition> initial_condition{};
    Solution* solution{};
    void set_domain();
};
 
}  // namespace b2000::b2dbv3
 
#endif