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)
        {
        valDirichlet.resize(DIM_PB*NOD);
        boundaryConditions();
        }
 
    void boundaryConditions(void); // should be private
 
    void preCompute(void);
 
    bool compute(void);
 
    void setPotential(std::vector<double> &_V);
 
    std::vector<Eigen::Vector3d> s;
 
    void checkBoundaryConditions(void) const;
 
    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> > Hst;
 
    const int precision = 8;
 
    double getMs(Tetra::Tet const &tet) const;
 
    double getSigma(Tetra::Tet const &tet) const;
 
    double getPolarizationRate(Tetra::Tet &tet) const;
 
    double getDiffusionCst(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_Hst(Tetra::Tet const &tet, Eigen::Ref<Eigen::Matrix<double,Nodes::DIM,Tetra::NPI>> _gradV,
                 Eigen::Ref<Eigen::Matrix<double,Nodes::DIM,Tetra::NPI>> _Hst);
 
    bool solve(void);
 
    void integraleMag(Tetra::Tet &tet, Eigen::Matrix<double,DIM_PB*Tetra::N,DIM_PB*Tetra::N> &AE);
 
    void integraleMag(Tetra::Tet &tet,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);
    };
 
#endif