targets.hpp

Go to the documentation of this file.

// Copyright (c) 2016-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)
// Copyright (c) 2016-2018 Centre national de la recherche scientifique (CNRS)
// Copyright (c) 2018-2023 Simons Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Michel Ferrero, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "../../arrays.hpp"
 
#include <nda/stdutil/complex.hpp>
 
#include <type_traits>
 
namespace triqs::gfs {

 
  // Forward declarations.
  template <int R> struct tensor_valued;
  struct matrix_valued;
  struct scalar_valued;

  template <int R> struct tensor_real_valued {
    static_assert(R > 0, "tensor_real_valued : R must be > 0");

    static constexpr int rank = R;

    static constexpr int is_real = true;

    static constexpr bool is_matrix = false;

    using scalar_t = double;

    using real_t = tensor_real_valued;

    using complex_t = tensor_valued<R>;
  };

  template <int R> struct tensor_valued {
    static_assert(R > 0, "tensor_valued : R must be > 0");

    static constexpr int rank = R;

    static constexpr int is_real = false;

    static constexpr bool is_matrix = false;

    using scalar_t = dcomplex;

    using real_t = tensor_real_valued<R>;

    using complex_t = tensor_valued;
  };

  struct matrix_real_valued {
    static constexpr int rank = 2;

    static constexpr int is_real = true;

    static constexpr bool is_matrix = true;

    using scalar_t = double;

    using real_t = matrix_real_valued;

    using complex_t = matrix_valued;
  };

  struct matrix_valued {
    static constexpr int rank = 2;

    static constexpr int is_real = false;

    static constexpr bool is_matrix = true;

    using scalar_t = dcomplex;

    using real_t = matrix_real_valued;

    using complex_t = matrix_valued;
  };

  struct scalar_real_valued {
    static constexpr int rank = 0;

    static constexpr int is_real = true;

    static constexpr bool is_matrix = false;

    using scalar_t = double;

    using real_t = scalar_real_valued;

    using complex_t = scalar_valued;
  };

  struct scalar_valued {
    static constexpr int rank = 0;

    static constexpr int is_real = false;

    static constexpr bool is_matrix = false;

    using scalar_t = dcomplex;

    using real_t = scalar_real_valued;

    using complex_t = scalar_valued;
  };

  template <typename T, int R> struct _target_from_type_rank;
 
  // Specialization mapping a complex scalar type and rank \f$ R \f$ to triqs::gfs::tensor_valued.
  template <int R> struct _target_from_type_rank<dcomplex, R> {
    using type = tensor_valued<R>;
  };
 
  // Specialization mapping a complex scalar type and rank 2 to triqs::gfs::matrix_valued.
  template <> struct _target_from_type_rank<dcomplex, 2> {
    using type = matrix_valued;
  };
 
  // Specialization mapping a complex scalar type and rank 0 to triqs::gfs::scalar_valued.
  template <> struct _target_from_type_rank<dcomplex, 0> {
    using type = scalar_valued;
  };
 
  // Specialization mapping a real scalar type and rank \f$ R \f$ to triqs::gfs::tensor_real_valued.
  template <int R> struct _target_from_type_rank<double, R> {
    using type = tensor_real_valued<R>;
  };
 
  // Specialization mapping a real scalar type and rank 2 to triqs::gfs::matrix_real_valued.
  template <> struct _target_from_type_rank<double, 2> {
    using type = matrix_real_valued;
  };
 
  // Specialization mapping a real scalar type and rank 0 to triqs::gfs::scalar_real_valued.
  template <> struct _target_from_type_rank<double, 0> {
    using type = scalar_real_valued;
  };

  template <typename A, int nvar>
  using target_from_array =
     typename _target_from_type_rank<typename std::decay_t<typename std::decay_t<A>::value_type>, std::decay_t<A>::rank - nvar>::type;

 
} // namespace triqs::gfs