b2solver.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2solver.H --
//
//
// written by Mathias Doreille
//            Thomas Blome <thomas.blome@dlr.de>
//
// Copyright (c) 2004-2012,2016 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 __B2SOLVER_H__
#define __B2SOLVER_H__
 
#include <functional>
 
#include "b2ppconfig.h"
#include "model/b2case.H"
#include "model/b2domain.H"
#include "model/b2element.H"
#include "model/b2initial_condition.H"
#include "model/b2model.H"
#include "utils/b2object.H"
#include "utils/b2threading.H"
 
 
namespace b2000 {
 
class Model;
class Case;
 
namespace solver {
extern Module module;
}
 
class Solver : public Object {
public:
    using type_t = ObjectTypeIncomplete<Solver>;
 
    void set_model(Model& model) { model_ = &model; };
 
    b2000::Model& GetModel() const { return *model_; };  
 
    void set_case(Case& b2case) { case_ = &b2case; };
 
    const bool IsLinear() const { return is_linear_; }
 
    bool IsDynamic() const { return is_dynamic_; }
 
    bool IsDamped() const { return is_damped_; }
 
    bool IsImplicit() const { return is_implicit_; }
 
    double GetTime() const { return time_; }
 
    double GetStepSize() const { return step_size_; }
 
    virtual void solve() = 0;
 
    static type_t type;
 
protected:
    virtual bool solve_iteration() = 0;
 
    virtual void InitializeSolverOnCase();
 
    Model* model_{};  
    Case* case_{};    
 
    double time_{};          
    double time_max_{1.0};   
    double step_size_{1.0};  
 
    bool is_linear_{};
    bool is_implicit_{true};
    bool is_damped_{};
    bool is_dynamic_{};
 
    size_t total_num_dof_{};      
    size_t effective_num_dof_{};  
    size_t number_of_fixed_dof_{};
 
    size_t iteration_count_{};
    const size_t kMaxIterations_{50};
 
    int current_stage_{};  
 
    CaseList::case_iterator case_iterator_{};
};
 
inline void Solver::InitializeSolverOnCase() {
    if (model_ == nullptr) { Exception() << THROW; }
 
    model_->set_case(*case_);
 
    const std::string analysis_type = case_->get_string("ANALYSIS");
    is_linear_ =
          !analysis_type.ends_with("NONLINEAR") && !analysis_type.ends_with("NONLINEAR_SOLUTION");
    is_dynamic_ = analysis_type.starts_with("MDYNAMIC");
    is_damped_ = analysis_type.starts_with("MTRANSIENT");
 
    time_ = 0;
    time_max_ = is_dynamic_ || is_damped_
                      ? case_->get_stage_size()
                      : 1;  
    step_size_ = is_dynamic_ || is_damped_ ? case_->get_double("STEP_SIZE") : 1;
    iteration_count_ = 0;
 
    // std::string domain_state_id;
    Domain& domain{model_->get_domain()};
 
    // Hier das evtl. auch für transient
    // if (is_dynamic_) {
    //     dynamic_cast<TypedInitialCondition<T>&>(model_->get_initial_condition())
    //           .get_dynamic_initial_condition_value(dof, time_, current_stage_, domain_state_id);
    // }
 
    // case_->set_stage(current_stage_);
    // if (!domain_state_id.empty()) { domain.load_state(domain_state_id); }
 
    total_num_dof_ = domain.get_number_of_dof();
}
 
class SolverHints : public Object {
public:
    enum Hints {
        none = 0,
 
        unfinished = 1,
 
        diverge = 2,
 
        degradation = 4,
 
        terminate_analysis = 5
    };
 
    SolverHints() : hints(none) {}
 
    SolverHints(int hints_) : hints(hints_) {}
 
    SolverHints& clear() {
        b2spin_rw_mutex::scoped_lock lock(tbb_mutex);
 
        hints = 0;
        return *this;
    }
 
    SolverHints& add(const Hints& other_hints) {
        b2spin_rw_mutex::scoped_lock lock(tbb_mutex);
 
        hints |= other_hints;
        return *this;
    }
 
    SolverHints& add(const SolverHints& other) {
        b2spin_rw_mutex::scoped_lock lock(tbb_mutex);
 
        hints |= other.hints;
        return *this;
    }
 
    SolverHints& operator|=(const Hints& other_hints) { return add(other_hints); }
 
    SolverHints& operator|=(const SolverHints& other) { return add(other); }
 
    int operator*() const {
        b2spin_rw_mutex::scoped_lock lock(const_cast<b2spin_rw_mutex&>(tbb_mutex));
 
        return hints;
    }
 
private:
    int hints;
 
    b2spin_rw_mutex tbb_mutex;
};
 
}  // namespace b2000
 
#endif