fem.h

Go to the documentation of this file.

#ifndef fem_h
#define fem_h
 
#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>
#include <list>
#include <vector>
 
#include <sys/times.h>
 
#include "mesh.h"
#include "fmm_demag.h"
#include "spinAccumulationSolver.h"
#include "linear_algebra.h"
#include "chronometer.h"
#include "ANN/ANN.h"
#include "settings.h"
 
const int NB_ENERGY_TERMS = 5;
 
enum ENERGY_TYPE
    {
    EXCHANGE = 0,
    ANISOTROPY = 1,
    DEMAG = 2,
    ZEEMAN = 3,
    DMI_BULK = 4
    };
 
class Fem
    {
public:
    inline Fem(Settings &mySets, timing &t_prm) : msh(mySets)
        {
        vmax = 0.0;
        std::fill(E.begin(),E.end(),0);
        Etot0 = INFINITY;  // avoid "WARNING: energy increased" on first time step
        Etot = 0.0;
 
        recenter_mem = false;
        if (mySets.recenter)
            {
            if (mySets.verbose)
                {
                std::cout << "Approximate nearest neighbors:\n";
                }
 
            pts = annAllocPts(msh.getNbNodes(), Nodes::DIM);
            if (!pts)
                {
                std::cerr << "ANN memory error while allocating points\n";
                SYSTEM_ERROR;
                }
            else if (mySets.verbose)
                {
                std::cout << "  points allocated\n";
                }
 
            for (int i = 0; i < msh.getNbNodes(); i++)
                {
                this->pts[i][0] = msh.getNode_p(i).x();
                this->pts[i][1] = msh.getNode_p(i).y();
                this->pts[i][2] = msh.getNode_p(i).z();
                }
 
            if (mySets.verbose)
                {
                std::cout << "  building kd_tree\n";
                }
 
            kdtree = new ANNkd_tree(pts, msh.getNbNodes(), Nodes::DIM);
            if (!kdtree)
                {
                std::cerr << "ANN memory error while allocating kd_tree\n";
                SYSTEM_ERROR;
                }
            recenter_mem = true;
 
            if (mySets.verbose)
                {
                std::cout << "  kd_tree allocated\n";
                }
            }
        else if (mySets.verbose)
            {
            std::cout << "No recentering.\n";
            }
 
        if (mySets.restoreFileName == "")
            {
            msh.init_distrib();
            }
        else
            {
            t_prm.set_t(gamma0 * msh.readSol(mySets.verbose, mySets.restoreFileName));
            }
 
        /* This potentially overrides the initial time set above by msh.readSol(). */
        if (!isnan(mySets.initial_time))
            {
            t_prm.set_t(gamma0 * mySets.initial_time);
            }
 
        if (mySets.recenter)
            {
            direction(Nodes::IDX_Z);
            } /* DW propagation direction for recentering */
        }
 
    ~Fem()
        {
        if (recenter_mem)
            {
            annDeallocPts(pts);
            delete kdtree;
            }
        }
 
    double vmax;
 
    std::array<double,NB_ENERGY_TERMS> E;
 
    double DW_dir;
 
    double Etot0;
 
    double Etot;
 
    Mesh::mesh msh;
 
    void energy(const double t 
                ,Settings &settings );
 
    inline void evolution(void)
        {
        msh.evolution();
        Etot0 = Etot;
        }
 
    void saver(Settings &settings , const timing &t_prm ,
               std::ofstream &fout , const int nt ,
               const spinAcc &spinAcc_solver ) const;
 
    bool recenter(double thres ,
                  char recentering_direction );
 
    int time_integration(Settings &settings ,
                         LinAlgebra &linAlg ,
                         spinAcc &spinAcc_solver ,
                         scal_fmm::fmm &myFMM ,
                         timing &t_prm ,
                         int &nt );
 
private:
    bool recenter_mem;  
    ANNkd_tree *kdtree; 
    ANNpointArray pts;  
    void direction(enum Nodes::index idx_dir );
 
    void compute_all(Settings &settings , scal_fmm::fmm &myFMM ,
                     const double t )
        {
        chronometer fmm_counter(2);
        myFMM.calc_demag(msh);
        if (settings.verbose)
            { std::cout << "magnetostatics done in " << fmm_counter.millis() << "\n"; }
        energy(t, settings);
        evolution();
        }
 
    void solve_spin_acc(Settings &settings , spinAcc &spinAcc_solver ,
                        const double t , const Nodes::step k )
        {
        spinAcc_solver.jn_multiplier = settings.jnMultiplier(t);
        bool success = spinAcc_solver.compute(k);
        if (settings.verbose)
            {
            if (success)
                { std::cout << "spin diffusion solved.\n"; }
            else
                { std::cerr << "spin diffusion solver failed.\n"; }
            }
        }
    };  // end class
 
#endif