dynamical_matrix.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 <boost/serialization/complex.hpp>
#include <boost/serialization/array.hpp>
#include <structures.hpp>
#include <symmetry.hpp>

namespace alma {
class Spectrum_at_point {
private:
    friend class boost::serialization::access;
    template <class Archive>
    void save(Archive& ar, const unsigned int version) const {
        auto rows = this->omega.size();

        ar << rows;
        ar << boost::serialization::make_array(this->omega.data(), rows);
        rows = this->wfs.rows();
        auto cols = this->wfs.cols();
        ar << rows;
        ar << cols;
        ar << boost::serialization::make_array(this->wfs.data(), rows * cols);
        rows = this->vg.rows();
        cols = this->vg.cols();
        ar << rows;
        ar << cols;
        ar << boost::serialization::make_array(this->vg.data(), rows * cols);
    }


    template <class Archive>
    void load(Archive& ar, const unsigned int version) {
        decltype(this->omega.size()) rows;
        ar >> rows;
        this->omega.resize(rows);
        ar >> boost::serialization::make_array(this->omega.data(), rows);
        decltype(rows) cols;
        ar >> rows;
        ar >> cols;
        this->wfs.resize(rows, cols);
        ar >> boost::serialization::make_array(this->wfs.data(), rows * cols);
        ar >> rows;
        ar >> cols;
        this->vg.resize(rows, cols);
        ar >> boost::serialization::make_array(this->vg.data(), rows * cols);
    }


    // Instruct boost::serialization to expect separate load()
    // and save() methods.
    BOOST_SERIALIZATION_SPLIT_MEMBER()
public:
    Eigen::ArrayXd omega;
    Eigen::MatrixXcd wfs;
    Eigen::ArrayXXd vg;
    Spectrum_at_point(const Eigen::Ref<const Eigen::ArrayXd>& _omega,
                      const Eigen::Ref<const Eigen::MatrixXcd>& _wfs,
                      const Eigen::Ref<const Eigen::ArrayXXd>& _vg)
        : omega(_omega), wfs(_wfs), vg(_vg) {
    }


    Spectrum_at_point() {
    }
};

class Dynamical_matrix_builder {
public:
    Dynamical_matrix_builder(const Crystal_structure& _structure,
                             const Symmetry_operations& syms,
                             const Harmonic_ifcs& fcs);
    Dynamical_matrix_builder(const Crystal_structure& _structure,
                             const Symmetry_operations& syms,
                             const Harmonic_ifcs& fcs,
                             const Dielectric_parameters& born);
    std::array<Eigen::MatrixXcd, 4> build(
        const Eigen::Ref<const Eigen::Vector3d>& q) const;

    std::unique_ptr<Spectrum_at_point> get_spectrum(
        const Eigen::Ref<const Eigen::Vector3d>& q) const;

    std::size_t get_nblocks() const {
        return this->blocks.size();
    }
    Eigen::MatrixXd get_block(std::size_t i) const {
        if (i >= this->blocks.size())
            throw value_error("invalid index");
        return this->blocks[i];
    }


    Triple_int get_pos(std::size_t i) const {
        if (i >= this->blocks.size())
            throw value_error("invalid index");
        return this->pos[i];
    }


private:
    std::vector<Eigen::MatrixXd> blocks;
    std::vector<Eigen::MatrixXd> masks;
    std::vector<Triple_int> pos;
    const int na;
    const int nb;
    const int nc;
    const double V;
    const Crystal_structure structure;
    const Eigen::MatrixXd rlattvec;
    const Symmetry_operations symmetries;
    Eigen::MatrixXd mpos;
    Eigen::MatrixXd cpos;
    Eigen::ArrayXXd massmatrix;
    const bool nonanalytic;
    const Dielectric_parameters born;
    void copy_blocks(const Harmonic_ifcs& fcs);

    Eigen::ArrayXcd get_exponentials(
        const Eigen::Ref<const Eigen::Vector3d>& q) const;

    std::array<Eigen::ArrayXXd, 4> build_nac(
        const Eigen::Ref<const Eigen::Vector3d>& q) const;
};
} // namespace alma