cpp_python_funct.cpp File Reference

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstring>
#include <vector>
#include <set>
#include <map>
#include <regex>
#include <iomanip>
#include <limits>
#include <dlfcn.h>
#include <dirent.h>
#include "cpp_python_funct.h"
#include "cpp_python_sampling.h"
#include "python_signal.h"

Go to the source code of this file.

Typedefs
typedef float	my_real

Functions
template<std::size_t N>
std::string	element_parenthesis_to_underscore (const std::string &input, const std::array< const char *, N > &keywords)
std::string	node_parenthesis_to_underscore (const std::string &input)
std::string	parenthesis_to_underscore (const std::string &input)
void	extract_node_uid (const std::string &input)
void	extract_element_keywords (const std::string &input)
template<typename T>
void	load_functions (T h, bool &python_initialized)
void	exit_with_message (const char *message)
void	check_error (int line_number)
void	python_signal_handler (int signum)
PyObject *	call_python_function_with_state (const char *func_name)
PyObject *	call_python_function (const char *func_name, double *args, int num_args)
void	call_python_function1D_vectors (const char *func_name, std::vector< double > &X, std::vector< double > &Y)
void	python_execute_code (const std::string &code)
std::string	extract_function_name (const std::string &signature)
bool	try_load_library (const std::string &path)
void	python_load_library ()
void	cpp_python_initialize (int *ierror)
void	cpp_python_load_environment ()
void	cpp_python_sync (void *pcontext)
void	cpp_python_finalize ()
void	cpp_python_execute_code (const char *code)
void	cpp_python_initialize_global_variables ()
void	cpp_python_register_function (char *name, char code[], int num_lines)
void	cpp_python_call_function (char *name, int num_args, double *args, int num_return, double *return_values)
void	cpp_python_call_function_with_state (char *name, double *return_values)
void	cpp_python_check_function (char *name, int *error)
void	cpp_python_update_reals (char *basename, int *uid, my_real *reals, int num_reals)
void	cpp_python_update_time (my_real TIME, my_real DT)
void	cpp_python_get_number_of_nodes (int *num_nodes)
void	cpp_python_get_nodes (int *nodes_uid_array)
void	cpp_python_create_node_mapping (int *itab, int *num_nodes)
void	cpp_python_update_sensors (int *types, int *uids, int *statuses, double *results, int *num_sensors)
void	cpp_python_update_active_node (int name_len, char *name, double *values)
void	cpp_python_update_active_node_ids (int id, int uid)
void	cpp_python_update_nodal_entity (int numnod, int name_len, char *name, my_real *values)
void	cpp_python_update_elemental_entity (char *name, double value, int uid)
void	cpp_python_get_number_elemental_entities (int *nb)
void	cpp_python_get_elemental_entity (int nb, char *name, int *uid)
void	cpp_python_sample_function (char *name, double *x, double *y, int n)
void	cpp_python_add_ints_to_dict (void *context_ptr, const char *name, int len_name, int *values, int nvalues)
void	cpp_python_add_doubles_to_dict (void *context_ptr, const char *name, int len_name, double *values, int nvalues)
void *	cpp_python_create_context ()
void	cpp_python_free_context (void *context)
PyThreadState *	py_begin_allow_threads ()
void	py_end_allow_threads (PyThreadState *saved_state)

Variables
void *	handle = nullptr
PyObject *	pDict = nullptr
bool	python_initialized = false
bool	sync_enabled = false
std::set< int >	nodes_uid
std::map< int, int >	nodes_uid_to_local_id
KeywordPairs	element_variables
static PyObject *	persistent_dict = nullptr
static PyObject *	persistent_arg = nullptr

Typedef Documentation

my_real

typedef float my_real

Definition at line 49 of file cpp_python_funct.cpp.

Function Documentation

call_python_function()

PyObject * call_python_function	(	const char *	func_name,
		double *	args,
		int	num_args )

Definition at line 322 of file cpp_python_funct.cpp.

{
    check_error(__LINE__);
    PyObject *pFunc, *pArgs, *pValue;
    pFunc = static_cast<PyObject *>(MyDict_GetItemString(pDict, func_name));
    if (MyCallable_Check(pFunc))
    {
        check_error(__LINE__);
        pArgs = static_cast<PyObject *>(MyTuple_New(num_args));
        for (size_t i = 0; i < num_args; i++)
        {
            MyTuple_SetItem(pArgs, i, static_cast<PyObject *>(MyFloat_FromDouble(args[i])));
        }
        check_error(__LINE__);
        pValue = static_cast<PyObject *>(MyObject_CallObject(pFunc, pArgs));
        check_error(__LINE__);
        My_DecRef(pArgs);
        if (pValue != nullptr)
        {
            // Function executed successfully
        }
        else
        {
            //  convert func_name to a string
            std::string func_name_str(func_name);
            std::cout << "ERROR in Python function " << func_name_str << ": function execution failed" << std::endl;
            if (MyErr_Occurred())
            {
                // Fetch the error
                PyObject *pType = nullptr, *pValue = nullptr, *pTraceback = nullptr;
                MyErr_Fetch(&pType, &pValue, &pTraceback);
                if (pType)
                    std::cout<<"[PYTHON]"<< MyUnicode_AsUTF8(MyObject_Str(pType)) << std::endl;
                if (pValue)
                    std::cout<<"[PYTHON]"<< MyUnicode_AsUTF8(MyObject_Str(pValue)) << std::endl;
                if (pTraceback)
                    std::cout<<"[PYTHON]"<< MyUnicode_AsUTF8(MyObject_Str(pTraceback)) << std::endl;
 
                // Print the error
                //MyErr_Display(pType, pValue, pTraceback);
                // Decrement reference counts for the error objects
                My_DecRef(pType);
                My_DecRef(pValue);
                My_DecRef(pTraceback);
                exit_with_message("ERROR: Python function failed");
            }
        }
 
        return pValue;
    }
    std::cout << "ERROR in Python function: cannot call function: " << func_name << std::endl;
    return nullptr;
}

call_python_function1D_vectors()

void call_python_function1D_vectors	(	const char *	func_name,
		std::vector< double > &	X,
		std::vector< double > &	Y )

Definition at line 376 of file cpp_python_funct.cpp.

{
    PyObject *pFunc, *pArgs, *pValue;
    const int num_args = X.size();
    pFunc = static_cast<PyObject *>(MyDict_GetItemString(pDict, func_name));
    if (MyCallable_Check(pFunc))
    {
        for (size_t i = 0; i < num_args; i++)
        {
            pArgs = static_cast<PyObject *>(MyTuple_New(1));
            MyTuple_SetItem(pArgs, 0, static_cast<PyObject *>(MyFloat_FromDouble(X[i])));
            pValue = static_cast<PyObject *>(MyObject_CallObject(pFunc, pArgs));
            My_DecRef(pArgs);
 
            if (pValue != nullptr)
            {
                // Function executed successfully
                Y[i]= (MyFloat_AsDouble(pValue));
                My_DecRef(pValue);
            }
            else
            {
                MyErr_Clear();
                Y[i] = static_cast<double>(std::numeric_limits<float>::max());
            }
//           std::cout<<"X["<<i<<"] = "<<X[i]<<" Y["<<i<<"] = "<<Y[i]<<std::endl;
        }
    }
}

