spinAccumulationSolver.h

#ifndef spinAccumulationSolver_h
#define spinAccumulationSolver_h
 
#include <vector>
#include "config.h"
#include "node.h"
#include "tetra.h"
#include "electrostatSolver.h"
#include "solver.h"
#include "meshUtils.h"
 
const int DIM_PB_SPIN_ACC = 3;
 
class spinAcc : public solver<DIM_PB_SPIN_ACC>
    {
    public:
    spinAcc(Mesh::mesh &_msh ,
    std::vector<Tetra::prm> & _pTetra ,
    std::vector<Facette::prm> & _pFac ,
    const double _tol ,  // _tol could be 1e-6
    const bool v ,
    const int max_iter ):
        solver<DIM_PB_SPIN_ACC>(_msh,_pTetra,_pFac,"bicg_dir",_tol,v,max_iter), verbose(v)
        {
        valDirichlet.resize(DIM_PB*NOD);
        boundaryConditions();
        }
 
    void boundaryConditions(void);
 
    void preCompute(void);
 
    bool compute(void);
 
    void setPotential(std::vector<double> &_V);
 
    bool checkBoundaryConditions(bool verbose) const;
 
    std::vector<Eigen::Vector3d> s;
 
    private:
    std::vector<double> V;
 
    std::vector<double> valDirichlet;
 
    std::vector<int> idxDirichlet;
 
    void fillDirichletData(const int k, Eigen::Vector3d &s_value);
 
    std::vector< Eigen::Matrix<double,Nodes::DIM,Tetra::NPI> > gradV;
 
    std::vector< Eigen::Matrix<double,Nodes::DIM,Tetra::NPI> > Hm;
 
    const bool verbose;
 
    const int precision = 8;
 
    double getJs(Tetra::Tet const &tet) const;
 
    double getSigma(Tetra::Tet const &tet) const;
    
    double getPolarization(Tetra::Tet &tet) const;
 
    double getN0(Tetra::Tet &tet) const;
 
    double getLsd(Tetra::Tet &tet) const;
 
    double getLsf(Tetra::Tet &tet) const;
 
    double getSpinHall(Tetra::Tet &tet) const;
 
    void prepareExtras(void);
 
    void calc_gradV(Tetra::Tet const &tet, Eigen::Ref<Eigen::Matrix<double,Nodes::DIM,Tetra::NPI>> _gradV);
 
    void calc_Hm(Tetra::Tet const &tet, Eigen::Ref<Eigen::Matrix<double,Nodes::DIM,Tetra::NPI>> _gradV,
                 Eigen::Ref<Eigen::Matrix<double,Nodes::DIM,Tetra::NPI>> _Hm);
 
    bool solve(void);
 
    void integraleMag(Tetra::Tet &tet,
                      Eigen::Matrix<double,DIM_PB*Tetra::N,DIM_PB*Tetra::N> &AE,
                      std::vector<double> &BE);
 
    void integraleSpinHall(Tetra::Tet &tet, std::vector<double> &BE);
 
    void integrales(Tetra::Tet &tet,
                    Eigen::Matrix<double,DIM_PB*Tetra::N,DIM_PB*Tetra::N> &AE);
 
    void integrales(Facette::Fac &fac, Eigen::Vector3d &Q, std::vector<double> &BE);
    };
 
#endif