python_helper.h

Go to the documentation of this file.

// ------------------------------------------------------
//
// SPDX-License-Identifier: GPL-2.0-or-later
//
// SPDX-FileCopyrightText: Copyright (C) 2025-2026 by the ASPECT authors.
//
// This file is part of ASPECT.
//
// Detailed license information governing the source code and
// contributions can be found in the folder LICENSES and in
// LICENSE and CONTRIBUTING.md at the top level directory.
//
// ------------------------------------------------------


#ifndef _aspect_python_helper_h
#define _aspect_python_helper_h

#include <aspect/global.h>
#include <deal.II/base/array_view.h>


#ifdef ASPECT_WITH_PYTHON

// Python does not like it if this macro is already defined. This happens at
// least in some versions of Trilinos and can trigger only with certain unity
// build options:
#ifdef HAVE_SYS_TIME_H
#  undef HAVE_SYS_TIME_H
#endif
#define PY_SSIZE_T_CLEAN
#include <Python.h>

// Declare that we are compatible with numpy 1.7 API and don't want any
// compile warnings for deprecated API calls:
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION

// Define a unique symbol name for the numpy Python API for used when building
// the ASPECT executable. This will be used by numpy to declare a static member
// variable that will be initialized using the import_array() function (see below).
#ifndef PY_ARRAY_UNIQUE_SYMBOL
#  define PY_ARRAY_UNIQUE_SYMBOL ASPECT_ARRAY_API
#endif

// NumPY API requires a call to import_array() to be made before usage
// but only once per executable. We will define
// ASPECT_NUMPY_DEFINE_API in exactly one translation unit per
// executable/shared library (in main.cc and any plugin that uses
// Python). All other translation units including this header will
// therefore define NO_IMPORT_ARRAY that asks numpy to skip defining
// import_array().
#ifndef ASPECT_NUMPY_DEFINE_API
#  define NO_IMPORT_ARRAY
#endif

#include <numpy/arrayobject.h>

// Clean up any of the macros defined above. This is important if we
// are doing a unity build:
#ifdef ASPECT_NUMPY_DEFINE_API
#  undef ASPECT_NUMPY_DEFINE_API
#endif
#ifdef NO_IMPORT_ARRAY
#  undef NO_IMPORT_ARRAY
#endif
#endif


namespace aspect
{
#ifdef ASPECT_WITH_PYTHON
  namespace PythonHelper
  {
    inline
    std::unique_ptr<PyObject, void(*)(PyObject *)> vector_to_numpy_object(const std::vector<double> &vec)
    {
      const npy_intp size = static_cast<npy_intp>(vec.size());

      auto deleter = [](PyObject *obj)
      {
        Py_DECREF(obj);
      };
      if (size == 0)
        return std::unique_ptr<PyObject, void(*)(PyObject *)>(PyArray_SimpleNew(1, &size, NPY_DOUBLE), deleter);
      double *data = const_cast<double *>(vec.data());
      return std::unique_ptr<PyObject, void(*)(PyObject *)>(PyArray_SimpleNewFromData(1, &size, NPY_DOUBLE, data), deleter);
    }



    inline ::ArrayView<double> numpy_to_array_view(PyObject *obj)
    {
      AssertThrow(PyArray_Check(obj), ::ExcMessage("Expected a numpy array"));
      PyArrayObject *arr = reinterpret_cast<PyArrayObject *>(obj);
      return ::ArrayView<double>(static_cast<double *>(PyArray_DATA(arr)),
                                       static_cast<size_t>(PyArray_SIZE(arr)));
    }

    inline
    PyObject *call_python_function(PyObject *pModule, const char *func_name, PyObject *pArgs = nullptr)
    {
      PyObject *pFunc = PyObject_GetAttrString(pModule, func_name);
      if (!pFunc || !PyCallable_Check(pFunc))
        AssertThrow(false, ExcMessage(std::string("Failed to load function: ") + func_name));

      PyObject *pValue = PyObject_CallObject(pFunc, pArgs);
      Py_DECREF(pFunc);

      if (pValue == nullptr)
        {
          if (PyErr_Occurred())
            PyErr_Print();
          AssertThrow(false, ExcMessage(std::string(func_name) + " returned NULL"));
        }
      return pValue;
    }
  }
#endif
}


#endif