Commit ce3d9542 authored by Cianciosa, Mark's avatar Cianciosa, Mark
Browse files

Merge branch 'piecewise' into 'main' 

Refactor code to reduce time needed to search for duplicate nodes. Add the...

See merge request !5
parents edfdacf0 885b5528

CMakeLists.txt

+13 −3
Original line number Diff line number Diff line
@@ -2,6 +2,16 @@ cmake_minimum_required (VERSION 3.21) 


project (rays CXX)



#-------------------------------------------------------------------------------

#  Build Options

#-------------------------------------------------------------------------------

option (USE_PCH "Enable the use of precompiled headers" ON)

    

#-------------------------------------------------------------------------------

#  Set the cmake module path.

#-------------------------------------------------------------------------------

set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH};${CMAKE_CURRENT_SOURCE_DIR}/cmake)



#-------------------------------------------------------------------------------

#  Setup build types

#-------------------------------------------------------------------------------
@@ -11,8 +21,6 @@ set_property (CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS 
              Sanitized

)



option (USE_REDUCE "Enable the graph reduction" ON)



#-------------------------------------------------------------------------------

#  GPU config

#-------------------------------------------------------------------------------
@@ -144,7 +152,9 @@ macro (add_test_target target) 
              COMMAND ${target}

    )



    if (${USE_PCH})

        target_precompile_headers (${target} REUSE_FROM xrays)

    endif ()

endmacro ()



add_subdirectory (graph_tests)

cmake/FindNetCDF.cmake

0 → 100644
+58 −0
Original line number Diff line number Diff line 
#[==[

Provides the following variables:



  * `NetCDF_FOUND`: Whether NetCDF was found or not.

  * `NetCDF_INCLUDE_DIRS`: Include directories necessary to use NetCDF.

  * `NetCDF_LIBRARIES`: Libraries necessary to use NetCDF.

  * `NetCDF_VERSION`: The version of NetCDF found.

  * `NetCDF::NetCDF`: A target to use with `target_link_libraries`.

#]==]



# Find it manually.

find_path (NetCDF_C_INCLUDE_DIR

           NAMES netcdf.h

           DOC "netcdf C include directories")

mark_as_advanced (NetCDF_C_INCLUDE_DIR)



find_library (NetCDF_C_LIBRARY

              NAMES netcdf

              DOC "netcdf C library")

mark_as_advanced (NetCDF_C_LIBRARY)



if (NetCDF_C_INCLUDE_DIR)

    file (STRINGS "${NetCDF_C_INCLUDE_DIR}/netcdf_meta.h" _netcdf_version_lines

          REGEX "#define[ \t]+NC_VERSION_(MAJOR|MINOR|PATCH|NOTE)")

    string (REGEX REPLACE ".*NC_VERSION_MAJOR *\([0-9]*\).*" "\\1" _netcdf_version_major "${_netcdf_version_lines}")

    string (REGEX REPLACE ".*NC_VERSION_MINOR *\([0-9]*\).*" "\\1" _netcdf_version_minor "${_netcdf_version_lines}")

    string (REGEX REPLACE ".*NC_VERSION_PATCH *\([0-9]*\).*" "\\1" _netcdf_version_patch "${_netcdf_version_lines}")

    string (REGEX REPLACE ".*NC_VERSION_NOTE *\"\([^\"]*\)\".*" "\\1" _netcdf_version_note "${_netcdf_version_lines}")

    set (NetCDF_VERSION "${_netcdf_version_major}.${_netcdf_version_minor}.${_netcdf_version_patch}${_netcdf_version_note}")

    unset (_netcdf_version_major)

    unset (_netcdf_version_minor)

    unset (_netcdf_version_patch)

    unset (_netcdf_version_note)

    unset (_netcdf_version_lines)

endif ()



include (FindPackageHandleStandardArgs)

find_package_handle_standard_args (NetCDF

                                   REQUIRED_VARS NetCDF_C_LIBRARY NetCDF_C_INCLUDE_DIR

                                   VERSION_VAR NetCDF_VERSION)



