isotopic_scattering.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 <cstddef>
#include <cmath>
#include <array>
#include <vector>
#include <boost/mpi.hpp>
#include <boost/math/distributions/normal.hpp>
#include <boost/serialization/array.hpp>
#include <structures.hpp>
#include <qpoint_grid.hpp>
#include <boost/math/distributions/normal.hpp>

// Forward declarations of elements documented later on.
// Note that serialization of std::vectors of objects without
// a default constructor is broken in Boost version 1.58.0. See:
// http://stackoverflow.com/a/30437359/85371
// https://svn.boost.org/trac/boost/ticket/11342
// This will prevent ALMA from compiling. We check for that
// specific version in our cmake configuration.
namespace alma {
class Twoph_process;
}
namespace boost {
namespace serialization {
template <class Archive>
inline void save_construct_data(Archive& ar,
                                const alma::Twoph_process* t,
                                const unsigned int file_version);
}
} // namespace boost

namespace alma {
class Twoph_process {
private:
    friend class boost::serialization::access;
    template <class Archive>
    friend void boost::serialization::save_construct_data(
        Archive& ar,
        const Twoph_process* t,
        const unsigned int file_version);

    friend void save_bulk_hdf5(const char* filename,
                               const std::string& description,
                               const Crystal_structure& cell,
                               const Symmetry_operations& symmetries,
                               const Gamma_grid& grid,
                               const std::vector<Threeph_process>& processes,
                               const boost::mpi::communicator& comm);

    friend std::tuple<std::string,
                      std::unique_ptr<Crystal_structure>,
                      std::unique_ptr<Symmetry_operations>,
                      std::unique_ptr<Gamma_grid>,
                      std::unique_ptr<std::vector<Threeph_process>>>
    load_bulk_hdf5(const char* filename, const boost::mpi::communicator& comm);

    const double domega;
    const double sigma;
    const double gaussian;

public:
    const std::size_t c;
    const std::array<std::size_t, 2> q;
    const std::array<std::size_t, 2> alpha;
    Twoph_process(std::size_t _c,
                  const std::array<std::size_t, 2>& _q,
                  const std::array<std::size_t, 2>& _alpha,
                  double _domega,
                  double _sigma)
        : domega(_domega), sigma(_sigma),
          gaussian(boost::math::pdf(boost::math::normal(0., sigma), domega)),
          c(_c), q(std::move(_q)), alpha(std::move(_alpha)) {
    }


    Twoph_process(const Twoph_process& original)
        : domega(original.domega), sigma(original.sigma),
          gaussian(original.gaussian), c(original.c), q(original.q),
          alpha(original.alpha) {
    }


    Twoph_process(std::size_t _c,
                  const std::array<std::size_t, 2>& _q,
                  const std::array<std::size_t, 2>& _alpha,
                  double _domega,
                  double _sigma,
                  double _gaussian)
        : domega(_domega), sigma(_sigma), gaussian(_gaussian), c(_c),
          q(std::move(_q)), alpha(std::move(_alpha)) {
    }


    double compute_gamma(const Crystal_structure& cell,
                         const Gamma_grid& grid) const;

    double compute_gamma(const Crystal_structure& cell,
                         const Eigen::Ref<const Eigen::VectorXd>& gfactors,
                         const Gamma_grid& grid) const;
};
std::vector<Twoph_process> find_allowed_twoph(
    const Gamma_grid& grid,
    const boost::mpi::communicator& communicator,
    double scalebroad = 1.0);

Eigen::ArrayXXd calc_w0_twoph(const Crystal_structure& cell,
                              const alma::Gamma_grid& grid,
                              const std::vector<alma::Twoph_process>& processes,
                              const boost::mpi::communicator& comm);

Eigen::ArrayXXd calc_w0_twoph(const Crystal_structure& cell,
                              const Eigen::Ref<const Eigen::VectorXd>& gfactors,
                              const alma::Gamma_grid& grid,
                              const std::vector<alma::Twoph_process>& processes,
                              const boost::mpi::communicator& comm);
} // namespace alma

namespace boost {
namespace serialization {
template <class Archive>
inline void save_construct_data(Archive& ar,
                                const alma::Twoph_process* t,
                                const unsigned int file_version) {
    ar << t->c;
    ar << make_array(t->q.data(), t->q.size());
    ar << make_array(t->alpha.data(), t->alpha.size());
    ar << t->domega;
    ar << t->sigma;
    ar << t->gaussian;
}


template <class Archive>
inline void load_construct_data(Archive& ar,
                                alma::Twoph_process* t,
                                const unsigned int file_version) {
    std::size_t c;

    ar >> c;
    std::array<std::size_t, 2> q;
    ar >> make_array(q.data(), q.size());
    std::array<std::size_t, 2> alpha;
    ar >> make_array(alpha.data(), alpha.size());
    double domega;
    ar >> domega;
    double sigma;
    ar >> sigma;
    double gaussian;
    ar >> gaussian;
    ::new (t) alma::Twoph_process(c, q, alpha, domega, sigma, gaussian);
}
} // namespace serialization
} // namespace boost