Commit 1fbe71c8 authored by cianciosa's avatar cianciosa
Browse files

Fix distribution of rays to avoid overlapping rays. Add distribution of wave... 

Fix distribution of rays to avoid overlapping rays. Add distribution of wave numbers, frequency and launch position.
parent 21f71a88

graph_benchmark/xrays_bench.cpp

+26 −22
Original line number Diff line number Diff line
@@ -26,26 +26,30 @@ void bench_runner() { 


    const size_t num_steps = NUM_TIMES/SUB_STEPS;



    std::vector<std::thread> threads(std::max(std::min(static_cast<unsigned int> (jit::context<T, false>::max_concurrency()),

    std::vector<std::thread> threads(std::max(std::min(static_cast<unsigned int> (jit::context<T>::max_concurrency()),

                                                       static_cast<unsigned int> (NUM_RAYS)),

                                              static_cast<unsigned int> (1)));



    const size_t batch = NUM_RAYS/threads.size();

    const size_t extra = NUM_RAYS%threads.size();



    timeing::measure_diagnostic_threaded timing;



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

        threads[i] = std::thread([&timing] (const size_t thread_number,

        threads[i] = std::thread([&timing, batch, extra] (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);



            auto omega = graph::variable<T, false> (local_num_rays, "\\omega");

            auto kx    = graph::variable<T, false> (local_num_rays, "k_{x}");

            auto ky    = graph::variable<T, false> (local_num_rays, "k_{y}");

            auto kz    = graph::variable<T, false> (local_num_rays, "k_{z}");

            auto x     = graph::variable<T, false> (local_num_rays, "x");

            auto y     = graph::variable<T, false> (local_num_rays, "y");

            auto z     = graph::variable<T, false> (local_num_rays, "z");

            auto t     = graph::variable<T, false> (local_num_rays, "t");



            const size_t local_num_rays = batch

                                        + (extra > thread_number ? 1 : 0);



            auto omega = graph::variable<T> (local_num_rays, "\\omega");

            auto kx    = graph::variable<T> (local_num_rays, "k_{x}");

            auto ky    = graph::variable<T> (local_num_rays, "k_{y}");

            auto kz    = graph::variable<T> (local_num_rays, "k_{z}");

            auto x     = graph::variable<T> (local_num_rays, "x");

            auto y     = graph::variable<T> (local_num_rays, "y");

            auto z     = graph::variable<T> (local_num_rays, "z");

            auto t     = graph::variable<T> (local_num_rays, "t");



            t->set(static_cast<T> (0.0));
@@ -58,12 +62,12 @@ void bench_runner() { 
            ky->set(static_cast<T> (0.0));

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



            auto eq = equilibrium::make_efit<T, false> (NC_FILE);

            auto eq = equilibrium::make_efit<T> (NC_FILE);



            const T endtime = static_cast<T> (1.0);

            const T dt = endtime/static_cast<T> (NUM_TIMES);



            solver::rk4<dispersion::cold_plasma<T, false>> solve(omega,

            solver::rk4<dispersion::cold_plasma<T>> solve(omega,

                                                          kx, ky, kz,

                                                          x, y, z,

                                                          t, dt,

graph_driver/xrays.cpp

+34 −24
Original line number Diff line number Diff line
@@ -26,8 +26,8 @@ int main(int argc, const char * argv[]) { 


    jit::verbose = verbose;



    typedef float base;

    //typedef double base;

    //typedef float base;

    typedef double base;

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

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

    //constexpr bool use_safe_math = true;
@@ -35,8 +35,8 @@ int main(int argc, const char * argv[]) { 


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



    const size_t num_times = 100000;

    const size_t sub_steps = 10;

    const size_t num_times = 200000;

    const size_t sub_steps = 100;

    const size_t num_steps = num_times/sub_steps;

    const size_t num_rays = 100000;
@@ -44,11 +44,15 @@ int main(int argc, const char * argv[]) { 
                                                       static_cast<unsigned int> (num_rays)),

                                              static_cast<unsigned int> (1)));



    const size_t batch = num_rays/threads.size();

    const size_t extra = num_rays%threads.size();



    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, batch, extra] (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);



            const size_t local_num_rays = batch

                                        + (extra > thread_number ? 1 : 0);



            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_int_distribution<size_t> int_dist(0, local_num_rays - 1);
@@ -66,35 +70,41 @@ int main(int argc, const char * argv[]) { 


//  Inital conditions.

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

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

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

                std::normal_distribution<float> norm_dist2(static_cast<float> (0.0), static_cast<float> (0.05));

                std::normal_distribution<float> norm_dist3(static_cast<float> (-100.0), static_cast<float> (10.0));

                std::normal_distribution<float> norm_dist4(static_cast<float> (0.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)));

                    y->set(j, static_cast<base> (norm_dist2(engine)));

                    z->set(j, static_cast<base> (norm_dist2(engine)));

                    ky->set(j, static_cast<base> (norm_dist3(engine)));

                    kz->set(j, static_cast<base> (norm_dist4(engine)));

                }

            } else {

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

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

                std::normal_distribution<float> norm_dist2(static_cast<double> (0.0), static_cast<double> (0.05));

                std::normal_distribution<float> norm_dist3(static_cast<float> (-100.0), static_cast<float> (10.0));

                std::normal_distribution<float> norm_dist4(static_cast<float> (0.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)));

                    y->set(j, static_cast<base> (norm_dist2(engine)));

                    z->set(j, static_cast<base> (norm_dist2(engine)));

                    ky->set(j, static_cast<base> (norm_dist3(engine)));

                    kz->set(j, static_cast<base> (norm_dist4(engine)));

                }

            }



            omega->set(static_cast<base> (500.0));

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

            x->set(static_cast<base> (2.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));

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

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

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

            //kz->set(static_cast<base> (10.0));

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



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

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

            //auto eq = equilibrium::make_slab_field<base, use_safe_math> ();

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



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

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

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

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

            const base dt = endtime/static_cast<base> (num_times);
@@ -108,9 +118,9 @@ int main(int argc, const char * argv[]) { 
            //solver::rk4<dispersion::bohm_gross<base, use_safe_math>>

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

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

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

            solver::rk4<dispersion::ordinary_wave<base, use_safe_math>>

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

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

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

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

            //solver::rk4<dispersion::hot_plasma<base, dispersion::z_erfi<base, use_safe_math>, use_safe_math>>

            //solver::rk4<dispersion::hot_plasma_expandion<base, dispersion::z_erfi<base, use_safe_math>, use_safe_math>>

graph_framework.xcodeproj/project.pbxproj

+0 −13
Original line number Diff line number Diff line
@@ -49,13 +49,6 @@ 
/* End PBXBuildFile section */



/* Begin PBXContainerItemProxy section */

		C74DF4612AA8BD2600319113 /* PBXContainerItemProxy */ = {

			isa = PBXContainerItemProxy;

			containerPortal = C791419E22DA9BF200E0BA0D /* Project object */;

			proxyType = 1;

			remoteGlobalIDString = C79141A522DA9BF200E0BA0D;

			remoteInfo = graph_framework;

		};

		C74DF4632AA8BD3400319113 /* PBXContainerItemProxy */ = {

			isa = PBXContainerItemProxy;

			containerPortal = C791419E22DA9BF200E0BA0D /* Project object */;
@@ -667,7 +660,6 @@ 
			buildRules = (

			);

			dependencies = (

				C74DF4622AA8BD2600319113 /* PBXTargetDependency */,

			);

			name = graph_benchmark;

			productName = graph_benchmark;
@@ -1083,11 +1075,6 @@ 
/* End PBXSourcesBuildPhase section */



/* Begin PBXTargetDependency section */

		C74DF4622AA8BD2600319113 /* PBXTargetDependency */ = {

			isa = PBXTargetDependency;

			target = C79141A522DA9BF200E0BA0D /* graph_framework */;

			targetProxy = C74DF4612AA8BD2600319113 /* PBXContainerItemProxy */;

		};

		C74DF4642AA8BD3400319113 /* PBXTargetDependency */ = {

			isa = PBXTargetDependency;

			target = C79141A522DA9BF200E0BA0D /* graph_framework */;

graph_framework/workflow.hpp

+1 −1

File changed.

Contains only whitespace changes.