Unverified Commit 975c2893 authored by Peter Doak's avatar Peter Doak Committed by GitHub
Browse files

Merge pull request #293 from CompFUSE/s_of_q_omega_demo 

bringing master up to date with active development.
parents 3f6271d0 673686eb

CMakeLists.txt

+4 −2
Original line number Diff line number Diff line
@@ -110,13 +110,14 @@ dca_write_haves_definitions_file() 


install(DIRECTORY ${CMAKE_BINARY_DIR}/include/dca/config DESTINATION include/dca)



include(dca_check_stdlib)

message("std::filesystem resolved")



################################################################################

# External libraries

include(dca_external_libs)  # Sets DCA_EXTERNAL_LIBS and DCA_EXTERNAL_INCLUDE_DIRS.





include(dca_check_stdlib)

message("std::filesystem resolved")



################################################################################

# Include directories
@@ -173,6 +174,7 @@ set(DCA_LIBS 
  ${DCA_CONCURRENCY_LIB}

  ${DCA_THREADING_LIBS}

  lapack

  models

)

  

set(SYSTEM_GPU_COUNT 0)

applications/analysis/CMakeLists.txt

+17 −7
Original line number Diff line number Diff line
@@ -3,15 +3,25 @@ 
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})

    endif()



    target_link_libraries(main_analysis PUBLIC signals ${DCA_LIBS} simplex_gm_rule)



  if (DCA_WITH_CUDA)

    target_link_libraries(main_dca PRIVATE CUDA::cublas)

  message("DCA_MODEL_IS_MATERIAL_LATTICE ${DCA_MODEL_IS_MATERIAL_LATTICE}")

  if (DCA_LATTICE STREQUAL "square")

    #new development of exanded q chi_q_omega

    add_executable(chi_q_omega chi_q_omega.cpp)

    target_compile_definitions(chi_q_omega PUBLIC DCA_HAS_SOFQOMEGA)

    target_include_directories(chi_q_omega PRIVATE ${DCA_INCLUDE_DIRS})



    if (DCA_HAVE_GPU)

      target_link_libraries(chi_q_omega PRIVATE ${DCA_GPU_LIBS})

    endif()



  if (DCA_WITH_HIP)

    target_compile_definitions(main_dca PUBLIC DCA_HAVE_HIP)

    target_link_libraries(main_dca PRIVATE hip::host roc::hipblas)

    target_link_libraries(chi_q_omega PUBLIC signals ${DCA_LIBS} simplex_gm_rule)



  endif()



  target_link_libraries(main_analysis ${DCA_LIBS})

endif()

applications/analysis/chi_q_omega.cpp

0 → 100644
+131 −0
Original line number Diff line number Diff line 
// Copyright (C) 2022 ETH Zurich

// Copyright (C) 2022 UT-Battelle, LLC

// All rights reserved.

//

// See LICENSE for terms of usage.

// See CITATION.md for citation guidelines, if DCA++ is used for scientific publications.

//

// Author: Peter Doak (doakpw@ornl.gov)

//

// Main file for generating dynamic susceptibility (Chi''_Q_omega) from a DCA++ G4

// Usage: ./chi_q_omega input_file.json



#include <iostream>

#include <string>



// Defines Concurrency, Threading, ParametersType, DcaData, and BseSolver.

#include "dca/config/analysis.hpp"

#include "dca/config/cmake_options.hpp"

#include "dca/io/json/json_reader.hpp"

#include "dca/util/git_version.hpp"

#include "dca/util/modules.hpp"

#include "dca/io/writer.hpp"

#include "dca/io/reader.hpp"

#include "dca/io/io_types.hpp"



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

  if (argc < 2) {

    std::cout << "Usage: " << argv[0] << " input_file.json" << std::endl;

    return -1;

  }



  std::string input_file(argv[1]);



  Concurrency concurrency(argc, argv);



  // Print some info.

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

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

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

    dca::config::CMakeOptions::print();



#ifdef DCA_HAVE_GPU

    dca::linalg::util::printInfoDevices();

#endif  // DCA_HAVE_GPU



    std::cout

        << "\n"

        << "********************************************************************************\n"

        << "**********                      DCA(+) S(q,omega)  Calculation        **********\n"

        << "********************************************************************************\n"

        << "\n"

        << "Start time : " << dca::util::print_time() << "\n"

        << "\n"

        << "MPI-world set up: " << concurrency.number_of_processors() << " processes."

        << "\n"

        << std::endl;

  }



#ifdef DCA_HAVE_GPU

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

#endif  // DCA_HAVE_GPU



  // Create the parameters object from the input file.

  ParametersType parameters(dca::util::GitVersion::string(), concurrency);

  parameters.read_input_and_broadcast<dca::io::JSONReader>(input_file);

  parameters.update_model();

  parameters.update_domains();



  // Create and initialize the DCA data object and read the output of the DCA(+) calculation.

  DcaDataType dca_data(parameters);

  dca_data.initialize();



