bddcSpaceTransfer.hh

Go to the documentation of this file.

 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2024-2024 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef BDDCSPACETRANSFER_HH
#define BDDCSPACETRANSFER_HH
 
#include "dune/common/fvector.hh"
#include <dune/istl/bvector.hh>
 
#include <vector>
#include <map>
namespace Kaskade::BDDC
{
 
  using Interfaces = std::vector<std::pair<int,std::vector<int>>>;
 
  // ----------------------------------------------------------------------------------------------
 
  template <int m, class Scalar>
  class SpaceTransferBase
  {
  public:
    using XEntry = Dune::FieldVector<Scalar,m>;
    using XVector = Dune::BlockVector<XEntry>;
    using Vector = Dune::BlockVector<Dune::FieldVector<Scalar,1>>;
 
    void setInterfaces(int id, Interfaces const& ifs);
 
    void setInterfaceAveragingWeights(int s, XVector const& rho);
 
    void getInterfaceAveragingWeights(int s, XVector& rho) const;
 
  protected:
 
    // Returns the interface-local indices of dofs shared with subdomain s.
    std::vector<int> const& localIdx(int s) const;
 
    int id; // own subdomain number
 
    // We think in interface dofs and indices. We therefore maintain a mapping of
    // interface dof indices to subdomain dof indices (globalIndex), and a
    // list of interface indices (instead of subdomain indices) for each interface group
    // (localIfs).
    std::vector<int> globalIndex;
    Interfaces localIfs;
 
    // This contains for each shared dof the own averaging weight w_i as well as the
    // sum of all weights (i.e. the averaging denominator).
    XVector myAvgWeight;
    XVector avgWeightSum;
  };
 
  // ----------------------------------------------------------------------------------------------
 
  template <int m, class Scalar=double, class TransmissionScalar=Scalar>
  class SpaceTransfer: public SpaceTransferBase<m,Scalar>
  {
    using Base = SpaceTransferBase<m,Scalar>;
 
  public:
    using XEntry = Dune::FieldVector<Scalar,m>;
    using XVector = Dune::BlockVector<XEntry>;
    using Vector = Dune::BlockVector<Dune::FieldVector<Scalar,1>>;
 
    using TEntry = Dune::FieldVector<TransmissionScalar,m>;
 
    using TransmissionType = std::vector<TEntry>;
 
    void preProlongate(Vector const& u);
 
    void getInterfaceValues(int s, TransmissionType& values) const;
 
    void setInterfaceValues(int s, TransmissionType const& values);
 
    void postProlongate(Vector const& u, Vector& du) const;
 
    void preRestrict(Vector const& r);
 
    void getInterfaceResidualUpdate(int s, TransmissionType& dres) const;
 
    void setInterfaceResidualUpdate(int s, TransmissionType const& dres);
 
    void postRestrict(Vector& r);
 
    void setGlobalIndex_active();
    void setInActiveIdx(int gIdx);
 
    void get_globalIndex(std::set<int> & globalIndex_notActive)
    {
      std::map<int, int>::iterator it;
      for (it = globalIndex_active.begin(); it != globalIndex_active.end(); it++)
      {
        if(not it->second)
        {
          globalIndex_notActive.insert(it->first);
        }             
      }
    }
 
  private:
    using Base::localIdx;
    using Base::globalIndex;
    using Base::avgWeightSum;
    using Base::myAvgWeight;
 
    // We store the interface values in transmission message format to be sent to
    // neighboring subdomains on demand. On restriction, this contains residual updates.
    // On prolongation, this contains weighted correction values.
    TransmissionType localIfValues;
 
    // On prolongation, we need to accumulate the weighted interface values received from
    // neighbors.
    TransmissionType ifValues;
 
    // We keep track of the local residual that we already have sent to neighbors (which may
    // be inexact due to compression or mixed precision), such that we can send only the
    // updates.
    XVector localPublishedResidual;
 
    // Correspondingly, we maintain the summed interface residual, which is updated with the
    // (possibly inexact) residual updates we receive from the neighbors.
    XVector residualSum;
 
    std::map<int,int> globalIndex_active;
  };
 
 
}
 
#endif