call_python_function_with_state()

PyObject * call_python_function_with_state

(

const char *

func_name

)

Definition at line 248 of file cpp_python_funct.cpp.

{
    PyObject *pFunc, *pValue;
    activate_signal_handling(python_signal_handler);
    // Retrieve the Python function from the module dictionary
    pFunc = static_cast<PyObject *>(MyDict_GetItemString(pDict, func_name));
    if (MyCallable_Check(pFunc))
    {
        // Initialize persistent dictionary on the first call
        if (!persistent_dict)
        {
            persistent_dict = MyDict_New();
            if (!persistent_dict)
            {
                std::cout << "ERROR: Failed to create persistent dictionary." << std::endl;
                return nullptr;
            }
            // Create a tuple to hold the single dictionary argument
            persistent_arg = static_cast<PyObject *>(MyTuple_New(1)); // Only 1 argument: the dictionary
            if (!persistent_arg)
            {
                std::cout << "ERROR: Failed to create argument tuple." << std::endl;
                return nullptr;
            }
 
            MyTuple_SetItem(persistent_arg, 0, persistent_dict); // Borrowed reference to persistent_dict Is this the problem????
        }
 
        // Set the dictionary in the tuple
 
        // Call the Python function
        pValue = static_cast<PyObject *>(MyObject_CallObject(pFunc, persistent_arg)); // segmentation fault here
 
        if (pValue != nullptr)
        {
            // Function executed successfully
            // Optionally handle the result (if required)
        }
        else
        {
            // Handle Python exception
            std::string func_name_str(func_name);
            std::cout << "ERROR in Python function " << func_name_str << ": function execution failed" << std::endl;
            if (MyErr_Occurred())
            {
                // Fetch the error details
                PyObject *pType, *pValue, *pTraceback;
                MyErr_Fetch(&pType, &pValue, &pTraceback);
                if (pType)
                    std::cout << "[PYTHON] " << MyUnicode_AsUTF8(MyObject_Str(pType)) << std::endl;
                if (pValue)
                    std::cout << "[PYTHON] " << MyUnicode_AsUTF8(MyObject_Str(pValue)) << std::endl;
                if (pTraceback)
                    std::cout << "[PYTHON]: " << MyUnicode_AsUTF8(MyObject_Str(pTraceback)) << std::endl;
 
                // Print the error
                //MyErr_Display(pType, pValue, pTraceback);
 
                // Decrement reference counts for error objects
                My_DecRef(pType);
                My_DecRef(pValue);
                My_DecRef(pTraceback);
                exit_with_message("ERROR: Python function failed");
            }
        }
        restore_default_signal_handling();
        return pValue;
    }
 
    std::cout << "ERROR in Python function: cannot call function: " << func_name << std::endl;
    return nullptr;
}

check_error()

void check_error

(

int

line_number

)

Definition at line 209 of file cpp_python_funct.cpp.

{
            if (MyErr_Occurred())
            {
                //std::cout<<"Error at line: "<<line_number<<std::endl;
                // Fetch the error
                PyObject *pType = nullptr, *pValue = nullptr, *pTraceback = nullptr;
                MyErr_Fetch(&pType, &pValue, &pTraceback);
                if (pType)
                    std::cout<<"[PYTHON]"<< MyUnicode_AsUTF8(MyObject_Str(pType)) << std::endl;
                if (pValue)
                    std::cout<<"[PYTHON]"<< MyUnicode_AsUTF8(MyObject_Str(pValue)) << std::endl;
                if (pTraceback)
                    std::cout<<"[PYTHON]"<< MyUnicode_AsUTF8(MyObject_Str(pTraceback)) << std::endl;
 
                // Print the error
                //MyErr_Display(pType, pValue, pTraceback);
                // Decrement reference counts for the error objects
                My_DecRef(pType);
                My_DecRef(pValue);
                My_DecRef(pTraceback);
                exit_with_message("ERROR: Python function failed");
            }
}

cpp_python_add_doubles_to_dict()

void cpp_python_add_doubles_to_dict	(	void *	context_ptr,
		const char *	name,
		int	len_name,
		double *	values,
		int	nvalues )

Definition at line 1438 of file cpp_python_funct.cpp.

{ // expose the array without copying
    if (!python_initialized)
    {
        return;
    }
    check_error(__LINE__);
    PyObject * context = static_cast<PyObject*>(context_ptr); 
    char ptr_key[100],size_key[100],type_key[100];
    snprintf(ptr_key, sizeof(ptr_key), "%s_ptr", name);
    snprintf(size_key, sizeof(size_key), "%s_size", name);
    snprintf(type_key, sizeof(type_key), "%s_type", name);
    PyObject* ptr_value  = MyLong_FromVoidPtr(values);
    PyObject* size_value = MyLong_FromLong(static_cast<long>(nvalues));
    PyObject* type_value = MyUnicode_FromString("double");
    // set the values in the context dictionary
    MyDict_SetItemString(context, ptr_key, ptr_value);
    MyDict_SetItemString(context, size_key, size_value);
    MyDict_SetItemString(context, type_key, type_value);
    // release the references
    My_DecRef(ptr_value);
    My_DecRef(size_value);
    My_DecRef(type_value);
    check_error(__LINE__);
}

cpp_python_add_ints_to_dict()

void cpp_python_add_ints_to_dict	(	void *	context_ptr,
		const char *	name,
		int	len_name,
		int *	values,
		int	nvalues )

Definition at line 1409 of file cpp_python_funct.cpp.

{ // expose the array without copying
    if (!python_initialized)
    {
        return;
    }
    check_error(__LINE__);
    PyObject * context = static_cast<PyObject*>(context_ptr); 
    char ptr_key[100],size_key[100],type_key[100];
    snprintf(ptr_key, sizeof(ptr_key), "%s_ptr", name);
    snprintf(size_key, sizeof(size_key), "%s_size", name);
    snprintf(type_key, sizeof(type_key), "%s_type", name);
    PyObject* ptr_value  = MyLong_FromVoidPtr(values);
    PyObject* size_value = MyLong_FromLong(static_cast<long>(nvalues));
    PyObject* type_value = MyUnicode_FromString("int");
 
    // set the values in the context dictionary
    MyDict_SetItemString(context, ptr_key, ptr_value);
    MyDict_SetItemString(context, size_key, size_value);
    MyDict_SetItemString(context, type_key, type_value);
 
    // release the references
    My_DecRef(ptr_value);
    My_DecRef(size_value);
    My_DecRef(type_value);
    check_error(__LINE__);
 
}

cpp_python_call_function()