if (NetCDF_FOUND)

    set (NetCDF_INCLUDE_DIRS ${NetCDF_C_INCLUDE_DIR})

    set (NetCDF_LIBRARIES "${NetCDF_C_LIBRARY}")



    if (NOT TARGET NetCDF::NetCDF_C)

       add_library (NetCDF::NetCDF_C UNKNOWN IMPORTED)

       set_target_properties (NetCDF::NetCDF_C PROPERTIES

                              IMPORTED_LOCATION "${NetCDF_C_LIBRARY}"

                              INTERFACE_INCLUDE_DIRECTORIES ${NetCDF_C_INCLUDE_DIR})

    endif ()



    if (NOT TARGET NetCDF::NetCDF)

        add_library (NetCDF::NetCDF INTERFACE IMPORTED)

        target_link_libraries (NetCDF::NetCDF INTERFACE NetCDF::NetCDF_C)

        target_include_directories (NetCDF::NetCDF INTERFACE ${NetCDF_INCLUDE_DIRS})

    endif ()

endif ()

graph_driver/xrays.cpp

+51 −22
Original line number Diff line number Diff line
@@ -8,7 +8,6 @@ 
#include <thread>

#include <random>



#include "../graph_framework/backend.hpp"

#include "../graph_framework/solver.hpp"

