b2time_integrator.H

//------------------------------------------------------------------------
// b2time_integrator.H --
//
//
// written by Harald Klimach <harald.klimach@dlr.de>
//            Thomas Blome <thomas.blome@dlr.de>
//
// (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 B2TIME_INTEGRATOR_H_
#define B2TIME_INTEGRATOR_H_
 
#include <utility>
 
#include "b2ppconfig.h"
#include "model/b2case.H"
#include "model/b2solver.H"
#include "utils/b2linear_algebra.H"
#include "utils/b2object.H"
 
namespace b2000::solver {
 
template <typename T>
class TimeIntegrator : public Object {
public:
    using type_t = ObjectTypeIncomplete<TimeIntegrator>;
    using EffectiveSymmetricSystem =
          std::pair<b2linalg::Matrix<T, b2linalg::Mpacked>, b2linalg::Vector<T, b2linalg::Vdense>>;
    using EffectiveUnsymmetricSystem = std::pair<
          b2linalg::Matrix<T, b2linalg::Mrectangle>, b2linalg::Vector<T, b2linalg::Vdense>>;
 
    virtual void SetAttribute(const Case& b2case) = 0;
 
    virtual void InitializeTimeIntegrator(
          const b2linalg::Matrix<T, b2linalg::Mrectangle>& initial_dof, const double dt) = 0;
 
    bool IsFinalStage() { return current_stage_number_ == max_stage_number_; }
 
    // const auto& GetVelocities() const = 0;
 
    virtual void InitializeFieldsForThisTimeStep(
          b2linalg::Matrix<T, b2linalg::Mrectangle>& dof,
          const b2linalg::Matrix<T, b2linalg::Mrectangle>& dU) = 0;
 
    virtual void UpdateFields(
          b2linalg::Matrix<T, b2linalg::Mrectangle>& dof,
          const b2linalg::Matrix<T, b2linalg::Mrectangle>& dU) = 0;
 
    virtual EffectiveSymmetricSystem GetEffectiveElementSystem(
          const b2linalg::Matrix<T, b2linalg::Mpacked>& k,
          const b2linalg::Matrix<T, b2linalg::Mpacked>& d,
          const b2linalg::Matrix<T, b2linalg::Mpacked>& m,
          const b2linalg::Matrix<T, b2linalg::Mrectangle_constref>& dof,
          const b2linalg::Index& index) const = 0;
 
    virtual EffectiveUnsymmetricSystem GetEffectiveElementSystem(
          const b2linalg::Matrix<T, b2linalg::Mrectangle>& k,
          const b2linalg::Matrix<T, b2linalg::Mrectangle>& d,
          const b2linalg::Matrix<T, b2linalg::Mrectangle>& m,
          const b2linalg::Matrix<T, b2linalg::Mrectangle_constref>& dof,
          const b2linalg::Index& index) const = 0;
 
    static type_t type;
 
    // double time_{};
 
protected:
    b2linalg::Matrix<T, b2linalg::Mrectangle> V_{};  
 
    b2linalg::Matrix<T, b2linalg::Mrectangle> Z_{};  
 
    b2linalg::Matrix<T, b2linalg::Mrectangle> dot_Z_{};  
 
    int current_stage_number_{1};  
    int max_stage_number_{1};      
    double dt{1};                  
};
 
template <typename T>
typename TimeIntegrator<T>::type_t TimeIntegrator<T>::type(
      "TimeIntegrator", type_name<T>(), StringList(), module, &Object::type);
 
}  // namespace b2000::solver
 
#endif  // B2TIME_INTEGRATOR_H_