Misc.hpp

Go to the documentation of this file.

//
// This file is part of pomerol, an exact diagonalization library aimed at
// solving condensed matter models of interacting fermions.
//
// Copyright (C) 2016-2024 A. Antipov, I. Krivenko and contributors
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#ifndef POMEROL_INCLUDE_POMEROL_MISC_HPP
#define POMEROL_INCLUDE_POMEROL_MISC_HPP
 
#include <pomerol/Version.hpp>
 
#include <libcommute/algebra_ids.hpp>
#include <libcommute/loperator/loperator.hpp>
#include <libcommute/loperator/state_vector.hpp>
 
#ifndef DOXYGEN_SKIP
#define EIGEN_YES_I_KNOW_SPARSE_MODULE_IS_NOT_STABLE_YET
#endif
#include <Eigen/Core>
#include <Eigen/Sparse>
 
#ifdef POMEROL_USE_OPENMP
#include <omp.h>
#endif
 
#if __cplusplus >= 201402L
#define POMEROL_DEPRECATED [[deprecated]]
#else
#define POMEROL_DEPRECATED
#endif
 
#include <array>
#include <complex>
#include <cstddef>
#include <iostream>
#include <type_traits>
 
namespace Pomerol {
 
 
#ifndef DOXYGEN_SKIP
#define MSG_PREFIX __FILE__ << ":" << __LINE__ << ": "
#endif
#ifndef NDEBUG
#define DEBUG(MSG) std::cout << MSG_PREFIX << MSG << '\n'
#else
#define DEBUG(MSG)
#endif
#define INFO(MSG) std::cout << MSG << '\n'
#define INFO_NONEWLINE(MSG) std::cout << MSG
#define ERROR(MSG) std::cerr << MSG_PREFIX << MSG << '\n'
 
using RealType = double;
using ComplexType = std::complex<double>;
 
using ParticleIndex = unsigned int;
 
using QuantumState = libcommute::sv_index_type;
 
using ComplexMatrixType =
    Eigen::Matrix<ComplexType, Eigen::Dynamic, Eigen::Dynamic, Eigen::AutoAlign | Eigen::RowMajor>;
 
template <bool Complex> using MelemType = typename std::conditional<Complex, ComplexType, RealType>::type;
 
template <typename ScalarType>
using LOperatorType = libcommute::loperator<ScalarType, libcommute::fermion, libcommute::boson>;
 
template <bool Complex>
using LOperatorTypeRC = libcommute::loperator<MelemType<Complex>, libcommute::fermion, libcommute::boson>;
 
template <bool Complex>
using MatrixType =
    Eigen::Matrix<MelemType<Complex>, Eigen::Dynamic, Eigen::Dynamic, Eigen::AutoAlign | Eigen::RowMajor>;
 
using ComplexVectorType = Eigen::Matrix<ComplexType, Eigen::Dynamic, 1, Eigen::AutoAlign>;
using RealVectorType = Eigen::Matrix<RealType, Eigen::Dynamic, 1, Eigen::AutoAlign>;
 
template <bool Complex> using VectorType = Eigen::Matrix<MelemType<Complex>, Eigen::Dynamic, 1, Eigen::AutoAlign>;
 
template <bool Complex> using ColMajorMatrixType = Eigen::SparseMatrix<MelemType<Complex>, Eigen::ColMajor>;
template <bool Complex> using RowMajorMatrixType = Eigen::SparseMatrix<MelemType<Complex>, Eigen::RowMajor>;
 
static ComplexType const I = ComplexType(0.0, 1.0); // 'static' to prevent linking problems
 
struct Permutation3 {
    std::array<std::size_t, 3> const perm;
    int const sign;
    bool operator==(Permutation3 const& rhs) const;
    bool operator!=(Permutation3 const& rhs) const;
 
    friend std::ostream& operator<<(std::ostream& os, Permutation3 const& p);
};
extern std::array<Permutation3, 6> const permutations3;
 
struct Permutation4 {
    std::array<std::size_t, 4> const perm;
    int const sign;
    bool operator==(Permutation4 const& rhs) const;
    bool operator!=(Permutation4 const& rhs) const;
 
    friend std::ostream& operator<<(std::ostream& os, Permutation4 const& p);
};
extern std::array<Permutation4, 24> const permutations4;
 
enum Channel : int {
    PP, 
    PH, 
    xPH 
};
std::ostream& operator<<(std::ostream& os, Channel channel);
 
std::size_t hash_binned_real(double x, double bin_size);
 
 
} // namespace Pomerol
 
#endif // #ifndef POMEROL_INCLUDE_POMEROL_MISC_HPP