b2initial_condition_database.H

//------------------------------------------------------------------------
// b2initial_condition_database.H --
//
//
// written by Mathias Doreille
//            Neda Ebrahimi Pour <neda.ebrahimipour@dlr.de>
//            Thomas Blome <thomas.blome@dlr.de>
//
// (c) 2004-2012 SMR Engineering & Development SA
//               2502 Bienne, Switzerland
//
// (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 __B2INITIAL_CONDITION_DATABASE_H__
#define __B2INITIAL_CONDITION_DATABASE_H__
 
#include <complex>
 
#include "b2domain_database.H"
#include "b2ppconfig.h"
#include "model/b2initial_condition.H"
#include "utils/b2database.H"
#include "utils/b2linear_algebra.H"
#include "utils/b2object.H"
 
namespace b2000::b2dbv3 {
 
template <typename T>
class TypedInitialCondition : public b2000::TypedInitialCondition<T> {
public:
    void set_model(b2000::Model& model) override {
        database = &dynamic_cast<DataBase&>(model);
        domain = &dynamic_cast<Domain&>(model.get_domain());
    }
 
    void set_case(b2000::Case& case__) override { case_ = &case__; }
 
    bool is_zero() override { return !case_->has_key("DOF_INIT"); }
 
    bool get_static_initial_condition_value(
          b2linalg::Vector<double, b2linalg::Vdense_ref> dof, double& time, int& stage,
          std::string& domain_state_id) override {
        bool zero = true;
        SetName dof_init = case_->get_string("DOF_INIT", "");
        if (dof_init.empty()) {
            dof.set_zero();
        } else {
            domain->load_global_dof(dof_init, dof);
            zero = false;
        }
        time = case_->get_double("TIME_INIT", 0);
        if (time != 0) { zero = false; }
        stage = case_->get_int("STAGE", 0);
        domain_state_id = case_->get_string("STATE_INIT", "");
        if (domain_state_id != "") { zero = false; }
        return !zero;
    }
 
    bool get_dynamic_initial_condition_value(
          b2linalg::Matrix<double, b2linalg::Mrectangle>& dof, double& time, int& stage,
          std::string& domain_state_id) override {
        SetName dof_init_id = case_->get_string("DOF_INIT", "");
        SetName dofdot_init_id = case_->get_string("DOFD_INIT", "");
        if (dofdot_init_id.empty()) {
            dof.resize(domain->get_number_of_dof(), 1);
        } else {
            dof.resize(domain->get_number_of_dof(), 2);
        }
        dof.set_zero();
        if (!dof_init_id.empty()) {
            SetName dof_init;
            if (std::isdigit(dof_init_id[0])) {
                dof_init = SetName("DOF_INIT", "*", 0, 0, dof_init_id);
            } else {
                dof_init = dof_init_id;
            }
            domain->load_global_dof(dof_init, dof[0]);
        }
        if (!dofdot_init_id.empty()) {
            SetName dofdot_init;
            if (std::isdigit(dofdot_init_id[0])) {
                dofdot_init = SetName("DOFD_INIT", "*", 0, 0, dofdot_init_id);
            } else {
                dofdot_init = dofdot_init_id;
            }
            domain->load_global_dof(dofdot_init, dof[1]);
        }
        time = case_->get_double("TIME", 0);
        stage = case_->get_int("STAGE", 0);
        domain_state_id = case_->get_string("STATE_INIT", "");
        return true;
    }
 
    using type_t = ObjectTypeComplete<TypedInitialCondition>;
    static type_t type;
 
private:
    DataBase* database{};
    Domain* domain{};
    b2000::Case* case_{};
};
 
template <typename T>
typename TypedInitialCondition<T>::type_t TypedInitialCondition<T>::type(
      "TypedInitialCondition", type_name<T>(), StringList(), b2000_module,
      &b2000::TypedInitialCondition<T>::type);
 
}  // Namespace b2000::b2dbv3
 
#endif