#include "../graph_framework/timing.hpp"
@@ -33,15 +32,18 @@ static base solution(const base t) { 
int main(int argc, const char * argv[]) {

    START_GPU



    //typedef std::complex<double> base;

    //typedef double base;

    std::mutex sync;



    typedef float base;

    //typedef double base;

    //typedef std::complex<float> base;

    //typedef std::complex<double> base;



    const timeing::measure_diagnostic total("Total Time");



    const size_t num_times = 10000;

    //const size_t num_rays = 1;

    const size_t sub_steps = 1;

    const size_t num_steps = num_times/sub_steps;

    const size_t num_rays = 1000000;



    std::vector<std::thread> threads(0);
@@ -54,14 +56,12 @@ int main(int argc, const char * argv[]) { 
    }



    for (size_t i = 0, ie = threads.size(); i < ie; i++) {

        threads[i] = std::thread([num_times, num_rays] (const size_t thread_number,

        threads[i] = std::thread([num_times, num_rays, &sync] (const size_t thread_number,

                                                               const size_t num_threads) -> void {

            const size_t local_num_rays = num_rays/num_threads

                                        + std::min(thread_number, num_rays%num_threads);



            std::mt19937_64 engine((thread_number + 1)*static_cast<uint64_t> (std::chrono::system_clock::to_time_t(std::chrono::system_clock::now())));

            std::uniform_real_distribution<base> real_dist(0.6, 1.0);

            std::normal_distribution<base> norm_dist(600.0, 10.0);

            std::uniform_int_distribution<size_t> int_dist(0, local_num_rays - 1);

            

            auto omega = graph::variable<base> (local_num_rays, "\\omega");
@@ -76,30 +76,57 @@ int main(int argc, const char * argv[]) { 
            t->set(static_cast<base> (0.0));



//  Inital conditions.

            if constexpr (jit::is_complex<base> ()) {

                if constexpr (jit::is_float<base> ()) {

                    std::normal_distribution<float> norm_dist(static_cast<float> (1000.0), static_cast<float> (10.0));

                    for (size_t j = 0; j < local_num_rays; j++) {

                        omega->set(j, static_cast<base> (norm_dist(engine)));

                    }

                } else {

                    std::normal_distribution<double> norm_dist(static_cast<double> (1000.0), static_cast<double> (10.0));

                    for (size_t j = 0; j < local_num_rays; j++) {

                        omega->set(j, static_cast<base> (norm_dist(engine)));

                    }

                }

            } else {

                std::normal_distribution<base> norm_dist(static_cast<base> (1000.0), static_cast<base> (10.0));

                for (size_t j = 0; j < local_num_rays; j++) {

                omega->set(j, norm_dist(engine));

                    omega->set(j, static_cast<base> (norm_dist(engine)));

                }

            }



            x->set(static_cast<base> (0.0));

            x->set(static_cast<base> (1.5));

            //x->set(static_cast<base> (0.0));

            y->set(static_cast<base> (0.0));

            z->set(static_cast<base> (0.0));

            kx->set(static_cast<base> (600.0));

            kx->set(static_cast<base> (2000.0));

            //kx->set(static_cast<base> (600.0));

            ky->set(static_cast<base> (0.0));

            kz->set(static_cast<base> (0.0));



            auto eq = equilibrium::make_slab_density<base> ();



            auto eq = equilibrium::make_efit<base> (NC_FILE, sync);

            //auto eq = equilibrium::make_slab_density<base> ();

            //auto eq = equilibrium::make_no_magnetic_field<base> ();



            //const base endtime = static_cast<base> (4.0);

            const base endtime = static_cast<base> (100.0);

            const base dt = endtime/static_cast<base> (num_times);



            //auto dt_var = graph::variable(num_rays, static_cast<base> (dt), "dt");



            //solver::split_simplextic<dispersion::bohm_gross<base>>

            //solver::rk4<dispersion::bohm_gross<base>>

            //solver::adaptive_rk4<dispersion::bohm_gross<base>>

            //solver::rk4<dispersion::simple<base>>

            //solver::rk4<dispersion::ordinary_wave<base>>

            //solver::rk4<dispersion::extra_ordinary_wave<base>>

            solver::rk4<dispersion::cold_plasma<base>>

                solve(omega, kx, ky, kz, x, y, z, t, 60.0/num_times, eq);

            solve.init(kx);

            solver::rk4<dispersion::extra_ordinary_wave<base>>

            //solver::rk4<dispersion::cold_plasma<base>>

            //solver::adaptive_rk4<dispersion::ordinary_wave<base>>

                solve(omega, kx, ky, kz, x, y, z, t, dt, eq);

                //solve(omega, kx, ky, kz, x, y, z, t, dt_var, eq);

            solve.init(omega);

            solve.compile();

            if (thread_number == 0) {

            if (thread_number == 0 && false) {

                solve.print_dispersion();

                std::cout << std::endl;

                solve.print_dkxdt();
@@ -121,12 +148,14 @@ int main(int argc, const char * argv[]) { 
                std::cout << "Omega " << omega->evaluate().at(sample) << std::endl;

            }



            for (size_t j = 0; j < num_times; j++) {

            for (size_t j = 0; j < num_steps; j++) {

                if (thread_number == 0) {

                    solve.print(sample);

                }

                for(size_t k = 0; k < sub_steps; k++) {

                    solve.step();

                }

            }



            if (thread_number == 0) {

                solve.print(sample);

graph_framework.xcodeproj/project.pbxproj

+243 −25

File changed.

Preview size limit exceeded, changes collapsed.

graph_framework/CMakeLists.txt

+22 −17
Original line number Diff line number Diff line 
find_package (NetCDF MODULE REQUIRED)



add_library (rays INTERFACE)

target_compile_features (rays

                         INTERFACE
@@ -7,9 +9,9 @@ target_compile_features (rays 
target_compile_definitions (rays

                            INTERFACE

                            $<$<CONFIG:Release>:NDEBUG>

                            $<$<BOOL:${USE_REDUCE}>:USE_REDUCE>

                            $<$<PLATFORM_ID:Darwin>:CXX="${CMAKE_CXX_COMPILER} -isysroot ${CMAKE_OSX_SYSROOT}">

                            $<$<PLATFORM_ID:Linux>:CXX="${CMAKE_CXX_COMPILER}">

                            NC_FILE="${CMAKE_CURRENT_SOURCE_DIR}/../graph_tests/efit.nc"

)

target_include_directories (rays

                            INTERFACE
@@ -19,23 +21,26 @@ target_link_libraries (rays 
                       INTERFACE

                       sanitizer

                       gpu_lib

                       NetCDF::NetCDF

)

target_precompile_headers (rays

                           INTERFACE

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/arithmetic.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/backend.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/dispersion.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/math.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/node.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/solver.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/trigonometry.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/vector.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/equilibrium.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/jit.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/workflow.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/register.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/timing.hpp>

                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpu_context.hpp>

                           $<$<BOOL:${USE_METAL}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/metal_context.hpp>>

                           $<$<BOOL:${USE_CUDA}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cuda_context.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/arithmetic.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/backend.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/dispersion.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/math.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/node.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/solver.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/trigonometry.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/vector.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/equilibrium.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/jit.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/workflow.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/register.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/timing.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cpu_context.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/piecewise.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/newton.hpp>>

                           $<$<BOOL:${USE_PCH}>:$<$<BOOL:${USE_METAL}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/metal_context.hpp>>>

                           $<$<BOOL:${USE_PCH}>:$<$<BOOL:${USE_CUDA}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cuda_context.hpp>>>

)