void cpp_python_call_function	(	char *	name,
		int	num_args,
		double *	args,
		int	num_return,
		double *	return_values )

Definition at line 916 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            return;
        }
        //GIL
        PyGILState_STATE gstate = MyGILState_Ensure();  
        check_error(__LINE__);
        if (strcmp(name, "initialize_environment") == 0) return;
        PyObject *result = call_python_function(name, args, num_args);
        if (result)
        {
            return_values[0] = MyFloat_AsDouble(result);
            My_DecRef(result);
        } else 
        {
            exit_with_message("ERROR: Python function failed");
        }
        check_error(__LINE__);
        MyGILState_Release(gstate);
    }

cpp_python_call_function_with_state()

void cpp_python_call_function_with_state	(	char *	name,
		double *	return_values )

Definition at line 939 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            return;
        }
        PyGILState_STATE gstate = MyGILState_Ensure();
        check_error(__LINE__);
        PyObject *result = call_python_function_with_state(name);
        if (result)
        {
            *return_values = MyFloat_AsDouble(result);
            My_DecRef(result);
        } else {
            exit_with_message("ERROR: Python function failed");
        }
        check_error(__LINE__);
        MyGILState_Release(gstate);
    }

cpp_python_check_function()

void cpp_python_check_function	(	char *	name,
		int *	error )

Definition at line 959 of file cpp_python_funct.cpp.

    {
        PyObject *pFunc;
        //        std::cout << "Checking if function exists: " << name << std::endl;
        if (python_initialized)
        {
            pFunc = static_cast<PyObject *>(MyDict_GetItemString(pDict, name));
            if (MyCallable_Check(pFunc))
            {
                *error = 0;
            }
            else
            {
                *error = 1;
            }
        }
        else
        {
            *error = 1;
        }
 
        //        std::cout << "Function exists? " << *error << std::endl;
    }

cpp_python_create_context()

void * cpp_python_create_context

(

)

Definition at line 1466 of file cpp_python_funct.cpp.

                                  {
    check_error(__LINE__);
    PyObject* context = MyDict_New();
    if (!context) {
        return NULL;
    }
    return context;
    check_error(__LINE__);
}

cpp_python_create_node_mapping()

void cpp_python_create_node_mapping	(	int *	itab,
		int *	num_nodes )

Definition at line 1085 of file cpp_python_funct.cpp.

    {
        // print number of nodes and python_initialized
        // std::cout << "Number of nodes: " << *num_nodes << " python_initialized" << python_initialized << std::endl;
        if (python_initialized)
        {
            // loop over the set
            for (auto node_uid : nodes_uid)
            {
                // find i such that itab[i] = node_uid
                bool found = false;
                for (int i = 0; i < *num_nodes; i++)
                {
                    if (itab[i] == node_uid)
                    {
                        nodes_uid_to_local_id[node_uid] = i;
                        // std::cout << "Node uid: " << node_uid << " local id: " << i << std::endl;
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    std::cout << "Node uid: " << node_uid << " not found in itab" << std::endl;
                }
            }
            check_error(__LINE__);
        }
    }

cpp_python_execute_code()

void cpp_python_execute_code

(

const char *

code

)

Definition at line 777 of file cpp_python_funct.cpp.

    {
        MyRun_SimpleString(code);
        check_error(__LINE__);
 
    }

cpp_python_finalize()

void cpp_python_finalize

(

)

Definition at line 773 of file cpp_python_funct.cpp.

    {
        My_Finalize();
    }

cpp_python_free_context()

void cpp_python_free_context

(

void *

context

)

Definition at line 1476 of file cpp_python_funct.cpp.

                                            {
    if (context) {
        My_DecRef(static_cast<PyObject*>(context));
    }
}

cpp_python_get_elemental_entity()

void cpp_python_get_elemental_entity	(	int	nb,
		char *	name,
		int *	uid )

Definition at line 1344 of file cpp_python_funct.cpp.

    {
        size_t n = static_cast<size_t>(nb - 1);
        KeywordPair p = get_keyword_pair(element_variables, n);
        for (int i = 0; i < max_variable_length; i++)
        {
            name[i] = '\0';
        }
        // copy user id
        *uid = p.first;
        // copy variable name
#ifdef _WIN64
        strcpy_s(name, max_variable_length, p.second);
#else
        strcpy(name, p.second);
#endif
    }

cpp_python_get_nodes()

void cpp_python_get_nodes

(

int *

nodes_uid_array

)

Definition at line 1071 of file cpp_python_funct.cpp.

    {
        if (python_initialized)
        {
            int i = 0;
            for (auto node_uid : nodes_uid)
            {
                // std::cout << "Node uid: " << node_uid << std::endl;
                nodes_uid_array[i] = node_uid;
                i++;
            }
        }
    }

cpp_python_get_number_elemental_entities()

void cpp_python_get_number_elemental_entities

(

int *

nb

)

Definition at line 1339 of file cpp_python_funct.cpp.

    {
        *nb = element_variables.size();
    }

cpp_python_get_number_of_nodes()

void cpp_python_get_number_of_nodes

(

int *

num_nodes

)

Definition at line 1057 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            *num_nodes = 0;
        }
        else
        {
            *num_nodes = nodes_uid.size();
        }
 
    }

cpp_python_initialize()

void cpp_python_initialize

(

int *

ierror

)

Definition at line 640 of file cpp_python_funct.cpp.

    {
        if (python_initialized)
        { // already initialized
            return;
        }
        // if ierror = 1 on entry, then "-python" is missing from the starter command line, and we will not execute any python code
        if (*ierror == 1)
            return;
        *ierror = 1;
        // Load Python dynamic library
        python_load_library();
        if (python_initialized)
        {
            pDict = MyModule_GetDict(MyImport_AddModule("__main__")); // Get the main module dictionary
            if (!pDict)
            {
                std::cout << "ERROR in Python: fetching main module dictionary" << std::endl;
                return;
            }
            int result = MyRun_SimpleString("import math"); // Import the math module for sin and other functions
            if (result != 0)
            {
                std::cerr << "ERROR: Failed to import math module in Python." << std::endl;
                // Print Python error traceback
                if (MyErr_Occurred())
                {
                // Fetch the error details
                PyObject *pType, *pValue, *pTraceback;
                MyErr_Fetch(&pType, &pValue, &pTraceback);
                if (pType)
                    std::cout << "[PYTHON] " << MyUnicode_AsUTF8(MyObject_Str(pType)) << std::endl;
                if (pValue)
                    std::cout << "[PYTHON] " << MyUnicode_AsUTF8(MyObject_Str(pValue)) << std::endl;
                if (pTraceback)
                    std::cout << "[PYTHON]: " << MyUnicode_AsUTF8(MyObject_Str(pTraceback)) << std::endl;
 
                // Print the error
                //MyErr_Display(pType, pValue, pTraceback);
 
                // Decrement reference counts for error objects
                My_DecRef(pType);
                My_DecRef(pValue);
                My_DecRef(pTraceback);
                exit_with_message("ERROR: Python function failed");
                }
           }else
           {
              *ierror = 0;
           }
           check_error(__LINE__);
        }
    }

