star-phor

sphor.c (6070B)

---

 /* 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/>. */
 
 #include "sphor.h"
 #include "sphor_c.h"
 #include "sphor_config.h"
 #include "sphor_compute_mvrea.h"
 
 #include <star/sphin.h>
 #include <star/s3d.h>
 #include <star/ssp.h>
 
 #include <rsys/logger.h>
 #include <rsys/mem_allocator.h>
 
 #include <errno.h> /* errno and EEXIST */
 #include <fcntl.h> /* open */
 #include <unistd.h> /* close */
 #include <sys/stat.h> /* S_IRUSR & S_IWUSR */
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 static res_T
 check_sphor_create_args
   (const struct sphor_create_args* args)
 {
   if (NULL == args) {
     return RES_BAD_ARG;
   }
   return RES_OK;
 }
 
 static void
 release_sphor
   (ref_T* address)
 {
   struct sphor* sphor = NULL;
   ASSERT(NULL != address);
 
   sphor = CONTAINER_OF(address, struct sphor, ref);
   if (NULL != sphor->config) {
     sphin_config_ref_put(sphor->config);
   }
   if (NULL != sphor->scene_view) {
     s3d_scene_view_ref_put(sphor->scene_view);
   }
   if (NULL != sphor->source_distrib_power) {
     ssp_ranst_discrete_ref_put(sphor->source_distrib_power);
   }
   if (NULL != sphor->stream) { fclose(sphor->stream); }
   darray_interface_release(&sphor->interfaces);
   darray_source_view_release(&sphor->source_views);
   MEM_RM(sphor->allocator, sphor);
 }
 
 /*******************************************************************************
  * Local functions
  ******************************************************************************/
 FILE*
 open_output_stream
   (const struct sphor_create_args* args,
    const struct sphor* sphor)
 {
   FILE* fp = NULL;
   int fd = -1;
 
   if (args->force) {
     fp = fopen(args->output_filename, "w");
     if (NULL == fp) {
       ERROR
         (sphor, "Could not open output file `%s'\n", args->output_filename);
       goto error;
     }
   } else {
     fd = open
       (args->output_filename,
        O_CREAT | O_EXCL | O_TRUNC | O_WRONLY,
        S_IRUSR | S_IWUSR);
     if (fd >= 0) {
       fp = fdopen(fd, "w");
       if (NULL == fp) {
         ERROR
           (sphor, "Could not open output file `%s'\n", args->output_filename);
         goto error;
       }
     } else if (errno == EEXIST) {
         ERROR
           (sphor, "The output file `%s' already exists'\n",
            args->output_filename);
         goto error;
     } else {
         ERROR
           (sphor,
            "Unexpected error while opening output file `%s'\n",
            args->output_filename);
         goto error;
     }
   }
 
 exit:
   return fp;
 error:
   if (NULL != fp) {
     fclose(fp);
     fp = NULL;
   } else if (fd >= 0) {
     close(fd);
   }
   goto exit;
 }
 
 /*******************************************************************************
  * Exported functions
  ******************************************************************************/
 res_T
 sphor_create
   (const struct sphor_create_args* args,
    struct sphor** out_sphor)
 {
   struct mem_allocator* allocator = NULL;
   struct sphor* sphor = NULL;
   res_T res = RES_OK;
 
   if (NULL == out_sphor) {
     res = RES_BAD_ARG;
     goto error;
   }
   res = check_sphor_create_args(args);
   if (RES_OK != res) goto error;
 
   if (NULL == args->allocator) {
     allocator = &mem_default_allocator;
   } else {
     allocator = args->allocator;
   }
   sphor = MEM_CALLOC(allocator, 1, sizeof(struct sphor));
   if (NULL == sphor) {
     res = RES_MEM_ERR;
     goto error;
   }
   ref_init(&sphor->ref);
   sphor->verbose = args->verbose;
   sphor->allocator = allocator;
   sphor->nthreads = args->nthreads;
   sphor->samples = args->samples;
   if (NULL == args->logger) {
     sphor->logger = LOGGER_DEFAULT;
   } else {
     sphor->logger = args->logger;
   }
   darray_interface_init(sphor->allocator, &sphor->interfaces);
   darray_source_view_init(sphor->allocator, &sphor->source_views);
 
   if (NULL != args->output_filename){
     sphor->stream = open_output_stream(args, sphor);
     if (NULL == sphor->stream) { goto error; }
   } else { sphor->stream = stdout; }
 
   /* Load the system and build data structure for Monte Carlo */
   res = setup_config(sphor, args);
   if (RES_OK != res) { goto error; }
 
 exit:
   if (NULL != out_sphor) *out_sphor = sphor;
   return res;
 error:
   if (NULL != sphor) {
     SPHOR(ref_put(sphor)); /* <=> ASSERT(sphor_ref_put(sphor) == RES_OK) */
     sphor = NULL;
   }
   goto exit;
 }
 
 res_T
 sphor_ref_get(struct sphor* sphor)
 {
   if (NULL == sphor) {
     return RES_BAD_ARG;
   }
   ref_get(&sphor->ref);
   return RES_OK;
 }
 
 res_T
 sphor_ref_put(struct sphor* sphor)
 {
   if (NULL == sphor) {
     return RES_BAD_ARG;
   }
   ref_put(&sphor->ref, release_sphor);
   return RES_OK;
 }
 
 res_T
 sphor_run(struct sphor* sphor)
 {
   res_T res = RES_OK;
 
   if (NULL == sphor) { goto error; }
 
   res = sphor_compute_MVREA(sphor);
   if (RES_OK != res) { goto error; }
 
 exit:
   return res;
 error:
   goto exit;
 }