linear_algebra.h

Go to the documentation of this file.

#ifndef linear_algebra_h
#define linear_algebra_h
 
#include <random>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#include <execution>
#pragma GCC diagnostic pop
 
#include "config.h"
 
#include "settings.h"
#include "solver.h"
#include "node.h"
#include "tetra.h"
 
const int DIM_PB_MAG = 2;
 
class LinAlgebra : public solver<DIM_PB_MAG>
    {
public:
    LinAlgebra(Settings &s , Mesh::mesh &my_msh )
        : solver<DIM_PB_MAG>(
            my_msh, s.paramTetra, s.paramTriangle, "bicg_dir", s.TOL, s.verbose, s.MAXITER,
            [this](const Mesh::Edge edge){ return msh->magNode[edge.first] && msh->magNode[edge.second]; }
        ),
        verbose(s.verbose),
        extSpaceField(my_msh.extSpaceField),
        absorb(s.absorb)
        {
        Xw.resize(2 * NOD);
        base_projection();
        if (!s.recenter)
            { idx_dir = Nodes::IDX_UNDEF; }
        else
            { idx_dir = s.recentering_direction; }
 
        for (int i = 0; i < NOD; i++)
            {
            if(!my_msh.magNode[i])
                {
                lvd.push_back(2 * i    );
                lvd.push_back(2 * i + 1);
                }
            }
        lvd.shrink_to_fit();
        }
 
    void checkBoundaryConditions(void) const override {}
 
    void prepareElements(const Eigen::Vector3d &Hext ,
                         const timing &t_prm ) const;
 
    void prepareElements(const double A_Hext ,
                         const timing &t_prm ) const;
 
    void buildInitGuess(std::vector<double> &G) const;
 
    bool solve(const timing &t_prm );
 
    inline void set_DW_vz(const double vz )
        { DW_vz = vz; }
 
    inline double get_v_max(void) const
        { return v_max; }
 
    void base_projection() const;
 
private:
    Nodes::index idx_dir;
 
    std::vector<double> Xw;
 
    const int verbose;
 
    double DW_vz;
 
    double v_max;
 
    const std::vector< Eigen::Matrix<double,Nodes::DIM,Tetra::NPI> >& extSpaceField;
 
    std::vector<int> lvd;
 
    const AbsorbingEnds &absorb;
    };// end class linAlgebra
#endif