analytic1d.hpp

Go to the documentation of this file.

// Copyright 2015-2018 The ALMA Project Developers
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the License.

#pragma once


#include <constants.hpp>
#include <structures.hpp>
#include <qpoint_grid.hpp>
#include <Eigen/Dense>

namespace alma {

namespace analytic1D {


class BasicProperties_calculator {
public:
    BasicProperties_calculator(const alma::Crystal_structure* poscar,
                               const alma::Gamma_grid* grid,
                               const Eigen::ArrayXXd* w,
                               double T);

    void setDirection(const Eigen::Vector3d unitvector);

    void setLogMFPbins(double MFPmin, double MFPmax, int Nbins);

    void setAutoMFPbins(int Nbins);

    void setAutoProjMFPbins(int Nbins);

    void setLogRTbins(double taumin, double taumax, int Nbins);

    void setAutoRTbins(int Nbins);

    void setLinOmegabins(double omegamin, double omegamax, int Nbins);

    void setAutoOmegabins(int Nbins);

    Eigen::VectorXd getMFPbins();

    Eigen::VectorXd getRTbins();

    Eigen::VectorXd getOmegabins();

    void setBulk();

    void setInPlaneFilm(double filmthickness,
                        const Eigen::Vector3d normal,
                        double specularity = 0.0);
    void setCrossPlaneFilm(double filmthickness);

    double getConductivity();

    double getSpectralConductivity();

    double getCapacity();

    double getDiffusivity();

    double getDominantProjMFP();

    double getDominantRT();

    double getAnisotropyIndex();

    void resolveByMFP();

    void resolveByProjMFP();

    void resolveByRT();

    void resolveByOmega();

    Eigen::VectorXd getCumulativeConductivity();

    Eigen::VectorXd getCumulativeCapacity();

    void setDOSgridsize(int nbins);

    Eigen::VectorXd getDOSgrid();

    Eigen::VectorXd getDOS();

private:
    const alma::Crystal_structure* poscar;
    const alma::Gamma_grid* grid;
    const Eigen::ArrayXXd* w;
    double T;

    Eigen::Vector3d unitvector;
    Eigen::Vector3d normalvector;
    Eigen::VectorXd MFPbins;
    Eigen::VectorXd taubins;
    Eigen::VectorXd omegabins;
    double internal_MFPmax;
    double internal_MFPprojmax;
    double internal_taumax;
    double internal_omegamax;
    bool thinfilm;
    bool crossplane;
    double filmthickness;
    double specularity; // for in-plane films
    double kappa;
    double Cv;
    double dominantProjMFP;
    double dominantRT;
    Eigen::Matrix3d FuchsRotation;
    void initFuchsRotation();
    void updateMe();
    Eigen::VectorXd kappacumul;
    Eigen::VectorXd Cvcumul;

    enum kappacumulID {
        resolve_by_MFP,
        resolve_by_ProjMFP,
        resolve_by_RT,
        resolve_by_omega
    };
    int kappacumulIdentifier;
    int DOS_Nbins;
};


class psi_calculator {
public:
    psi_calculator(const alma::Crystal_structure* poscar,
                   const alma::Gamma_grid* grid,
                   const Eigen::ArrayXXd* w,
                   double T);

    void setDirection(const Eigen::Vector3d unitvector);

    void setLinGrid(double ximin, double ximax, int Nxi);

    void setLogGrid(double ximin, double ximax, int Nxi);

    void setXiGrid(const Eigen::Ref<const Eigen::VectorXd> xigrid);

    Eigen::VectorXd getSpatialFrequencies();

    void normaliseOutput(bool norm);

    double getDiffusivity();

    Eigen::VectorXd getPsi();

private:
    const alma::Crystal_structure* poscar;
    const alma::Gamma_grid* grid;
    const Eigen::ArrayXXd* w;
    double T;

    Eigen::Vector3d unitvector;
    Eigen::VectorXd xi;
    bool scaleoutput;
    double Dbulk;
    void updateDiffusivity();
    Eigen::VectorXd psi;
};



class SPR_calculator_FourierLaplace {
public:
    SPR_calculator_FourierLaplace(const alma::Crystal_structure* poscar,
                                  const alma::Gamma_grid* grid,
                                  const Eigen::ArrayXXd* w,
                                  double T);

    void setDirection(const Eigen::Vector3d unitvector);

    void setLinSpatialGrid(double ximin, double ximax, int Nxi);

    void setLogSpatialGrid(double ximin, double ximax, int Nxi);