cpp_python_initialize_global_variables()

void cpp_python_initialize_global_variables

(

)

Definition at line 784 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            return;
        }
        // initialize TIME and DT to 0
        check_error(__LINE__);
 
 
        PyObject *py_TIME = static_cast<PyObject *>(MyFloat_FromDouble(0.0));
        PyObject *py_DT = static_cast<PyObject *>(MyFloat_FromDouble(0.0));
        MyDict_SetItemString(pDict, "TIME", py_TIME);
        MyDict_SetItemString(pDict, "DT", py_DT);
 
        // loop over the set of nodes
        for (auto node_uid : nodes_uid)
        {
            std::string entity_names[] = {"C", "D", "V", "A", "VR", "AR", "DR"};
            for (auto name : entity_names)
            {
                const double x_values = static_cast<double>(1);
                const double y_values = static_cast<double>(1);
                const double z_values = static_cast<double>(1);
                PyObject *py_x_values = static_cast<PyObject *>(MyFloat_FromDouble(x_values));
                PyObject *py_y_values = static_cast<PyObject *>(MyFloat_FromDouble(y_values));
                PyObject *py_z_values = static_cast<PyObject *>(MyFloat_FromDouble(z_values));
                if (!py_x_values || !py_y_values || !py_z_values)
                {
                    std::cout << "ERROR: Failed to create Python objects from C++ doubles." << std::endl;
                    return;
                }
                std::string x_name = name + "X_" + std::to_string(node_uid);
                std::string y_name = name + "Y_" + std::to_string(node_uid);
                std::string z_name = name + "Z_" + std::to_string(node_uid);
                // std::cout<<" write to python: "<<x_name<<" "<<y_name<<" "<<z_name<<std::endl;
                MyDict_SetItemString(pDict, x_name.c_str(), py_x_values);
                MyDict_SetItemString(pDict, y_name.c_str(), py_y_values);
                MyDict_SetItemString(pDict, z_name.c_str(), py_z_values);
                // Release the Python objects
                if (py_x_values != nullptr)
                    My_DecRef(py_x_values);
                if (py_y_values != nullptr)
                    My_DecRef(py_y_values);
                if (py_z_values != nullptr)
                    My_DecRef(py_z_values);
            }
        }
        // Initialize all elements keywords to 1
        for (auto p : element_variables)
        {
            double v = static_cast<double>(1);
            PyObject *py_value = static_cast<PyObject *>(MyFloat_FromDouble(v));
            if (!py_value)
            {
                std::cout << "ERROR: Failed to create Python objects from C++ doubles." << std::endl;
            }
            // convert p.second (const char *) to std::string
            std::string keyword(p.second);
            std::string sname = keyword + "_" + std::to_string(p.first);
            MyDict_SetItemString(pDict, sname.c_str(), py_value);
            if (py_value != nullptr)
                My_DecRef(py_value);
        }
        check_error(__LINE__);
 
    }

cpp_python_load_environment()

void cpp_python_load_environment

(

)

Definition at line 693 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            return;
        }
        check_error(__LINE__);
        const char *code =
            "if 'initialize_environment' in globals():\n"
            "    initialize_environment()\n";
        int result = MyRun_SimpleString(code);
        check_error(__LINE__);
    }

cpp_python_register_function()

void cpp_python_register_function	(	char *	name,
		char	code[],
		int	num_lines )

Definition at line 853 of file cpp_python_funct.cpp.

    {
        std::string tmp_string;
        int current_line = 0;
        std::stringstream function_code;
 
        if (!python_initialized)
        {
            std::cout << "ERROR: Python not initialized" << std::endl;
            std::cout << "Make sure that the following python code is safe" << std::endl;
            std::cout << "and rerun the starter with the -python option." << std::endl;
        }
 
        for (int i = 0; current_line < num_lines;)
        {
            tmp_string.clear();
            // Extract characters into the temporary string until a null character is found
            while (code[i] != '\0')
            {
                tmp_string += code[i];
                i++;
            }
            if (current_line == 0)
            {
                std::string function_name = extract_function_name(tmp_string);
        if(function_name == "sync") sync_enabled = true;
                if (function_name.empty())
                {
                    std::cout << "ERROR: function name not found in function signature" << std::endl;
                    return;
                }
// copy function_name into argument name
#ifdef _WIN64
                strcpy_s(name, max_line_length, function_name.c_str());
#else
                strcpy(name, function_name.c_str());
#endif
                // add the null char at the end of the string
                name[function_name.size()] = '\0';
            }
 
            const std::string s = parenthesis_to_underscore(tmp_string);
            extract_node_uid(s);
 
            extract_element_keywords(s);
            function_code << s << std::endl; // Add the line to the function code
            i++;                             // Move past the null character
            current_line++;
        }
        if (python_initialized)
        {
            // initialize the global variables found in the python function
            cpp_python_initialize_global_variables();
            python_execute_code(function_code.str());
        }
        else
        {
            // print the python function to stdout and stderr
            std::cout << function_code.str() << std::endl;
        }
    }

cpp_python_sample_function()

void cpp_python_sample_function	(	char *	name,
		double *	x,
		double *	y,
		int	n )

Definition at line 1362 of file cpp_python_funct.cpp.

    {
        //write the name
        constexpr size_t N = 10000; // Number of points
        double x_max = 1e+6;
        std::vector<double> Xtmp = initial_sampling(x_max,N);
        std::vector<double> X(2*N, 0.0);
        double scale = x_max / N;
 
        // X = -Xtmp(N) .. -Xtmp(1) Xtmp(1) .. Xtmp(N)
        for (size_t i = 0; i < N; i++)
        {
            X[i] = -scale * Xtmp[N - i - 1];
        }
        for (size_t i = 0; i < N; i++)
        {
            X[i + N] = scale * Xtmp[i];
        }
        // I would like to symmetrically sample the function around 0, so I will sample the function at -X and X
        //Y of size N, filled with 0
        std::vector<double> Y(X.size(), 0.0);
        // evaluate the function at all X values using cpp_
        call_python_function1D_vectors(name, X, Y);
        //Sample the function to get n points:
        std::vector<double>  new_x = select_points(X,Y,size_t(n));
        std::vector<double>  new_y(n, 0.0);
        call_python_function1D_vectors(name, new_x, new_y);
        //sizes:
        // copy the values to the output arrays
        for (int i = 0; i < n; i++)
        {
            x[i] = static_cast<my_real>(new_x[i]);
            y[i] = static_cast<my_real>(new_y[i]);
        }
    }

cpp_python_sync()

void cpp_python_sync

(

void *

pcontext

)

