Kagome branch

.github/workflows/ci-github-actions-self-hosted.yaml

@@ -18,7 +18,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jobname: [GCC12-MPI-CUDA-Real-Full]
+        jobname: [LLVM21-MPI-CUDA-Real-Full]
+
     #            GCC12-MPI-NoMPI-CUDA-Real-Full,
     #            GCC12-MPI-NoMPI-CUDA-Real-Debug-Full,
 

applications/analysis/CMakeLists.txt

@@ -4,7 +4,8 @@ if (DCA_BUILD_ANALYSIS)
   add_executable(main_analysis main_analysis.cpp)
   target_include_directories(main_analysis PRIVATE ${DCA_INCLUDE_DIRS})
     if (DCA_HAVE_GPU)
-      target_link_libraries(main_analysis PRIVATE ${DCA_GPU_LIBS})
+      target_link_libraries(main_analysis PRIVATE ${DCA_GPU_LIBS}
+  magma::magma)
     endif()
 
     target_link_libraries(main_analysis PUBLIC signals ${DCA_LIBS} simplex_gm_rule)

build-aux/local_CPU.cmake

@@ -16,14 +16,14 @@ set(gtest_DIR "${CMAKE_CURRENT_LIST_DIR}/../libs/gmock-1.7.0/gtest/"
 
 # HDF5
 # CMake 3.6 does not properly find HDF5 if HDF5_ROOT is not set.
-set(HDF5_ROOT "/opt/homebrew/Cellar/hdf5/1.14.4.3/" CACHE PATH "Path to HDF5 installation directory.")
+set(HDF5_ROOT "/opt/homebrew/Cellar/hdf5/1.14.6/" CACHE PATH "Path to HDF5 installation directory.")
 # set(HDF5_ROOT "/usr/local/anaconda3/pkgs/hdf5-1.10.6-hdbbcd12_0/" CACHE PATH "Path to HDF5 installation directory.")
 
 # FFTW
 # set(FFTW_INCLUDE_DIR "/usr/local/Cellar/fftw/3.3.10/include" CACHE PATH "Path to fftw3.h.")
 # set(FFTW_LIBRARY "/usr/local/Cellar/fftw/3.3.10/lib/libfftw3.a" CACHE FILEPATH "Path to FFTW3 library.")
 set(FFTW_INCLUDE_DIR "/opt/homebrew/Cellar/fftw/3.3.10_1/include" CACHE PATH "Path to fftw3.h.")
-set(FFTW_LIBRARY "/opt/homebrew/Cellar/fftw/3.3.10_1/lib/libfftw3.a" CACHE FILEPATH "Path to FFTW3 library.")
+set(FFTW_LIBRARY "/opt/homebrew/Cellar/fftw/3.3.10_2/lib/libfftw3.a" CACHE FILEPATH "Path to FFTW3 library.")
 
 mark_as_advanced(gtest_DIR SPRNG_DIR HDF5_ROOT)
 
@@ -37,4 +37,3 @@ set(MPIEXEC_NUMPROC_FLAG "-np"
   CACHE STRING "Flag used by TEST_RUNNER to specify the number of processes.")
 
 mark_as_advanced(TEST_RUNNER MPIEXEC_NUMPROC_FLAG)
-

cmake/dca_config.cmake

@@ -121,8 +121,8 @@ endif()
 
 # Lattice type
 set(DCA_LATTICE "square" CACHE STRING "Lattice type, options are: bilayer | square | triangular |
-    Kagome | hund | twoband_Cu | threeband | Rashba_Hubbard | Moire_Hubbard | FeAs | material_NiO | material_FeSn | La3Ni2O7_bilayer")
-set_property(CACHE DCA_LATTICE PROPERTY STRINGS bilayer square triangular Kagome hund twoband_Cu threeband
+    Kagome | Plaquette | hund | twoband_Cu | threeband | Rashba_Hubbard | Moire_Hubbard | FeAs | material_NiO | material_FeSn | La3Ni2O7_bilayer")
+set_property(CACHE DCA_LATTICE PROPERTY STRINGS bilayer square triangular Kagome Plaquette hund twoband_Cu threeband
              Rashba_Hubbard Moire_Hubbard FeAs material_NiO material_FeSn La3Ni2O7_bilayer)
 
 if (DCA_LATTICE STREQUAL "bilayer")
@@ -149,48 +149,64 @@ elseif (DCA_LATTICE STREQUAL "triangular")
   set(DCA_LATTICE_TYPE dca::phys::models::triangular_lattice<PointGroup>)
   set(DCA_LATTICE_INCLUDE
     "dca/phys/models/analytic_hamiltonians/triangular_lattice.hpp")
+
 elseif (DCA_LATTICE STREQUAL "Kagome")
   set(DCA_LATTICE_TYPE dca::phys::models::KagomeHubbard<PointGroup>)
   set(DCA_LATTICE_INCLUDE
     "dca/phys/models/analytic_hamiltonians/Kagome_hubbard.hpp")
+
+elseif (DCA_LATTICE STREQUAL "Plaquette")
+  set(DCA_LATTICE_TYPE dca::phys::models::squarePlaquetteHubbard<PointGroup>)
+  set(DCA_LATTICE_INCLUDE
+    "dca/phys/models/analytic_hamiltonians/square_plaquette_hubbard.hpp")
+
 elseif (DCA_LATTICE STREQUAL "hund")
   set(DCA_LATTICE_TYPE dca::phys::models::HundLattice<PointGroup>)
   set(DCA_LATTICE_INCLUDE
     "dca/phys/models/analytic_hamiltonians/hund_lattice.hpp")
+
 elseif (DCA_LATTICE STREQUAL "threeband")
   set(DCA_LATTICE_TYPE dca::phys::models::ThreebandHubbard<PointGroup>)
   set(DCA_LATTICE_INCLUDE
     "dca/phys/models/analytic_hamiltonians/threeband_hubbard.hpp")
+
 elseif (DCA_LATTICE STREQUAL "Rashba_Hubbard")
   set(DCA_LATTICE_TYPE dca::phys::models::RashbaHubbard<PointGroup>)
   set(DCA_LATTICE_INCLUDE
     "dca/phys/models/analytic_hamiltonians/rashba_hubbard.hpp")
+
 elseif (DCA_LATTICE STREQUAL "Moire_Hubbard")
   set(DCA_LATTICE_TYPE dca::phys::models::moire_hubbard<PointGroup>)
   set(DCA_LATTICE_INCLUDE
     "dca/phys/models/analytic_hamiltonians/Moire_Hubbard.hpp")
+
 elseif (DCA_LATTICE STREQUAL "twoband_chain")
   set(DCA_LATTICE_TYPE dca::phys::models::twoband_chain<dca::phys::domains::no_symmetry<1>>)
   set(DCA_LATTICE_INCLUDE
       "dca/phys/models/analytic_hamiltonians/hund_lattice.hpp")
+
 elseif (DCA_LATTICE STREQUAL "FeAs")
   set(DCA_LATTICE_TYPE dca::phys::models::FeAsLattice<PointGroup>)
   set(DCA_LATTICE_INCLUDE
       "dca/phys/models/analytic_hamiltonians/fe_as_lattice.hpp")
+
 elseif (DCA_LATTICE STREQUAL "twoband_Cu")
   set(DCA_LATTICE_TYPE dca::phys::models::TwoBandCu<PointGroup>)
   set(DCA_LATTICE_INCLUDE
       "dca/phys/models/analytic_hamiltonians/twoband_Cu.hpp")
+
 elseif (DCA_LATTICE STREQUAL "material_NiO")
   set(DCA_LATTICE_TYPE "dca::phys::models::material_lattice<dca::phys::models::Material::NiO_unsymmetric, dca::phys::domains::${DCA_POINT_GROUP}>")
   set(DCA_LATTICE_INCLUDE
       "dca/phys/models/material_hamiltonians/material_lattice.hpp")
   set(DCA_MODEL_IS_MATERIAL_LATTICE ON CACHE BOOL "is the model a material lattice")
+
 elseif (DCA_LATTICE STREQUAL "material_FeSn")
   set(DCA_LATTICE_TYPE "dca::phys::models::material_lattice<dca::phys::models::Material::FeSn, dca::phys::domains::${DCA_POINT_GROUP}>")
   set(DCA_LATTICE_INCLUDE
       "dca/phys/models/material_hamiltonians/material_lattice.hpp")
   set(DCA_MODEL_IS_MATERIAL_LATTICE ON CACHE BOOL "is the model a material lattice")
+
 else()
   message(FATAL_ERROR "Please set DCA_LATTICE to a valid option: bilayer | La3Ni2O7_bilayer | square | triangular | Kagome | hund | twoband_Cu | threeband | Rashba_Hubbard | Moire_Hubbard | FeAs | material_NiO | material_FeSn.")
 endif()

cmake/dca_testing.cmake

@@ -16,6 +16,7 @@ if(DCA_HAVE_HPX)
   set(test_thread_option HPX)
 endif()
 
+
 # Adds a test written with Google Test.
 #
 # dca_add_gtest(name
@@ -36,7 +37,7 @@ endif()
 function(dca_add_gtest name)
   set(options FAST EXTENSIVE STOCHASTIC PERFORMANCE GTEST_MAIN GTEST_MPI_MAIN THREADED MPI CUDA CUDA_MPI)
   set(oneValueArgs MPI_NUMPROC)
-  set(multiValueArgs INCLUDE_DIRS SOURCES LIBS)
+  set(multiValueArgs INCLUDE_DIRS SOURCES LIBS CUSTOM_SOURCE TEST_DEFINES)
   cmake_parse_arguments(DCA_ADD_GTEST "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
   # FAST, EXTENSIVE and PERFORMANCE are mutually exclusive.
@@ -47,7 +48,7 @@ function(dca_add_gtest name)
       (DCA_ADD_GTEST_STOCHASTIC AND DCA_ADD_GTEST_EXTENSIVE) OR
       (DCA_ADD_GTEST_STOCHASTIC AND DCA_ADD_GTEST_PERFORMANCE))
     message(FATAL_ERROR "Incorrect use of dca_add_gtest.\n
-                         dca_add_gtest(name\n
+                         dca_add_gtest_impl (name src_file compile_definitions \n
                                        [FAST | EXTENSIVE | STOCHASTIC | PERFORMANCE]\n
                                        [GTEST_MAIN]\n
                                        [THREADED]\n
@@ -97,7 +98,7 @@ function(dca_add_gtest name)
   IF (DCA_ADD_GTEST_CUDA_MPI AND NOT DCA_HAVE_GPU_AWARE_MPI)
     return()
   endif()
-  
+
   # Right now we're only testing GPU distributed code on one node so its pointless
   # without more than one GPU per node.
   if (DCA_ADD_GTEST_CUDA_MPI AND DCA_HAVE_GPU_AWARE_MPI AND (DCA_TEST_GPU_COUNT LESS 2) )
@@ -112,9 +113,15 @@ function(dca_add_gtest name)
     set(DCA_ADD_GTEST_SOURCES ${PROJECT_SOURCE_DIR}/test/dca_gtest_main_mpi.cpp ${DCA_ADD_GTEST_SOURCES})
   endif()
 
-  add_executable(${name} ${name}.cpp ${DCA_ADD_GTEST_SOURCES})
-
+  if (DCA_ADD_GTEST_CUSTOM_SOURCE)
+    add_executable(${name} ${DCA_ADD_GTEST_CUSTOM_SOURCE} ${DCA_ADD_GTEST_SOURCES})
+  else ()
+    add_executable(${name} ${name}.cpp ${DCA_ADD_GTEST_SOURCES})
+  endif()
   target_compile_definitions(${name} PRIVATE DCA_SOURCE_DIR=\"${PROJECT_SOURCE_DIR}\")
+  if (DCA_ADD_GTEST_TEST_DEFINES)
+    target_compile_definitions(${name} PRIVATE THIS_TEST_DEFINES=${DCA_ADD_GTEST_TEST_DEFINES})
+  endif()
 
   # this is hacky but allows continued use of DCA_THREADING_LIBS
   # if (DCA_ADD_GTEST_LIBS MATCHES "parallel_hpx")
@@ -182,7 +189,7 @@ function(dca_add_gtest name)
     target_compile_definitions(${name} PUBLIC DCA_HAVE_HPX)
     target_link_libraries(${name} PUBLIC HPX::hpx HPX::wrap_main)
   endif()
-  
+
   target_include_directories(${name} PRIVATE
     ${gtest_SOURCE_DIR}/include
     ${DCA_ADD_GTEST_INCLUDE_DIRS})
@@ -239,5 +246,3 @@ function(dca_add_perftest name)
 
   target_compile_definitions(${name} PRIVATE DCA_SOURCE_DIR=\"${PROJECT_SOURCE_DIR}\")
 endfunction()
-
-

include/dca/function/util/difference.hpp

@@ -64,16 +64,16 @@ Difference difference(const function<Scalartype1, Dmn1, DT1>& f1,
   l2_error = std::sqrt(l2_error / l2);
   linf_error /= linf;
 
-
-
   return Difference{l1_error, l2_error, linf_error};
 }
 
 // Returns the l1, l2, and l_inf relative (w.r.t. f1) differences of f1 and f2.
 template <typename Scalartype1, typename Scalartype2, class Dmn1, class Dmn2>
 Difference difference(const function<Scalartype1, Dmn1>& f1, const function<Scalartype2, Dmn2>& f2) {
   if (f1.size() != f2.size())
-    throw(std::logic_error("The two functions have different size."));
+    throw(std::logic_error("The two functions have different sizes. f1.size() (" +
+                           std::to_string(f1.size()) + ") == f2.size() (" +
+                           std::to_string(f2.size()) + ")!\n"));
 
   double l1 = 0.;
   double l2 = 0.;

include/dca/math/function_transform/special_transforms/space_transform_2D.hpp

@@ -30,20 +30,18 @@ namespace math {
 namespace transform {
 // dca::math::transform::
 
-template <class RDmn, class KDmn, typename Scalar = double>
+template <class RDmn, class KDmn, class BDMN, class SPDMN, typename Scalar = double>
 class SpaceTransform2D {
 protected:
   using Complex = dca::util::ComplexAlias<Scalar>;
-  using BDmn = func::dmn_0<phys::domains::electron_band_domain>;
-  using SDmn = func::dmn_0<phys::domains::electron_spin_domain>;
+  using BDmn = BDMN;   // func::dmn_0<phys::domains::electron_band_domain>;
+  using SDmn = SPDMN;  // func::dmn_0<phys::domains::electron_spin_domain>;
 
 public:
   // Apply the 2D Fourier transform defined as
-  // f(k1, b1, k2, b2) = \sum_{r1, r2} Exp[i (k1 (r1 + a[b1]) - k2 (r2 + a[b2])] f(r1, b1, r2, b2) / Nc,
-  // where a[b] is the displacement vector associated with each band,
-  // and rearrange the output domains.
-  // In/Out: f_input. The input is overwritten with a partial result.
-  // Out: f_output
+  // f(k1, b1, k2, b2) = \sum_{r1, r2} Exp[i (k1 (r1 + a[b1]) - k2 (r2 + a[b2])] f(r1, b1, r2, b2) /
+  // Nc, where a[b] is the displacement vector associated with each band, and rearrange the output
+  // domains. In/Out: f_input. The input is overwritten with a partial result. Out: f_output
   template <class W1Dmn, class W2Dmn>
   static void execute(
       func::function<Complex, func::dmn_variadic<RDmn, RDmn, BDmn, BDmn, SDmn, W1Dmn, W2Dmn>>& f_input,
@@ -55,16 +53,15 @@ class SpaceTransform2D {
     return SpaceToMomentumTransform<RDmn, KDmn>::hasPhaseFactor();
   }
   static const auto& getPhaseFactors();
-protected:
-
 
+protected:
 };
 
-template <class RDmn, class KDmn, typename Scalar>
+template <class RDmn, class KDmn, class BDMN, class SPDMN, typename Scalar>
 template <class W1Dmn, class W2Dmn>
-void SpaceTransform2D<RDmn, KDmn, Scalar>::execute(
-    func::function<Complex, func::dmn_variadic<RDmn, RDmn, BDmn, BDmn, SDmn, W1Dmn, W2Dmn>>& f_input,
-    func::function<Complex, func::dmn_variadic<BDmn, BDmn, SDmn, KDmn, KDmn, W1Dmn, W2Dmn>>& f_output) {
+void SpaceTransform2D<RDmn, KDmn, BDMN, SPDMN, Scalar>::execute(
+    func::function<Complex, func::dmn_variadic<RDmn, RDmn, BDMN, BDMN, SPDMN, W1Dmn, W2Dmn>>& f_input,
+    func::function<Complex, func::dmn_variadic<BDMN, BDMN, SPDMN, KDmn, KDmn, W1Dmn, W2Dmn>>& f_output) {
   assert(SDmn::dmn_size() == 2);
   const int nc = RDmn::dmn_size();
   linalg::Matrix<Complex, linalg::CPU> tmp(nc);
@@ -80,28 +77,32 @@ void SpaceTransform2D<RDmn, KDmn, Scalar>::execute(
             linalg::MatrixView<Complex, linalg::CPU> f_r_r(&f_input(0, 0, b1, b2, s, w1, w2), nc);
 
             // f(k1,k2) = \sum_{r1, r2} exp(i(k1 * r1 - k2 *r2)) f(r1, r2) / Nc
-            linalg::matrixop::gemm(T, f_r_r,tmp);
+            linalg::matrixop::gemm(T, f_r_r, tmp);
             linalg::matrixop::gemm('N', 'C', norm, tmp, T, Complex(0), f_r_r);
 
             // f(k1, k2) *= Exp[i (k1 a[b1] - k2 a[b2])]
             for (int k2 = 0; k2 < nc; ++k2)
-              for (int k1 = 0; k1 < nc; ++k1)
+              for (int k1 = 0; k1 < nc; ++k1) {
+                assert(b1 < BDMN::dmn_size());
                 f_output(b1, b2, s, k1, k2, w1, w2) =
                     f_r_r(k1, k2) * phase_factors(b1, k1) * std::conj(phase_factors(b2, k2));
+              }
           }
 }
 
-template <class RDmn, class KDmn, typename Scalar>
-const linalg::Matrix<dca::util::ComplexAlias<Scalar>, linalg::CPU>& SpaceTransform2D<RDmn, KDmn, Scalar>::get_T_matrix() {
+template <class RDmn, class KDmn, class BDMN, class SPDMN, typename Scalar>
+const linalg::Matrix<dca::util::ComplexAlias<Scalar>, linalg::CPU>& SpaceTransform2D<
+    RDmn, KDmn, BDMN, SPDMN, Scalar>::get_T_matrix() {
   auto initialize_T_matrix = []() {
     assert(RDmn::dmn_size() == KDmn::dmn_size());
     linalg::Matrix<Complex, linalg::CPU> T(RDmn::dmn_size());
     for (int j = 0; j < RDmn::dmn_size(); ++j) {
       const auto& r = RDmn::parameter_type::get_elements()[j];
       for (int i = 0; i < KDmn::dmn_size(); ++i) {
         const auto& k = KDmn::parameter_type::get_elements()[i];
-	using Real = dca::util::RealAlias<Scalar>;
-	auto temp_exp = std::exp(dca::util::ComplexAlias<Real>{0, static_cast<Real>(util::innerProduct(k, r))});
+        using Real = dca::util::RealAlias<Scalar>;
+        auto temp_exp =
+            std::exp(dca::util::ComplexAlias<Real>{0, static_cast<Real>(util::innerProduct(k, r))});
         T(i, j) = typename decltype(T)::ValueType{temp_exp.real(), temp_exp.imag()};
       }
     }
@@ -112,9 +113,9 @@ const linalg::Matrix<dca::util::ComplexAlias<Scalar>, linalg::CPU>& SpaceTransfo
   return T;
 }
 
-template <class RDmn, class KDmn, typename Scalar>
-const auto& SpaceTransform2D<RDmn, KDmn, Scalar>::getPhaseFactors() {
-  static func::function<Complex, func::dmn_variadic<BDmn, KDmn>> phase_factors("Phase factors.");
+template <class RDmn, class KDmn, class BDMN, class SPDMN, typename Scalar>
+const auto& SpaceTransform2D<RDmn, KDmn, BDMN, SPDMN, Scalar>::getPhaseFactors() {
+  static func::function<Complex, func::dmn_variadic<BDMN, KDmn>> phase_factors("Phase factors.");
   using Real = dca::util::RealAlias<Scalar>;
   static std::once_flag flag;
 
@@ -127,10 +128,10 @@ const auto& SpaceTransform2D<RDmn, KDmn, Scalar>::getPhaseFactors() {
     for (int k = 0; k < KDmn::dmn_size(); ++k) {
       const auto& k_vec = KDmn::get_elements()[k];
       for (int b = 0; b < BDmn::dmn_size(); ++b) {
-	// Scalar could be cuComplex or cuDoubleComplex so...
-	std::complex<Real> temp_phase{0., static_cast<Real>(util::innerProduct(k_vec, a_vecs[b]))};
-	temp_phase = std::exp(temp_phase);
-	phase_factors(b,k) = Complex{temp_phase.real(), temp_phase.imag()};
+        // Scalar could be cuComplex or cuDoubleComplex so...
+        std::complex<Real> temp_phase{0., static_cast<Real>(util::innerProduct(k_vec, a_vecs[b]))};
+        temp_phase = std::exp(temp_phase);
+        phase_factors(b, k) = Complex{temp_phase.real(), temp_phase.imag()};
       }
     }
   });