    void setLinTemporalGrid(double fmin, double fmax, int Nf);

    void setLogTemporalGrid(double fmin, double fmax, int Nf);

    Eigen::VectorXd getSpatialFrequencies();

    Eigen::VectorXd getTemporalFrequencies();

    Eigen::MatrixXcd getSPR();

private:
    const alma::Crystal_structure* poscar;
    const alma::Gamma_grid* grid;
    const Eigen::ArrayXXd* w;
    double T;

    Eigen::Vector3d unitvector;
    Eigen::VectorXd xi;
    Eigen::VectorXd f;
    Eigen::VectorXcd s;
    Eigen::MatrixXcd Pxis;
};



class SPR_calculator_RealSpace {
public:
    SPR_calculator_RealSpace(const alma::Crystal_structure* poscar,
                             const alma::Gamma_grid* grid,
                             const Eigen::ArrayXXd* w,
                             double T);

    void setDirection(const Eigen::Vector3d unitvector);

    void setLinGrid(double xmin, double xmax, int Nx);

    void setLogGrid(double xmin, double xmax, int Nx);

    void declareGridNormalised(bool norm);

    // Optional normalisation of calculation output
    // by sqrt(4*pi*Dbulk*t)
    void normaliseOutput(bool norm);

    void setTime(double t);

    void setLogMFPbins(double MFPmin, double MFPmax, int Nbins);

    Eigen::VectorXd getGrid();
    Eigen::VectorXd getNormalisedGrid();

    double getTime();

    Eigen::VectorXd getMFPbins();

    double getDiffusivity();

    Eigen::VectorXd getSourceTransient(
        const Eigen::Ref<Eigen::VectorXd> timegrid);

    Eigen::VectorXd getSPR();

    Eigen::MatrixXd resolveSPRbyMFP();

private:
    const alma::Crystal_structure* poscar;
    const alma::Gamma_grid* grid;
    const Eigen::ArrayXXd* w;
    double T;

    Eigen::Vector3d unitvector;
    Eigen::Vector3d filmnormal;
    Eigen::VectorXd x;
    bool gridIsNormalised;
    bool normaliseoutput;
    Eigen::VectorXd MFPbins;
    double t;
    double Dbulk;
    void updateDiffusivity();
    Eigen::VectorXd Pxt;
    Eigen::MatrixXd Pmodes;
};



class MSD_calculator_Laplace {
public:
    MSD_calculator_Laplace(const alma::Crystal_structure* poscar,
                           const alma::Gamma_grid* grid,
                           const Eigen::ArrayXXd* w,
                           double T);

    void setDirection(const Eigen::Vector3d unitvector);

    void setLinGrid(double fmin, double fmax, int Nf);

    void setLogGrid(double fmin, double fmax, int Nf);

    void setLaplaceGrid(const Eigen::Ref<const Eigen::VectorXcd> sgrid);

    Eigen::VectorXd getGrid();
    Eigen::VectorXcd getLaplaceGrid();

    Eigen::VectorXcd getMSD();

private:
    const alma::Crystal_structure* poscar;
    const alma::Gamma_grid* grid;
    const Eigen::ArrayXXd* w;
    double T;

    Eigen::Vector3d unitvector;
    Eigen::VectorXd f;
    Eigen::VectorXcd s;
    Eigen::VectorXcd MSD;
};



class MSD_calculator_RealTime {
public:
    MSD_calculator_RealTime(const alma::Crystal_structure* poscar,
                            const alma::Gamma_grid* grid,
                            const Eigen::ArrayXXd* w,
                            double T);

    void setDirection(const Eigen::Vector3d unitvector);

    void setLinGrid(double tmin, double tmax, int Nt);

    void setLogGrid(double tmin, double tmax, int Nt);

    void setTimeGrid(const Eigen::Ref<const Eigen::VectorXd> tgrid);

    Eigen::VectorXd getGrid();

    void normaliseOutput(bool norm);

    double getDiffusivity();

    Eigen::VectorXd getMSD();

private:
    const alma::Crystal_structure* poscar;
    const alma::Gamma_grid* grid;
    const Eigen::ArrayXXd* w;
    double T;

    Eigen::Vector3d unitvector;
    Eigen::Vector3d filmnormal;
    Eigen::VectorXd t;
    double Dbulk;
    void updateDiffusivity();
    bool normaliseoutput;
    Eigen::VectorXd MSD;

    int GS_depth;
    Eigen::VectorXd GS_coeffs;
    double factorial(int n);
};
} // end namespace analytic1D
} // end namespace alma