Definition at line 707 of file cpp_python_funct.cpp.

    {
 
        //std::cout<<"[PYTHON] cpp_python_sync called"<<std::endl;
        if (!python_initialized || !sync_enabled)
        {
            return;
        }
        check_error(__LINE__);
 
        // cast the context to a double pointer as a PyObject
        char func_name[100];
        // func_name = "sync" 
        func_name[0] = 's';
        func_name[1] = 'y';
        func_name[2] = 'n';
        func_name[3] = 'c';
        func_name[4] = '\0';
        //std::cout<<"[PYTHON] cpp_python_sync called with function name: "<<func_name<<std::endl;
 
        PyObject *context = static_cast<PyObject *>(pcontext);
        PyObject* args = MyTuple_New(1);
        if(!args)
        {
            std::cout << "ERROR: Failed to create Python tuple." << std::endl;
        }
        My_IncRef(context);
        MyTuple_SetItem(args, 0, context);  // This steals the reference
        PyObject *pFunc = static_cast<PyObject *>(MyDict_GetItemString(pDict, func_name));
        if (!pFunc)
        {
            std::cout << "ERROR: Python function not found: " << func_name << std::endl;
            My_DecRef(args);
        }
 
        if (!MyCallable_Check(pFunc)) {
        std::cerr << "[PYTHON] Error: '" << func_name << "' is not callable" << std::endl;
        My_DecRef(args);
        }
 
        PyObject* result = MyObject_CallObject(pFunc, args);
         if (MyErr_Occurred())
         {
             // Fetch the error details
             PyObject *pType, *pValue, *pTraceback;
             MyErr_Fetch(&pType, &pValue, &pTraceback);
             if (pType)
                 std::cout << "[PYTHON] " << MyUnicode_AsUTF8(MyObject_Str(pType)) << std::endl;
             if (pValue)
                 std::cout << "[PYTHON] " << MyUnicode_AsUTF8(MyObject_Str(pValue)) << std::endl;
             if (pTraceback)
                 std::cout << "[PYTHON]: " << MyUnicode_AsUTF8(MyObject_Str(pTraceback)) << std::endl;
 
             // Decrement reference counts for error objects
             My_DecRef(pType);
             My_DecRef(pValue);
             My_DecRef(pTraceback);
             exit_with_message("ERROR: Python function failed");
         }
 
        My_DecRef(args);
        check_error(__LINE__);
 
    }

cpp_python_update_active_node()

void cpp_python_update_active_node	(	int	name_len,
		char *	name,
		double *	values )

Definition at line 1212 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            return;
        }
        check_error(__LINE__);
        double x_values, y_values, z_values;
        // loop over the map nodes_uid_to_local_id
        {
            x_values = static_cast<double>(values[0]);
            y_values = static_cast<double>(values[1]);
            z_values = static_cast<double>(values[2]);
            PyObject *py_x_values = static_cast<PyObject *>(MyFloat_FromDouble(x_values));
            PyObject *py_y_values = static_cast<PyObject *>(MyFloat_FromDouble(y_values));
            PyObject *py_z_values = static_cast<PyObject *>(MyFloat_FromDouble(z_values));
            if (!py_x_values || !py_y_values || !py_z_values)
            {
                std::cout << "ERROR: Failed to create Python objects from C++ doubles." << std::endl;
                return;
            }
            // Set the Python global variables in the main module's dictionary
            std::string x_name = std::string(name) + "X_ACTIVE_NODE";
            std::string y_name = std::string(name) + "Y_ACTIVE_NODE";
            std::string z_name = std::string(name) + "Z_ACTIVE_NODE";
            // std::cout<<" write to python: "<<x_name<<" "<<y_name<<" "<<z_name<<std::endl;
            MyDict_SetItemString(pDict, x_name.c_str(), py_x_values);
            MyDict_SetItemString(pDict, y_name.c_str(), py_y_values);
            MyDict_SetItemString(pDict, z_name.c_str(), py_z_values);
            // Release the Python objects
            if (py_x_values != nullptr)
                My_DecRef(py_x_values);
            if (py_y_values != nullptr)
                My_DecRef(py_y_values);
            if (py_z_values != nullptr)
                My_DecRef(py_z_values);
            check_error(__LINE__);
 
        }
    }

cpp_python_update_active_node_ids()

void cpp_python_update_active_node_ids	(	int	id,
		int	uid )

Definition at line 1252 of file cpp_python_funct.cpp.

    { // set ACTIVE_NODE as id, and ACTIVE_NODE_UID as uid
        if (!python_initialized)
        {
            return;
        }
        check_error(__LINE__);
        // Set the Python global variables in the main module's dictionary
        std::string id_name = "ACTIVE_NODE";
        std::string uid_name = "ACTIVE_NODE_UID";
        MyDict_SetItemString(pDict, id_name.c_str(), static_cast<PyObject *>(MyLong_FromLong(static_cast<long>(id))));
        MyDict_SetItemString(pDict, uid_name.c_str(), static_cast<PyObject *>(MyLong_FromLong(static_cast<long>(uid))));
        check_error(__LINE__);
 
    }

cpp_python_update_elemental_entity()

void cpp_python_update_elemental_entity	(	char *	name,
		double	value,
		int	uid )

Definition at line 1321 of file cpp_python_funct.cpp.

    {
        double v = static_cast<double>(value);
        check_error(__LINE__);
        PyObject *py_value = static_cast<PyObject *>(MyFloat_FromDouble(v));
        if (!py_value)
        {
            std::cout << "ERROR: Failed to create Python objects from C++ doubles." << std::endl;
        }
        std::string sname = std::string(name) + "_" + std::to_string(uid);
        // std::cout<<"[PYTHON] update elemental entity: "<<sname<<" value: "<<v<<std::endl;
        MyDict_SetItemString(pDict, sname.c_str(), py_value);
        if (py_value != nullptr)
            My_DecRef(py_value);
        check_error(__LINE__);
    }

cpp_python_update_nodal_entity()

void cpp_python_update_nodal_entity	(	int	numnod,
		int	name_len,
		char *	name,
		my_real *	values )

Definition at line 1270 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            return;
        }
 
        check_error(__LINE__);
        double x_values, y_values, z_values;
        // loop over the map nodes_uid_to_local_id
        for (auto it = nodes_uid_to_local_id.begin(); it != nodes_uid_to_local_id.end(); ++it)
        {
            int node_uid = it->first;
            int local_id = it->second;
            if(local_id > numnod-1)
            {
                std::cout << "ERROR: local_id " << local_id << " is greater than numnod " << numnod << std::endl;
                return;
            }
            x_values = static_cast<double>(values[3 * local_id]);
            y_values = static_cast<double>(values[3 * local_id + 1]);
            z_values = static_cast<double>(values[3 * local_id + 2]);
            PyObject *py_x_values = static_cast<PyObject *>(MyFloat_FromDouble(x_values));
            PyObject *py_y_values = static_cast<PyObject *>(MyFloat_FromDouble(y_values));
            PyObject *py_z_values = static_cast<PyObject *>(MyFloat_FromDouble(z_values));
            if (!py_x_values || !py_y_values || !py_z_values)
            {
                std::cout << "ERROR: Failed to create Python objects from C++ doubles." << std::endl;
                return;
            }
            // Set the Python global variables in the main module's dictionary
            std::string x_name = std::string(name) + "X_" + std::to_string(node_uid);
            std::string y_name = std::string(name) + "Y_" + std::to_string(node_uid);
            std::string z_name = std::string(name) + "Z_" + std::to_string(node_uid);
            // std::cout<<" write to python: "<<x_name<<" "<<y_name<<" "<<z_name<<std::endl;
            MyDict_SetItemString(pDict, x_name.c_str(), py_x_values);
            MyDict_SetItemString(pDict, y_name.c_str(), py_y_values);
            MyDict_SetItemString(pDict, z_name.c_str(), py_z_values);
            // Release the Python objects
            if (py_x_values != nullptr)
                My_DecRef(py_x_values);
            if (py_y_values != nullptr)
                My_DecRef(py_y_values);
            if (py_z_values != nullptr)
                My_DecRef(py_z_values);
 
            check_error(__LINE__);
        }
    }

