wrapper_c.cc

Go to the documentation of this file.

/*
  Copyright (C) 2018-2024 by the authors of the World Builder code.

  This file is part of the World Builder.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 2 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 Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#include "world_builder/wrapper_c.h"

#include "world_builder/assert.h"
#include "world_builder/world.h"
#include <vector>

extern "C" {
  void create_world(void **ptr_ptr_world, const char *world_builder_file,
                    const bool *has_output_dir_, const char *output_dir_,
                    const unsigned long random_number_seed)
  {
    bool has_output_dir = false;

    if (has_output_dir_ != nullptr)
      {
        has_output_dir = *has_output_dir_;
      }

    std::string output_dir;
    if (output_dir_ != nullptr)
      {
        output_dir = *output_dir_;
      }

    WorldBuilder::World *a =
      new WorldBuilder::World(std::string(world_builder_file), has_output_dir,
                              output_dir, random_number_seed);

    *ptr_ptr_world = reinterpret_cast<void *>(a);
  }

  unsigned int properties_output_size(void *ptr_ptr_world,const unsigned int properties_[][3],
                                      const unsigned int n_properties)
  {
    WorldBuilder::World *a =
      reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    std::vector<std::array<unsigned int, 3>> properties(n_properties);
    for (size_t i = 0; i < n_properties; ++i)
      {
        properties[i][0] = properties_[i][0];
        properties[i][1] = properties_[i][1];
        properties[i][2] = properties_[i][2];
      }
    return a->properties_output_size(properties);
  }

  void properties_2d(void *ptr_ptr_world, const double x, const double z,
                     const double depth, const unsigned int properties_[][3],
                     const unsigned int n_properties, double values[])
  {
    WorldBuilder::World *a =
      reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    const std::array<double, 2> position = {{x, z}};
    std::vector<std::array<unsigned int, 3>> properties(n_properties);
    for (size_t i = 0; i < n_properties; ++i)
      {
        properties[i][0] = properties_[i][0];
        properties[i][1] = properties_[i][1];
        properties[i][2] = properties_[i][2];
      }
    std::vector<double> returned_values = a->properties(position, depth, properties);
    for (unsigned i = 0; i < returned_values.size(); ++i)
      {
        values[i] = returned_values[i];
      }
  }

  void properties_3d(void *ptr_ptr_world,
                     const double x,
                     const double y,
                     const double z,
                     const double depth,
                     const unsigned int properties_[][3],
                     const unsigned int n_properties,
                     double values[])
  {
    WorldBuilder::World *a = reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    const std::array<double,3> position = {{x,y,z}};
    std::vector<std::array<unsigned int,3>> properties(n_properties);
    for (size_t i = 0; i < n_properties; ++i)
      {
        properties[i][0] = properties_[i][0];
        properties[i][1] = properties_[i][1];
        properties[i][2] = properties_[i][2];
      }
    std::vector<double> returned_values = a->properties(position, depth, properties);
    for (unsigned i = 0; i < returned_values.size(); ++i)
      {
        values[i] = returned_values[i];
      }
  }

  void temperature_2d(void *ptr_ptr_world, double x, double z, double depth,
                      double *temperature)
  {
    WorldBuilder::World *a =
      reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    const std::array<double, 2> position = {{x, z}};
    *temperature = a->temperature(position, depth);
  }

  void temperature_3d(void *ptr_ptr_world, double x, double y, double z,
                      double depth, double *temperature)
  {
    WorldBuilder::World *a =
      reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    const std::array<double, 3> position = {{x, y, z}};
    *temperature = a->temperature(position, depth);
  }

  void composition_2d(void *ptr_ptr_world, double x, double z, double depth,
                      unsigned int composition_number, double *composition)
  {
    WorldBuilder::World *a =
      reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    const std::array<double, 2> position = {{x, z}};
    *composition = a->composition(position, depth, composition_number);
  }

  void composition_3d(void *ptr_ptr_world, double x, double y, double z,
                      double depth, unsigned int composition_number,
                      double *composition)
  {
    WorldBuilder::World *a =
      reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    const std::array<double, 3> position = {{x, y, z}};
    *composition = a->composition(position, depth, composition_number);
  }

  void release_world(void *ptr_ptr_world)
  {
    WorldBuilder::World *a =
      reinterpret_cast<WorldBuilder::World *>(ptr_ptr_world);
    delete a;
  }
}