b2branch_property.H

//------------------------------------------------------------------------
// b2branch_property.H --
//
//
// written by Mathias Doreille
//            Neda Ebrahimi Pour <neda.ebrahimipour@dlr.de>
//            Thomas Blome <thomas.blome@dlr.de>
//
// (c) 2004-2015,2017 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 B2_BRANCH_PROPERTY_H_
#define B2_BRANCH_PROPERTY_H_
 
#include <vector>
 
#include "b2domain_property.H"
#include "b2ppconfig.h"
#include "model/b2case.H"
#include "model/b2node.H"
#include "model_imp/b2case_component.H"
#include "utils/b2linear_algebra.H"
#include "utils/b2rtable.H"
 
namespace b2000::b2dbv3 {
 
class BranchProperty {
public:
    BranchProperty(DomainProperty& parent_) : parent(parent_) {}
 
    void init(int branch_id_, size_t branch_internal_id_, size_t first_node_id_of_branch_) {
        branch_id = branch_id_;
        branch_internal_id = branch_internal_id_;
        first_node_id_of_branch = first_node_id_of_branch_;
    }
 
    void set_case(b2000::Case& case_);
 
    void set_subcase_id(const int subcase_id_) { subcase_id = subcase_id_; }
 
    int get_subcase_id() const { return subcase_id; }
 
    Domain& get_domain() { return parent.get_domain(); }
 
    DomainProperty& get_domain_property() { return parent; }
 
    size_t get_branch_internal_id() const { return branch_internal_id; }
 
    bool have_temperature() const {
        auto it = node_temp_map.find(subcase_id);
        return (it != node_temp_map.end() && !it->second.empty());
    }
 
    bool get_material_temperature(
          const Element* element,
          b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
          const size_t nb_thickness_interpolation, const double thickness_interpolation[],
          const double time, double& temperature, double& d_temperature_d_time) const {
        temperature = 0;
        d_temperature_d_time = 0;
        auto it = node_temp_map.find(subcase_id);
        if (it == node_temp_map.end() || it->second.empty()) { return false; }
        const NodeTempVector& node_temp_vector = it->second;
        int current_stage = current_case->get_stage_number();
        std::pair<size_t, Node* const*> nodes = element->get_nodes();
        for (size_t k = 0; k != node_temp_vector.size(); ++k) {
            const NodeTemp& nt = node_temp_vector[k];
            if (nt.stage_number < current_stage) { continue; }
            double scale;
            double scale_d;
            if (nt.stage_number > current_stage) {
                scale = current_case->get_stage_size(nt.stage_number);
                scale_d = 0;
            } else {
                scale = nt.scalef->value(time);
                scale_d = nt.scalef->d_value(time);
            }
 
            // Interpolate and scale.
            if (nt.values.size1() < nb_thickness_interpolation) {
                Exception() << "Number of temperature values per node "
                               "mismatch."
                            << THROW;
            }
            for (size_t j = 0; j != nodes.first; ++j) {
                const size_t jj = nodes.second[j]->get_id() - first_node_id_of_branch;
                for (size_t i = 0; i != nb_thickness_interpolation; ++i) {
                    const double f =
                          thickness_interpolation[i] * nodes_interpolation[j] * nt.values(i, jj);
                    temperature += f * scale;
                    d_temperature_d_time += f * scale_d;
                }
            }
        }
        return true;
    }
 
private:
    void load();
 
    struct NodeTemp {
        int stage_number;
        b2linalg::Matrix<double, b2linalg::Mrectangle> values;
        TimeFunction* scalef;
    };
 
    typedef std::vector<NodeTemp> NodeTempVector;
    typedef std::map<int, NodeTempVector> NodeTempVectorMap;
 
    int branch_id{};
    size_t branch_internal_id{};
    size_t first_node_id_of_branch{};
    DomainProperty& parent;
    b2000::Case* current_case{};
    int subcase_id{};
    NodeTempVectorMap node_temp_map;
    bool loaded{};
};
 
}  // namespace b2000::b2dbv3
 
#endif  // B2_BRANCH_PROPERTY_H_