star-phor-input

sphin_prop_rad.c (6303B)

---

 /* Copyright (C) 2024-2026 Centre National de la Recherche Scientifique
  * Copyright (C) 2024-2026 Clermont Auvergne INP
  * Copyright (C) 2024-2026 INSA Lyon
  * Copyright (C) 2024-2026 Institut Mines Télécom Albi-Carmaux
  * Copyright (C) 2024-2026 Institut National Polytechnique de Toulouse
  * Copyright (C) 2024-2026 |Méso|Star> (contact@meso-star.com)
  * Copyright (C) 2024-2026 PhotonLyX (info@photonlyx.com)
  * Copyright (C) 2024-2026 Université de Lorraine
  * Copyright (C) 2024-2026 Université Paul Sabatier
  * Copyright (C) 2024-2026 Université Toulouse - Jean Jaurès
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>. */
 #define _POSIX_C_SOURCE 200112L /* for strtok_r support */
 
 #include "sphin_c.h"
 #include "sphin_config.h"
 #include "sphin_prop_rad.h"
 #include "sphin_scatterer.h"
 #include "sphin_volume.h"
 
 #include <rsys/mem_allocator.h>
 #include <rsys/ref_count.h>
 #include <rsys/rsys.h>
 #include <rsys/str.h>
 #include <rsys/text_reader.h>
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 static res_T
 prop_rad_create
   (struct sphin* sphin,
    const char* name,
    struct sphin_prop_rad** out_prop_rad)
 {
   struct sphin_prop_rad* prop_rad = NULL;
   res_T res = RES_OK;
 
   ASSERT('\0' != name[0]); /* Name can't be empty */
   ASSERT(NULL != name);
   ASSERT(NULL != out_prop_rad);
   ASSERT(NULL != sphin);
 
   prop_rad = MEM_CALLOC(sphin->allocator, 1, sizeof(struct sphin_prop_rad));
   if (NULL == prop_rad) { res = RES_MEM_ERR; goto error; }
   ref_init(&prop_rad->ref);
   SPHIN(ref_get(sphin));
   prop_rad->sphin = sphin;
   prop_rad->scatterer = NULL;
 
   str_init(sphin->allocator, &prop_rad->name);
   res = str_set(&prop_rad->name, name);
   if (RES_OK != res) { goto error; }
 
 exit:
   *out_prop_rad = prop_rad;
   return res;
 error:
   if (NULL != prop_rad) {
     SPHIN(prop_rad_ref_put(prop_rad));
     prop_rad = NULL;
   }
   goto exit;
 }
 
 static void
 release_prop_rad
   (ref_T* address)
 {
   struct sphin_prop_rad* prop_rad = NULL;
   struct sphin* sphin = NULL;
 
   ASSERT(NULL != address);
 
   prop_rad = CONTAINER_OF(address, struct sphin_prop_rad, ref);
   str_release(&prop_rad->name);
   if (NULL != prop_rad->scatterer) {
     SPHIN(scatterer_ref_put(prop_rad->scatterer));
   }
   sphin = prop_rad->sphin;
   MEM_RM(sphin->allocator, prop_rad);
   SPHIN(ref_put(sphin));
 }
 
 /*******************************************************************************
  * Local functions
  ******************************************************************************/
 res_T
 parse_prop_rad
   (struct sphin_config* config,
    struct sphin_volume* volume,
    struct txtrdr* txtrdr,
    char* value)
 {
   char* prop_rad_type_str = NULL;
   char* name = NULL;
   char* token = NULL;
   char* token_ptr = NULL;
   enum sphin_prop_rad_type prop_rad_type = SPHIN_PROP_RAD_NONE__;
   struct str line;
   struct sphin_prop_rad* prop_rad = NULL;
   res_T res = RES_OK;
 
   ASSERT(NULL != volume);
   ASSERT(NULL != txtrdr);
   ASSERT(NULL != value);
   ASSERT('\0' != value[0]); /* Name can't be empty */
 
   str_init(config->sphin->allocator, &line);
 
   /* Parse name of the prop_rad */
   name = trim_string(value);
   if (NULL == name){ res = RES_BAD_ARG; goto error; }
 
   /* Next line: corresponds to the prop_rad type */
   res = txtrdr_read_line(txtrdr);
   if (RES_OK != res) { goto error; }
 
   if (NULL == txtrdr_get_line(txtrdr)) { res = RES_BAD_ARG; goto error; }
 
   res = str_set(&line, txtrdr_get_cline(txtrdr));
   if (RES_OK != res) { goto error; }
 
   token = strtok_r(str_get(&line), ":", &token_ptr);
   if (NULL == token) { res = RES_BAD_ARG; goto error; }
 
   prop_rad_type_str = trim_keyword(token);
   if (0 == strcmp(prop_rad_type_str, "scatterer")) {
     prop_rad_type = SPHIN_PROP_RAD_SCATTERER;
   } else {
     res = RES_BAD_ARG; goto error;
   }
 
   res = prop_rad_create(volume->sphin, name, &prop_rad);
   if (RES_OK != res) { goto error; }
 
   /* Parse prop rad parameters in function of its type */
   switch(prop_rad_type) {
     case SPHIN_PROP_RAD_BOLTZMANN:
       /* TODO Parse prop rad coefficients */
       break;
 
     case SPHIN_PROP_RAD_SCATTERER:
       res = parse_scatterer(prop_rad, txtrdr);
       if (RES_OK != res) { goto error; }
       break;
 
     case SPHIN_PROP_RAD_NONE__:
       res = RES_BAD_ARG;
       goto error;
 
     default:
        FATAL("Unreachable code\n"); break;
   }
 
   res = darray_sphin_prop_rad_ptr_push_back(&volume->prop_rads, &prop_rad);
   if (RES_OK != res) { goto error; }
 
 exit:
   str_release(&line);
   return res;
 error:
   if (NULL != prop_rad) {
     SPHIN(prop_rad_ref_put(prop_rad));
     prop_rad = NULL;
   }
   goto exit;
 }
 
 /*******************************************************************************
  * Exported functions
  ******************************************************************************/
 res_T
 sphin_prop_rad_ref_get
   (struct sphin_prop_rad* prop_rad)
 {
   if (NULL == prop_rad) {
     return RES_BAD_ARG;
   }
   ref_get(&prop_rad->ref);
   return RES_OK;
 }
 
 res_T
 sphin_prop_rad_ref_put
   (struct sphin_prop_rad* prop_rad)
 {
   if (NULL == prop_rad) {
     return RES_BAD_ARG;
   }
   ref_put(&prop_rad->ref, release_prop_rad);
   return RES_OK;
 }
 
 res_T
 sphin_prop_rad_get_name
   (struct sphin_prop_rad* prop_rad,
    char** name)
 {
   if (NULL == prop_rad || NULL == name) {
     return RES_BAD_ARG;
   }
   *name = (char*)str_get((struct str*)&prop_rad->name);
   return RES_OK;
 }
 
 res_T
 sphin_prop_rad_get_scatterer
   (struct sphin_prop_rad* prop_rad,
    struct sphin_scatterer** scatterer)
 {
   if (NULL == prop_rad
    || NULL == scatterer) {
     return RES_BAD_ARG;
   }
   *scatterer = prop_rad->scatterer;
   return RES_OK;
 }