cpp_python_update_reals()

void cpp_python_update_reals	(	char *	basename,
		int *	uid,
		my_real *	reals,
		int	num_reals )

Definition at line 983 of file cpp_python_funct.cpp.

    {
        // add BASENAME_$UID = reals[i] to the python dictionary
        if (!python_initialized)
        {
            return;
        }
 
        PyGILState_STATE gstate = MyGILState_Ensure();
        check_error(__LINE__);
        // Convert C++ doubles to Python objects
        for (int i = 0; i < num_reals; i++)
        {
            double value = static_cast<double>(reals[i]);
            PyObject *py_value = static_cast<PyObject *>(MyFloat_FromDouble(value));
            if (!py_value)
            {
                std::cerr << "ERROR: Failed to create Python object from C++ double." << std::endl;
                return;
            }
            // Create the key in the format BASENAME_$UID
            std::string key = std::string(basename) + "_" + std::to_string(uid[i]);
            // Set the item in the Python dictionary
            MyDict_SetItemString(pDict, key.c_str(), py_value);
            // Release the Python object
            My_DecRef(py_value);
        }
        // Release the Python object
        check_error(__LINE__);
        MyGILState_Release(gstate);
    }

cpp_python_update_sensors()

void cpp_python_update_sensors	(	int *	types,
		int *	uids,
		int *	statuses,
		double *	results,
		int *	num_sensors )

Definition at line 1115 of file cpp_python_funct.cpp.

    {
        //std::cout << "[PYTHON] update sensors" << std::endl;
        constexpr int sensor_python = 40;    // PYTHON
        constexpr int sensor_energy = 14;    // ENERGY
        constexpr int sensor_time = 0;       // TIME
        constexpr int sensor_accel = 1;      // ACCE
        constexpr int sensor_dist = 2;       // DISP
        constexpr int sensor_sens = 3;       // SENS
        constexpr int sensor_and = 4;        // AND
        constexpr int sensor_or = 5;         // OR
        constexpr int sensor_inter = 6;      // INTER
        constexpr int sensor_rwall = 7;      // RWALL
        constexpr int sensor_not = 8;        // NOT
        constexpr int sensor_vel = 9;        // VEL
        constexpr int sensor_gauge = 10;     // GAUGE
        constexpr int sensor_rbody = 11;     // RBODY
        constexpr int sensor_sect = 12;      // SECT
        constexpr int sensor_work = 13;      // WORK
        constexpr int sensor_dist_surf = 15; // DIST_SURF
        constexpr int sensor_hic = 16;       // HIC
        constexpr int sensor_temp = 17;      // TEMP
        // create a python dictionary with associating type to name
        const std::map<int, std::string> sensor_type_to_name = {
            {sensor_python, "PYTHON"},
            {sensor_energy, "ENERGY"},
            {sensor_time, "TIME"},
            {sensor_accel, "ACCE"},
            {sensor_dist, "DIST"},
            {sensor_sens, "SENS"},
            {sensor_and, "AND"},
            {sensor_or, "OR"},
            {sensor_inter, "INTER"},
            {sensor_rwall, "RWALL"},
            {sensor_not, "NOT"},
            {sensor_vel, "VEL"},
            {sensor_gauge, "GAUGE"},
            {sensor_rbody, "RBODY"},
            {sensor_sect, "SECT"},
            {sensor_work, "WORK"},
            {sensor_dist_surf, "DIST_SURF"},
            {sensor_hic, "HIC"},
            {sensor_temp, "TEMP"}};
 
        if (!python_initialized)
        {
            return;
        }
        check_error(__LINE__);
        std::ostringstream oss;
        oss << std::setprecision(std::numeric_limits<double>::max_digits10) << std::hexfloat;
        oss << "sensors = { \n";
        for (int i = 0; i < *num_sensors; i++)
        {
            int type = types[i];
            int uid = uids[i];
            int status = statuses[i];
            oss << "    " << uid << " : { 'type' : '" << sensor_type_to_name.at(type) << "', 'status' : " << status;
            // depending on the type, the results are different
            if (type == sensor_energy)
            { // Eint = results[2*(i-1)], Ekin = results[2*(i-1)+1]
                oss << ", 'Eint' :  float.fromhex('" << results[2 * i] << "'), 'Ekin' : float.fromhex('" << results[2 * i + 1] << "') ";
            }
            else if (type == sensor_inter || type == sensor_rwall)
            { // Force = results[2*(i-1)]
                oss << ", 'Force' :  float.fromhex('" << results[2 * i] << "') ";
            }
            else if (type == sensor_dist || type == sensor_dist_surf)
            {
                oss << ", 'Distance' :  float.fromhex('" << results[2 * i] << "') ";
            }
            else if (type == sensor_gauge)
            {
                oss << ", 'Pressure' :  float.fromhex('" << results[2 * i] << "') ";
            }
            if (i < *num_sensors - 1)
            {
                oss << "},\n";
            }
            else
            {
                oss << "}\n";
            }
        }
        oss << "\n}";
 
        std::string code = oss.str();
        // std::cout<< "Generated code: "<<code<<std::endl;
        python_execute_code(code);
        // check for errors
        check_error(__LINE__);
 
    }

cpp_python_update_time()

void cpp_python_update_time	(	my_real	TIME,
		my_real	DT )

