Commit f2afa19f authored by Doak, Peter W.'s avatar Doak, Peter W.
Browse files

added rashba statistical test

parent 768de824

test/integration/statistical_tests/rashba_lattice/rashba_lattice_setup.hpp

+24 −10
Original line number Diff line number Diff line
@@ -35,7 +35,6 @@ 
#include "dca/profiling/null_profiler.hpp"

#include "dca/util/git_version.hpp"

#include "dca/util/modules.hpp"

#include "dca/testing/dca_mpi_test_environment.hpp"

#include "dca/testing/minimalist_printer.hpp"



namespace dca {
@@ -50,7 +49,7 @@ using dca::linalg::CPU; 
const std::string test_directory =

    DCA_SOURCE_DIR "/test/integration/statistical_tests/rashba_lattice/";



constexpr char default_input[] = DCA_SOURCE_DIR "rashba_lattice_stat_test.json";

const std::string default_input(test_directory + "rashba_lattice_stat_test.json");



using LatticeRashba = phys::models::RashbaHubbard<phys::domains::no_symmetry<2>>;
@@ -58,14 +57,13 @@ using dca::math::util::cutFrequency; 


using dca::linalg::DeviceType;



template <typename Scalar, DeviceType DEVICE, class Lattice = LatticeRashba,

          ClusterSolverId solver_name = ClusterSolverId::CT_AUX,

          const char* input_name = default_input, DistType DT = DistType::NONE>

template <typename Scalar, DeviceType DEVICE, class CONCURRENCY, class Lattice = LatticeRashba,

          ClusterSolverId solver_name = ClusterSolverId::CT_AUX, DistType DT = DistType::NONE>

struct IntegrationSetupBare {

  using LatticeType = Lattice;

  using Model = phys::models::TightBindingModel<Lattice>;

  using RandomNumberGenerator = dca::math::random::StdRandomWrapper<std::mt19937_64>;

  using Concurrency = DcaMpiTestEnvironment::ConcurrencyType;

  using Concurrency = CONCURRENCY;

  using Parameters =

      phys::params::Parameters<Concurrency, Threading, profiling::NullProfiler, Model,

                               RandomNumberGenerator, solver_name,
@@ -86,7 +84,6 @@ struct IntegrationSetupBare { 
    using type = dca::phys::solver::CtintClusterSolver<DEVICE, PARAMETERS, true>;

  };





  using QMCSolver = typename ClusterSolverSelector<solver_name, Parameters>::type;

