b2case.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2case.H --
//
//
// written by Mathias Doreille
//            Thomas Blome <thomas.blome@dlr.de>
//
// Copyright (c) 2004-2012 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 __B2CASE_H__
#define __B2CASE_H__
 
#include <complex>
#include <memory>
#include <string>
 
#include "b2ppconfig.h"
#include "utils/b2csda.H"
#include "utils/b2dictionary.H"
#include "utils/b2object.H"
 
namespace b2000 {
 
class Model;
class Domain;
class NaturalBoundaryCondition;
class EssentialBoundaryCondition;
class ModelReductionBoundaryCondition;
class InitialCondition;
 
class AttributeList : public Dictionary {
public:
    ~AttributeList() override {}
 
    virtual void set(const std::string& key, int value) = 0;
 
    virtual void set(const std::string& key, double value) = 0;
 
    virtual void set(const std::string& key, b2000::csda<double> value) = 0;
 
    virtual void set(const std::string& key, std::complex<double> value) = 0;
 
    virtual void set(const std::string& key, const std::string& value) = 0;
};
 
class Case : public AttributeList {
public:
    ~Case() override {}
 
    virtual std::string get_id() const = 0;
 
    virtual void get_subcase_ids(std::set<int>& subcase_ids_) const = 0;
 
    virtual size_t get_number_of_stage() const = 0;
 
    virtual int get_stage_number() const = 0;
 
    virtual std::string get_stage_id(int stage = -1) const = 0;
 
    virtual double get_stage_size(int stage = -1) const = 0;
 
    virtual bool next_stage() = 0;
 
    virtual void set_stage(int stage) = 0;
 
    using type_t = ObjectTypeIncomplete<Case>;
    static type_t type;
};
 
class CaseList : public Object {
public:
    ~CaseList() override {}
 
    virtual void set_model(Model& model) = 0;
 
    virtual size_t get_number_of_case() const = 0;
 
    class CaseIterator {
    public:
        virtual ~CaseIterator() {}
        virtual Case* next() = 0;
        virtual size_t get_number_of_case() const = 0;
    };
 
    using case_iterator = std::unique_ptr<CaseIterator>;
 
    virtual case_iterator get_case_iterator() = 0;
 
    class CaseListIterator {
    public:
        virtual ~CaseListIterator() {}
        virtual CaseList* next() = 0;
        virtual size_t get_number_of_case_list() const = 0;
    };
 
    using case_list_iterator = std::unique_ptr<CaseListIterator>;
 
    virtual Case* get_case(const std::string& case_id) {
        case_iterator i = get_case_iterator();
        Case* c = nullptr;
        while ((c = i->next()) != nullptr) {
            if (c->get_id() == case_id) { return c; }
        }
        return nullptr;
    }
 
    enum SortType {
        value_constant_at_null_dof,
        d_value_d_dof_constant_at_null_dof,
        value_and_d_value_d_dof_constant_at_null_dof
    };
 
    virtual case_list_iterator get_case_sublist_iterator(const Domain* domain, SortType st) = 0;
 
    virtual case_list_iterator get_case_sublist_iterator(
          const NaturalBoundaryCondition* nbc, SortType st) = 0;
 
    virtual case_list_iterator get_case_sublist_iterator(
          const EssentialBoundaryCondition* ebc, SortType st) = 0;
 
    virtual case_list_iterator get_case_sublist_iterator(
          const ModelReductionBoundaryCondition* mrbc, SortType st) = 0;
 
    virtual case_list_iterator get_case_sublist_iterator(
          const InitialCondition* ic, SortType st) = 0;
 
    using type_t = ObjectTypeIncomplete<CaseList>;
    static type_t type;
};
}  // namespace b2000
 
#endif