stardis-solver

Solve coupled heat transfers
git clone git://git.meso-star.fr/stardis-solver.git
Log | Files | Refs | README | LICENSE

test_sdis_source.c (4275B)

      1 /* Copyright (C) 2016-2025 |Méso|Star> (contact@meso-star.com)
      2  *
      3  * This program is free software: you can redistribute it and/or modify
      4  * it under the terms of the GNU General Public License as published by
      5  * the Free Software Foundation, either version 3 of the License, or
      6  * (at your option) any later version.
      7  *
      8  * This program is distributed in the hope that it will be useful,
      9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     11  * GNU General Public License for more details.
     12  *
     13  * You should have received a copy of the GNU General Public License
     14  * along with this program. If not, see <http://www.gnu.org/licenses/>. */
     15 
     16 #include "sdis.h"
     17 #include "test_sdis_utils.h"
     18 
     19 /*******************************************************************************
     20  * Helper functions
     21  ******************************************************************************/
     22 static void
     23 spherical_source_get_position
     24   (const double time,
     25    double pos[3],
     26    struct sdis_data* data)
     27 {
     28   (void)time, (void)data;
     29   pos[0] = pos[1] = pos[2] = 1.234; /* [m] */
     30 }
     31 
     32 static double
     33 spherical_source_get_power
     34   (const double time,
     35    struct sdis_data* data)
     36 {
     37   (void)time, (void)data;
     38   return 10; /* [W] */
     39 }
     40 
     41 static double
     42 spherical_source_get_diffuse_radiance
     43   (const double time,
     44    const double dir[3],
     45    struct sdis_data* data)
     46 {
     47   (void)time, (void)dir, (void)data;
     48   return 50; /* [W/m^2/sr] */
     49 }
     50 
     51 static void
     52 check_spherical_source(struct sdis_device* dev)
     53 {
     54   struct sdis_spherical_source_shader shader = SDIS_SPHERICAL_SOURCE_SHADER_NULL;
     55   struct sdis_spherical_source_shader shader2= SDIS_SPHERICAL_SOURCE_SHADER_NULL;
     56   struct sdis_source* src = NULL;
     57   struct sdis_source* src2 = NULL;
     58   struct sdis_data* data = NULL;
     59   const double dir[3] = {1,0,0};
     60 
     61   /* Create a data to check its memory management */
     62   OK(sdis_data_create(dev, sizeof(double[3]), ALIGNOF(double[3]), NULL, &data));
     63 
     64   shader.position = spherical_source_get_position;
     65   shader.power = spherical_source_get_power;
     66   shader.radius = 1;
     67   BA(sdis_spherical_source_create(NULL, &shader, data, &src));
     68   BA(sdis_spherical_source_create(dev, NULL, data, &src));
     69   BA(sdis_spherical_source_create(dev, &shader, data, NULL));
     70   OK(sdis_spherical_source_create(dev, &shader, data, &src));
     71 
     72   BA(sdis_spherical_source_get_shader(NULL, &shader2));
     73   BA(sdis_spherical_source_get_shader(src, NULL));
     74   OK(sdis_spherical_source_get_shader(src, &shader2));
     75 
     76   CHK(sdis_source_get_data(src) == data);
     77 
     78   CHK(shader2.position == shader.position);
     79   CHK(shader2.power == shader.power);
     80   CHK(shader2.diffuse_radiance == shader.diffuse_radiance);
     81   CHK(shader2.power(INF, data) == 10);
     82 
     83   BA(sdis_source_ref_get(NULL));
     84   OK(sdis_source_ref_get(src));
     85   BA(sdis_source_ref_put(NULL));
     86   OK(sdis_source_ref_put(src));
     87   OK(sdis_source_ref_put(src));
     88 
     89   OK(sdis_data_ref_put(data));
     90 
     91   OK(sdis_spherical_source_create(dev, &shader, NULL, &src));
     92   OK(sdis_spherical_source_create(dev, &shader, NULL, &src2));
     93   CHK(sdis_source_get_id(src) != sdis_source_get_id(src2));
     94   CHK(sdis_source_get_data(src) == NULL);
     95   OK(sdis_source_ref_put(src));
     96   OK(sdis_source_ref_put(src2));
     97 
     98   shader.position = NULL;
     99   BA(sdis_spherical_source_create(dev, &shader, NULL, &src));
    100   shader.position = spherical_source_get_position;
    101   shader.power = NULL;
    102   BA(sdis_spherical_source_create(dev, &shader, NULL, &src));
    103   shader.power = spherical_source_get_power;
    104   shader.diffuse_radiance = spherical_source_get_diffuse_radiance;
    105   OK(sdis_spherical_source_create(dev, &shader, NULL, &src));
    106 
    107   OK(sdis_spherical_source_get_shader(src, &shader2));
    108   CHK(shader2.diffuse_radiance = spherical_source_get_diffuse_radiance);
    109   CHK(shader2.diffuse_radiance(INF, dir, NULL) == 50);
    110 
    111   OK(sdis_source_ref_put(src));
    112 }
    113 
    114 /*******************************************************************************
    115  * The test
    116  ******************************************************************************/
    117 int
    118 main(int argc, char** argv)
    119 {
    120   struct sdis_device* dev = NULL;
    121   (void)argc, (void)argv;
    122 
    123   OK(sdis_device_create(&SDIS_DEVICE_CREATE_ARGS_DEFAULT, &dev));
    124 
    125   check_spherical_source(dev);
    126 
    127   OK(sdis_device_ref_put(dev));
    128   CHK(mem_allocated_size() == 0);
    129   return 0;
    130 }