  using ThreadedSolver = dca::phys::solver::StdThreadQmciClusterSolver<QMCSolver>;
@@ -107,13 +104,30 @@ struct IntegrationSetupBare { 
  using SigmaDomain = dca::math::util::SigmaDomain<dca::math::util::details::Kdmn<>>;

  using CovarianceDomain = dca::math::util::CovarianceDomain<dca::math::util::details::Kdmn<>>;



  Concurrency concurrency_;

  Concurrency* concurrency_;

  Parameters parameters_;

  std::unique_ptr<Data> data_;



  IntegrationSetupBare() : concurrency_(0, nullptr), parameters_("", concurrency_) {}

  IntegrationSetupBare(Concurrency* concurrency, const std::string& input_file = default_input)

      : concurrency_(concurrency), parameters_("", *concurrency_) {

    try {

      parameters_.template read_input_and_broadcast<io::JSONReader>(input_file);

    }

    catch (const std::exception& r_w) {

      throw std::runtime_error(r_w.what());

    }

    catch (...) {

      throw std::runtime_error("Input parsing failed!");

    }

    parameters_.update_model();



    parameters_.update_domains();



    data_ = std::make_unique<Data>(parameters_);

    data_->initialize();

  }



  void SetUp() {

  void SetUp(const std::string& input_name = default_input) {

    try {

      parameters_.template read_input_and_broadcast<io::JSONReader>(input_name);

    }

test/integration/statistical_tests/rashba_lattice/test_rashba_lattice.cpp

+57 −38
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <complex>

#include <iostream>

#include <string>

#include <type_traits>

#include <dca/function/util/difference.hpp>



#include "dca/testing/gtest_h_w_warning_blocking.h"
@@ -47,74 +48,82 @@ using McOptions = MockMcOptions<Scalar>; 
#include "dca/phys/models/tight_binding_model.hpp"

#include "dca/phys/parameters/parameters.hpp"

#include "dca/profiling/null_profiler.hpp"

#include "dca/testing/dca_mpi_test_environment.hpp"

#include "dca/testing/minimalist_printer.hpp"

#include "dca/util/git_version.hpp"

#include "dca/util/modules.hpp"

#include "rashba_lattice_setup.hpp"

#include "dca/math/statistical_testing/function_cut.hpp"

#include "dca/math/statistical_testing/statistical_testing.hpp"

#include "dca/testing/dca_mpi_test_environment.hpp"



constexpr bool update_baseline = false;



#ifdef DCA_HAVE_ADIOS2

adios2::ADIOS* adios_ptr;

#include "dca/io/adios2/adios2_reader.hpp"

#include "dca/io/adios2/adios2_writer.hpp"

adios2::ADIOS* adios2_ptr;

#endif



#ifdef DCA_HAVE_MPI

#include "dca/parallel/mpi_concurrency/mpi_concurrency.hpp"

dca::parallel::MPIConcurrency* concurrency_ptr;

#else

#include "dca/parallel/no_concurrency/no_concurrency.hpp"

dca::parallel::NoConcurrency* concurrency_ptr;

#endif

dca::testing::DcaMpiTestEnvironment* dca_test_env;



// #ifdef DCA_HAVE_MPI

// #include "dca/parallel/mpi_concurrency/mpi_concurrency.hpp"

// dca::parallel::MPIConcurrency* concurrency_ptr;

// #else

// #include "dca/parallel/no_concurrency/no_concurrency.hpp"

// dca::parallel::NoConcurrency* concurrency_ptr;

// #endif



using dca::linalg::DeviceType;



template <typename SCALAR>

struct RashbaLatticeIntegrationTest : public ::testing::Test {

  using SCALAR = std::complex<double>;

  template <DeviceType DEVICE>



  using IntegrationSetupBare =

      dca::testing::IntegrationSetupBare<SCALAR, DEVICE, dca::testing::LatticeRashba,

    dca::testing::IntegrationSetupBare<SCALAR, DEVICE, dca::testing::DcaMpiTestEnvironment::ConcurrencyType, dca::testing::LatticeRashba,

                                         dca::ClusterSolverId::CT_AUX>;

  virtual void SetUp() {

    host_setup.SetUp();

    gpu_setup.SetUp();

  virtual void reallySetUp(Concurrency* concurrency) {

    host_setup = std::make_unique<IntegrationSetupBare<dca::linalg::CPU>>(concurrency);

    gpu_setup = std::make_unique<IntegrationSetupBare<dca::linalg::GPU>>(concurrency);

  }



  virtual void TearDown() {}

  IntegrationSetupBare<dca::linalg::CPU> host_setup;

  IntegrationSetupBare<dca::linalg::GPU> gpu_setup;



  using CPUSetup = IntegrationSetupBare<dca::linalg::CPU>;

  using GPUSetup = IntegrationSetupBare<dca::linalg::GPU>;

  

  std::unique_ptr<CPUSetup> host_setup;

  std::unique_ptr<GPUSetup> gpu_setup;

};



using TestTypes = ::testing::Types<std::complex<double>>;

TYPED_TEST_CASE(RashbaLatticeIntegrationTest, TestTypes);



TYPED_TEST(RashbaLatticeIntegrationTest, SelfEnergy) {

  if (concurrency_ptr->id() == concurrency_ptr->first()) {

TEST_F(RashbaLatticeIntegrationTest, SelfEnergy) {

  auto& concurrency = dca_test_env->concurrency;

  if (concurrency.id() == concurrency.first()) {

    dca::util::GitVersion::print();

    dca::util::Modules::print();

  }



  dca::phys::DcaLoopData<decltype(this->gpu_setup.parameters_)> dca_loop_data_gpu;

  this->reallySetUp(&concurrency);

  

  dca::phys::DcaLoopData<decltype(this->gpu_setup->parameters_)> dca_loop_data_gpu;



  // dca::func::function<std::complex<double>, dca::func::dmn_variadic<nu, nu, k_DCA, w> >

  //   Sigma_ED(dca_data_imag.Sigma);



  // Do one QMC iteration

  using QMCSolverGPU = typename decltype(this->gpu_setup)::ThreadedSolver;

  QMCSolverGPU qmc_solver_gpu(this->gpu_setup.parameters_, *(this->gpu_setup.data_), nullptr);

  using QMCSolverGPU = typename RashbaLatticeIntegrationTest::GPUSetup::ThreadedSolver;

  QMCSolverGPU qmc_solver_gpu(this->gpu_setup->parameters_, *(this->gpu_setup->data_), nullptr);

  qmc_solver_gpu.initialize(0);

  qmc_solver_gpu.integrate();

  qmc_solver_gpu.finalize(dca_loop_data_gpu);



  using NuDmn = typename decltype(this->gpu_setup)::NuDmn;

  using KDmnDCA = typename decltype(this->gpu_setup)::KDmnDCA;

  using WDmn = typename decltype(this->gpu_setup)::WDmn;

  using NuDmn =  RashbaLatticeIntegrationTest::GPUSetup::NuDmn;

  using KDmnDCA = RashbaLatticeIntegrationTest::GPUSetup::KDmnDCA;

  using WDmn = RashbaLatticeIntegrationTest::GPUSetup::WDmn;



  dca::func::function<std::complex<double>, dca::func::dmn_variadic<NuDmn, NuDmn, KDmnDCA, WDmn>> Sigma_QMC(

      this->gpu_setup.data_->Sigma);

      this->gpu_setup->data_->Sigma);



  // // Read QMC self-energy from check_data file and compare it with the newly

  // // computed QMC self-energy.
@@ -151,26 +160,36 @@ TYPED_TEST(RashbaLatticeIntegrationTest, SelfEnergy) { 
}



int main(int argc, char** argv) {

#ifdef DCA_HAVE_MPI

  // #ifdef DCA_HAVE_MPI

  //   dca::parallel::MPIConcurrency concurrency(argc, argv);

  //   concurrency_ptr = &concurrency;

  // #else

  //   dca::parallel::NoConcurrency concurrency(argc, argv);

  //   concurrency_ptr = &concurrency;

  // #endif

  ::testing::InitGoogleTest(&argc, argv);



  dca::parallel::MPIConcurrency concurrency(argc, argv);

  concurrency_ptr = &concurrency;

#else

  dca::parallel::NoConcurrency concurrency(argc, argv);

  concurrency_ptr = &concurrency;

#endif

  dca_test_env = new dca::testing::DcaMpiTestEnvironment(

      concurrency,  "rashba_lattice_stat_test.json");

  testing::AddGlobalTestEnvironment(dca_test_env);



  dca::linalg::util::initializeMagma();



#ifdef DCA_HAVE_ADIOS2

  // ADIOS expects MPI_COMM pointer or nullptr

  adios2::ADIOS adios("", concurrency_ptr->get(), false);

  adios_ptr = &adios;

  // std::string dummy("");

  // adios2::ADIOS adios(dummy, concurrency.get(), false);

  // adios2_ptr = &adios;

#endif

  ::testing::InitGoogleTest(&argc, argv);



  // ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners();

  ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners();

  // delete listeners.Release(listeners.default_result_printer());

  // listeners.Append(new dca::testing::MinimalistPrinter);

  if (dca_test_env->concurrency.id() != 0) {

    delete listeners.Release(listeners.default_result_printer());

    listeners.Append(new dca::testing::MinimalistPrinter);

  }



  int result = RUN_ALL_TESTS();

  return result;

test/unit/phys/dca_step/cluster_solver/shared_tools/accumulation/tp/tp_accumulator_complex_g0_gpu_test.cpp

+9 −9
Original line number Diff line number Diff line
@@ -134,8 +134,8 @@ TYPED_TEST(TpAccumulatorComplexG0GpuTest, Accumulate) { 
  // lattice_mapping_obj_host.execute(host_data->Sigma, host_data->Sigma_lattice_interpolated,

  //                                  host_data->Sigma_lattice_coarsegrained, host_data->Sigma_lattice);



  // LatticeMapSpType<ParametersGPU, k_DCA<ParametersGPU>, k_HOST<ParametersGPU>> lattice_mapping_obj_gpu(this->gpu_setup.parameters_);

  // auto& gpu_data = this->gpu_setup.data_;

  // LatticeMapSpType<ParametersGPU, k_DCA<ParametersGPU>, k_HOST<ParametersGPU>>

  // lattice_mapping_obj_gpu(this->gpu_setup.parameters_); auto& gpu_data = this->gpu_setup.data_;

  // lattice_mapping_obj_gpu.execute(gpu_data->Sigma, gpu_data->Sigma_lattice_interpolated,

  //                                 gpu_data->Sigma_lattice_coarsegrained, gpu_data->Sigma_lattice);

test/unit/phys/dca_step/cluster_solver/shared_tools/accumulation/tp/tp_accumulator_test_baseline.hdf5

(28 MiB)

File changed.

No diff preview for this file type.

View original file
View changed file