Definition at line 1015 of file cpp_python_funct.cpp.

    {
        if (!python_initialized)
        {
            // std::cerr << "ERROR: Python is not initialized." << std::endl;
            return;
        }
        PyGILState_STATE gstate = MyGILState_Ensure();
        check_error(__LINE__);
        if (!pDict)
        {
            std::cerr << "ERROR: Python main module dictionary not initialized." << std::endl;
            MyGILState_Release(gstate);
            return;
        }
        // donvert TIME and DT to double precision in TIME2 and DT2
        double TIME2 = static_cast<double>(TIME);
        double DT2 = static_cast<double>(DT);
        // Convert C++ doubles to Python objects
        PyObject *py_TIME = static_cast<PyObject *>(MyFloat_FromDouble(TIME2));
        PyObject *py_DT = static_cast<PyObject *>(MyFloat_FromDouble(DT2));
 
        if (!py_TIME || !py_DT)
        {
            std::cerr << "ERROR: Failed to create Python objects from C++ doubles." << std::endl;
            MyGILState_Release(gstate);
            return;
        }
 
        // Set the Python global variables in the main module's dictionary
        MyDict_SetItemString(pDict, "TIME", py_TIME);
        MyDict_SetItemString(pDict, "DT", py_DT);
 
        // Release the Python objects
        if (py_TIME != nullptr)
            My_DecRef(py_TIME);
        if (py_DT != nullptr)
            My_DecRef(py_DT);
        check_error(__LINE__);
        MyGILState_Release(gstate);
    }

element_parenthesis_to_underscore()

template<std::size_t N>

std::string element_parenthesis_to_underscore	(	const std::string &	input,
		const std::array< const char *, N > &	keywords )

Definition at line 86 of file cpp_python_funct.cpp.

{
    std::string output = input;
    for (const auto &keyword : keywords)
    {
        std::regex pattern(std::string(keyword) + R"(\‍(\s*(\d+)\s*\))");
        output = std::regex_replace(output, pattern, std::string(keyword) + "_$1");
    }
    return output;
}

exit_with_message()

void exit_with_message

(

const char *

message

)

Definition at line 201 of file cpp_python_funct.cpp.

{
    std::cout << message << std::endl;
    std::cerr << message << std::endl;
    My_Finalize();
    exit(1);
}

extract_element_keywords()

void extract_element_keywords

(

const std::string &

input

)

Definition at line 142 of file cpp_python_funct.cpp.

{
    for (const auto &keyword : ELEMENT_KEYWORDS)
    {
        // std::regex pattern(std::string(keyword) + R"(_(\d+))");
        std::regex pattern(std::string(R"((?:[^a-zA-Z0-9]|^))") + std::string(keyword) + R"(_(\d+))");
        auto words_begin = std::sregex_iterator(input.begin(), input.end(), pattern);
        auto words_end = std::sregex_iterator();
        for (std::sregex_iterator i = words_begin; i != words_end; ++i)
        {
            std::smatch match = *i;
            int id = std::stoi(match.str(1));
            element_variables.emplace(id, keyword);
            // std::cout<<"[PYTHON] keyword found: "<<keyword<<" id: "<<id<<std::endl;
        }
    }
}

extract_function_name()

std::string extract_function_name

(

const std::string &

signature

)

Definition at line 414 of file cpp_python_funct.cpp.

{
    if (signature.substr(0, 3) != "def")
    {
        std::cout << "ERROR in Python function: signature does not start with 'def'" << std::endl;
        return "";
    }
    std::size_t startPos = signature.find_first_not_of(" ", 3);
    if (startPos == std::string::npos)
    {
        std::cout << "ERROR in Python function: function name not found" << std::endl;
        return "";
    }
    // Find the index of the opening parenthesis
    std::size_t endPos = signature.find("(", startPos);
    if (endPos == std::string::npos)
    {
        std::cout << "ERROR in Python function: opening parenthesis not found" << std::endl;
        return "";
    }
    // Extract the function name
    return signature.substr(startPos, endPos - startPos);
}

extract_node_uid()

void extract_node_uid

(

const std::string &

input

)

Definition at line 111 of file cpp_python_funct.cpp.

{
    //    Coordinates     CX_n,  CY_n,  CZ_n
    //    Displacement    DX_n,  DY_n,  DZ_n
    //    Acceleration    AX_n,  AY_n,  AZ_n
    //    DisplacementR  DRX_n, DRY_n, DRZ_n
    //    Velocity        VX_n,  VY_n , VZ_n
    //    VelocityR      VRX_n, VRY_n, VRZ_n
    //    AccelerationR  ARX_n, ARY_n, ARZ_n
    // Regex pattern: non-alphanumeric or start of line, followed by A[XYZ] and underscore and numbers
    // std::cout<<"input: "<<input<<std::endl;
    std::regex pattern(R"((?:[^a-zA-Z0-9]|^)[ACDV][R]*[XYZ]_[0-9]+)");
 
    auto begin = std::sregex_iterator(input.begin(), input.end(), pattern);
    auto end = std::sregex_iterator();
 
    for (auto i = begin; i != end; ++i)
    {
 
        auto match = *i;
        std::string match_str = match.str();
        size_t underscore_pos = match_str.find('_');
        if (underscore_pos != std::string::npos)
        {
            int number = std::stoi(match_str.substr(underscore_pos + 1));
            nodes_uid.insert(number);
        }
    }
}

load_functions()

template<typename T>

void load_functions	(	T	h,
		bool &	python_initialized )

Definition at line 163 of file cpp_python_funct.cpp.

{
    python_initialized = true;
    load_function(h, "Py_Initialize", My_Initialize, python_initialized);
    load_function(h, "Py_IsInitialized", My_IsInitialized, python_initialized);
    load_function(h, "Py_Finalize", My_Finalize, python_initialized);
    load_function(h, "PyDict_GetItemString", MyDict_GetItemString, python_initialized);
    load_function(h, "PyCallable_Check", MyCallable_Check, python_initialized);
    load_function(h, "PyTuple_New", MyTuple_New, python_initialized);
    load_function(h, "PyFloat_FromDouble", MyFloat_FromDouble, python_initialized);
    load_function(h, "PyObject_CallObject", MyObject_CallObject, python_initialized);
    load_function(h, "PyImport_AddModule", MyImport_AddModule, python_initialized);
    load_function(h, "PyModule_GetDict", MyModule_GetDict, python_initialized);
    load_function(h, "PyRun_SimpleString", MyRun_SimpleString, python_initialized);
    load_function(h, "PyTuple_SetItem", MyTuple_SetItem, python_initialized);
    load_function(h, "PyList_SetItem", MyList_SetItem, python_initialized);
    load_function(h, "Py_DecRef", My_DecRef, python_initialized);
    load_function(h, "Py_IncRef", My_IncRef, python_initialized);
    load_function(h, "PyFloat_AsDouble", MyFloat_AsDouble, python_initialized);
    load_function(h, "PyDict_SetItemString", MyDict_SetItemString, python_initialized);
    load_function(h, "PyErr_Fetch", MyErr_Fetch, python_initialized);
    load_function(h, "PyErr_Display", MyErr_Display, python_initialized);
    load_function(h, "PyErr_Occurred", MyErr_Occurred, python_initialized);
    load_function(h, "PyObject_Str", MyObject_Str, python_initialized);
    load_function(h, "PyUnicode_AsUTF8", MyUnicode_AsUTF8, python_initialized);
    load_function(h, "PyDict_New", MyDict_New, python_initialized);
    load_function(h, "PyList_New", MyList_New, python_initialized);
    load_function(h, "PyErr_Clear", MyErr_Clear, python_initialized);
    load_function(h, "PyLong_FromLong", MyLong_FromLong, python_initialized);
    load_function(h, "PyLong_FromVoidPtr", MyLong_FromVoidPtr, python_initialized);
    load_function(h, "PyUnicode_FromString", MyUnicode_FromString, python_initialized);
    load_function(h, "PyEval_SaveThread", MyEval_SaveThread, python_initialized);
    load_function(h, "PyEval_RestoreThread", MyEval_RestoreThread, python_initialized);
    load_function(h, "PyGILState_Ensure", MyGILState_Ensure, python_initialized);
    load_function(h, "PyGILState_Release", MyGILState_Release, python_initialized);
}