#ifdef DCA_HAVE_ADIOS2

  adios2::ADIOS adios;



  if (dca::io::stringToIOType(parameters.get_output_format()) == dca::io::IOType::ADIOS2) {

    int rank = concurrency.id();

    std::cout << "\nProcessor " << concurrency.id() << " is writing data." << std::endl;

    dca::io::Writer writer(adios, concurrency, parameters.get_output_format(), true);

    std::string filename_bse(parameters.get_directory() + parameters.getAppropriateFilenameAnalysis());

    writer.open_file(filename_bse);



    std::string filename(parameters.get_directory() + parameters.get_filename_dca());

    dca::io::Reader reader(concurrency, parameters.get_output_format());

    reader.open_file(filename);

    auto& adios2_reader = std::get<dca::io::ADIOS2Reader<Concurrency>>(reader.getUnderlying());

    std::size_t step_count = adios2_reader.getStepCount();



    int ranks = concurrency.get_size();



    int current_step = 0;



    while (true) {

      if (current_step >= step_count - 1)

        break;      

      writer.begin_step();

      int got_step_num = -1;

      for (int ir = 0; ir < ranks; ++ir) {

	// cut off the last weird step dca is saving

        if (current_step >= step_count - 1)

          goto end_steps;

        adios2_reader.begin_step();

        if (rank == ir) {

          dca_data.read(reader);

          got_step_num = current_step;

        }

        adios2_reader.end_step();

        ++current_step;

      }

      if (got_step_num >= 0) {

        std::cout << "Rank " << rank << " working on step " << got_step_num << '\n';

        BseSolverExt bse_solver_ext(parameters, dca_data);

        bse_solver_ext.calculateSusceptibilities();

        writer.open_group("step_" + std::to_string(got_step_num));

        bse_solver_ext.write(writer);

        writer.close_group();

        got_step_num = -1;

      }

    end_steps:

      writer.end_step();

    }

    writer.begin_step();

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

      parameters.write(writer);

    writer.end_step();

    writer.close_file();

  }

#endif

  std::cout << "\nFinish time: " << dca::util::print_time() << "\n" << std::endl;

  return 0;

}

applications/analysis/main_analysis.cpp

+30 −10
Original line number Diff line number Diff line
@@ -61,19 +61,39 @@ int main(int argc, char** argv) { 
  dca_data.initialize();

#ifdef DCA_HAVE_ADIOS2

  adios2::ADIOS adios;



  if (dca::io::stringToIOType(parameters.get_output_format()) == dca::io::IOType::ADIOS2) {

    int rank = concurrency.id();

    std::cout << "\nProcessor " << concurrency.id() << " is writing data." << std::endl;

    dca::io::Writer writer(adios, concurrency, parameters.get_output_format(), true);

    std::string filename_bse(parameters.get_directory() + parameters.getAppropriateFilenameAnalysis());

    writer.open_file(filename_bse);



    dca_data.read(adios, parameters.get_directory() + parameters.get_filename_dca());

#else

  dca_data.read(parameters.get_directory() + parameters.get_filename_dca());

    BseSolverType bse_solver(parameters, dca_data);

    bse_solver.calculateSusceptibilities();



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

      std::cout << "\n Writing ADIOS2 output\n";

      writer.begin_step();

      bse_solver.write(writer);

      writer.end_step();

      std::cout << "\nFinish time: " << dca::util::print_time() << "\n" << std::endl;

    }

  }

  else

#endif

  {

    dca_data.read(parameters.get_directory() + parameters.get_filename_dca());

    BseSolverType bse_solver(parameters, dca_data);

    bse_solver.calculateSusceptibilities();



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

      std::cout << "\nProcessor " << concurrency.id() << " is writing data." << std::endl;

      bse_solver.write();



      std::cout << "\nFinish time: " << dca::util::print_time() << "\n" << std::endl;

    }

  }



  return 0;

}

applications/cluster_solver_check/CMakeLists.txt

+4 −3
Original line number Diff line number Diff line
@@ -3,9 +3,10 @@ 
if (DCA_BUILD_CLUSTER_SOLVER_CHECK)

  add_executable(cluster_solver_check cluster_solver_check.cpp)

  target_include_directories(cluster_solver_check PRIVATE ${DCA_INCLUDE_DIRS})

  target_link_libraries(cluster_solver_check  PRIVATE ${DCA_LIBS} statistical_testing)

  target_link_libraries(cluster_solver_check PRIVATE ${DCA_LIBS} dca_hdf5 statistical_testing)



  if (DCA_WITH_CUDA)

    cuda_add_cublas_to_target(cluster_solver_check)

  if (DCA_HAVE_GPU)

    dca_gpu_runtime_link(cluster_solver_check)

    dca_gpu_blas_link(cluster_solver_check)

  endif()

endif()