node_parenthesis_to_underscore()

std::string node_parenthesis_to_underscore

(

const std::string &

input

)

Definition at line 97 of file cpp_python_funct.cpp.

{
    std::regex pattern(R"(\b(DX|DY|DZ|AX|AY|AZ|CX|CY|CZ|VX|VY|VZ|ARX|ARY|ARZ|VRX|VRY|VRZ|DRX|DRY|DRZ|MONVOL_VOL|MONVOL_T|MONVOL_A|MONVOL_P)\b\s*\‍(\s*(\d+|ACTIVE_NODE)\s*\))");
    std::string result = std::regex_replace(input, pattern, "$1_$2");
    return result;
}

parenthesis_to_underscore()

std::string parenthesis_to_underscore

(

const std::string &

input

)

Definition at line 104 of file cpp_python_funct.cpp.

{
    std::string result = node_parenthesis_to_underscore(input);
    return element_parenthesis_to_underscore(result, ELEMENT_KEYWORDS);
}

py_begin_allow_threads()

PyThreadState * py_begin_allow_threads

(

)

Definition at line 1481 of file cpp_python_funct.cpp.

                                        {
    return MyEval_SaveThread();
}

py_end_allow_threads()

void py_end_allow_threads

(

PyThreadState *

saved_state

)

Definition at line 1485 of file cpp_python_funct.cpp.

                                                      {
    MyEval_RestoreThread(saved_state);
}

python_execute_code()

void python_execute_code

(

const std::string &

code

)

Definition at line 407 of file cpp_python_funct.cpp.

{
    MyRun_SimpleString(code.c_str());
    check_error(__LINE__);
}

python_load_library()

void python_load_library

(

)

Definition at line 555 of file cpp_python_funct.cpp.

{
    python_initialized = false;
    handle = nullptr;
    // clear the previous errors in dlerror:
    dlerror();
    // Get the string from the environment variable RAD_PYTHON_PATH
    const char *python_path = getenv("RAD_PYTHON_PATH");
    if (python_path == nullptr)
    {
        python_initialized = false;
    }
    else
    {
        python_initialized = try_load_library(python_path);
    }
 
    // if RAD_PYTHON_PATH was not found, or if the library was not loaded, try find PYTHONHOME
    if (!python_initialized)
    {
        python_path = getenv("PYTHONHOME");
        if (python_path)
        {
            std::cout << "INFO: searching for python library in PYTHONHOME" << std::endl;
            std::vector<std::string> possible_dirs = {"/lib64/", "/lib/", "/usr/lib64/", "/usr/lib/", "/usr/lib/x86_64-linux-gnu/"};
            for (const auto &dir : possible_dirs)
            {
                std::string dir_path = std::string(python_path) + dir;
                DIR *d = opendir(dir_path.c_str());
                if (d)
                {
                    struct dirent *entry;
                    while ((entry = readdir(d)) != nullptr)
                    {
                        std::string filename(entry->d_name);
                        if (filename.find("libpython") == 0 && filename.find(".so") != std::string::npos)
                        {
                            python_initialized = try_load_library(dir_path + filename);
                            if (python_initialized)
                            {
                                closedir(d);
                                return;
                            }
                        }
                    }
                    closedir(d);
                }
            }
        }
    }
    // if we reach this point, we did not find any python library
    // we look into some default locations
    std::cout << " INFO: searching for python library in default locations LD_LIBRARY_PATH" << std::endl;
    std::vector<std::string> possible_names = {
        "libpython3.12.so",
        "libpython3.11.so",
        "libpython3.10.so",
        "libpython3.9.so",
        "libpython3.8.so",
        "libpython3.7.so",
        "libpython3.6.so",
        "libpython3.5.so",
        "libpython3.4.so",
        "libpython3.3.so",
        "libpython3.2.so",
        "libpython3.1.so",
        "libpython3.so",
        "libpython3.0.so",
        "libpython2.7.so"};
    for (const auto &name : possible_names)
    {
        std::string libname = name;
        python_initialized = try_load_library(libname);
        if (python_initialized)
        {
            return;
        }
    }
}

python_signal_handler()

void python_signal_handler

(

int

signum

)

Definition at line 234 of file cpp_python_funct.cpp.

                                       {
    std::cout << "[PYTHON] Caught signal " << signum << std::endl;
    std::cerr << "[PYTHON] Caught signal " << signum << std::endl;
    //How to flush the output buffers before exiting
    std::cout << std::flush;
    std::cerr << std::flush;
    std::cerr.flush();
    std::cout.flush();
    //My_Finalize();
    std::exit(signum);
}

try_load_library()

bool try_load_library

(

const std::string &

path

)

Definition at line 533 of file cpp_python_funct.cpp.

{
    bool python_initialized = false;
    handle = dlopen(path.c_str(), RTLD_LAZY |RTLD_GLOBAL);
    if (handle)
    {
        std::cout << "Trying python library: " << path << std::endl;
        load_functions(handle, python_initialized);
        if (python_initialized)
        {
            std::cout << "INFO: Python library found at " << path << std::endl;
            My_Initialize();
            if (!My_IsInitialized())
            {
                std::cout << "ERROR: My_Initialize failed" << std::endl;
                python_initialized = false;
            }
        }
    }
    return python_initialized;
}

Variable Documentation

element_variables

KeywordPairs element_variables

Definition at line 80 of file cpp_python_funct.cpp.

handle

void* handle = nullptr

Definition at line 67 of file cpp_python_funct.cpp.

nodes_uid

std::set<int> nodes_uid

Definition at line 77 of file cpp_python_funct.cpp.

nodes_uid_to_local_id

std::map<int, int> nodes_uid_to_local_id

Definition at line 79 of file cpp_python_funct.cpp.

pDict

PyObject* pDict = nullptr

Definition at line 71 of file cpp_python_funct.cpp.

persistent_arg

PyObject* persistent_arg = nullptr

static

Definition at line 82 of file cpp_python_funct.cpp.

persistent_dict

PyObject* persistent_dict = nullptr

static

Definition at line 81 of file cpp_python_funct.cpp.

python_initialized

bool python_initialized = false

Definition at line 72 of file cpp_python_funct.cpp.

sync_enabled

bool sync_enabled = false

Definition at line 73 of file cpp_python_funct.cpp.