ruspectroscopy-tools 0.0.1__tar.gz

ruspectroscopy_tools-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 jacubillos10
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ruspectroscopy_tools-0.0.1/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: ruspectroscopy_tools
+Version: 0.0.1
+Summary: A simple tool that generates Gamma matrix and E matrix, given the elastic constants, mass, dimansions and shape of a sample, in Resonant Ultrasound Spectroscopy. Use scipy.linalg.eigh(...) to solve the forward problem
+Home-page: https://github.com/jacubillos10/RUSpectroscopy_Tools
+Author: Alejandro Cubillos
+Author-email: alejandro4cm@outlook.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# RUSpectroscopy_tools
+
+A C extension module for generating Gamma and Epsilon matrices, in Resonant Ultrasound Spectroscopy.
+
+## Authors
+
+- Alejandro Cubillos - alejandro4cm@outlook.com
+- Manuela Rivas
+- Julián Rincón 
+
+## Import: 
+```python
+from rusmodules import rus
+```
+
+## Usage Example
+```python
+gamma = rus.gamma_matrix(N, C, geometry, shape)
+E = rus.E_matrix(N, shape) 
+```
+
+# Where: 
+* N <int> represents the maximim grade of the polynomials of the basis functions 
+* C <np.array> 6x6 matrix with the elastic constants
+* geometry <np.array> (3,) shape array containing the dimensions of the sample
+* shape <int> 0 for parallelepiped, 1 for cylinder and 2 to spheroid
+
+Solve forward problem with scipy:
+Eigenvalues return $m\omega^2$
+```python
+eigenvals, eigenvects = scipy.linalg.eigh(a = gamma, b = E)
+omega = (eigenvals[6:]/m)**(1/2) #remember the fisrt 6 eigenvalues must be near zero
+frequencies = omega/(2*np.pi)
+``` 
+
+## Installation: 
+```bash
+pip3 install ruspectroscopy_tools

ruspectroscopy_tools-0.0.1/README.md

@@ -0,0 +1,38 @@
+# RUSpectroscopy_tools
+
+A C extension module for generating Gamma and Epsilon matrices, in Resonant Ultrasound Spectroscopy.
+
+## Authors
+
+- Alejandro Cubillos - alejandro4cm@outlook.com
+- Manuela Rivas
+- Julián Rincón 
+
+## Import: 
+```python
+from rusmodules import rus
+```
+
+## Usage Example
+```python
+gamma = rus.gamma_matrix(N, C, geometry, shape)
+E = rus.E_matrix(N, shape) 
+```
+
+# Where: 
+* N <int> represents the maximim grade of the polynomials of the basis functions 
+* C <np.array> 6x6 matrix with the elastic constants
+* geometry <np.array> (3,) shape array containing the dimensions of the sample
+* shape <int> 0 for parallelepiped, 1 for cylinder and 2 to spheroid
+
+Solve forward problem with scipy:
+Eigenvalues return $m\omega^2$
+```python
+eigenvals, eigenvects = scipy.linalg.eigh(a = gamma, b = E)
+omega = (eigenvals[6:]/m)**(1/2) #remember the fisrt 6 eigenvalues must be near zero
+frequencies = omega/(2*np.pi)
+``` 
+
+## Installation: 
+```bash
+pip3 install ruspectroscopy_tools

ruspectroscopy_tools-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel", "numpy", "schipy"]
+build-backend = "setuptools.build_meta"

ruspectroscopy_tools-0.0.1/rusmodules/compile_data_generator.py

@@ -0,0 +1,49 @@
+import numpy as np
+from numba import njit, types
+from numba.pycc import CC
+cc = CC('data_generator')
+
+@njit("f8[:,:](f8,f8,i8)")
+@cc.export("generate_C_matrix", "f8[:,:](f8,f8,i8)")
+def generate_C_matrix(C_min, C_max, crystal_structure):
+    C = np.zeros((6,6))
+    C_prc = np.zeros(3)
+    C_sec = np.zeros(6)
+    C_ter = np.zeros(12)
+    d_struc = np.array([[3,6],[2,4],[1,2],[1,1]])
+    n_p = d_struc[crystal_structure,0]
+    n_s = d_struc[crystal_structure,1]
+    C_prc_raw = np.random.uniform(C_min, C_max, n_p)
+    C_max_sec = 0.5*min(C_prc)
+    C_sec_raw = np.random.uniform(C_min, C_max_sec, n_s)
+    if crystal_structure == 1:
+        C_prc[0:2] = C_prc_raw[0]
+        C_prc[2] = C_prc_raw[1]
+        C_sec[0] = C_sec_raw[0]
+        C_sec[1:3] = C_sec_raw[1]
+        C_sec[3:5] = C_sec_raw[2]
+        C_sec[5] = C_sec_raw[3]
+    elif crystal_structure == 2:
+        C_prc[:] = C_prc_raw[0]
+        C_sec[0:3] = C_sec_raw[0]
+        C_sec[3:] = C_sec_raw[1]
+    elif crystal_structure == 3:
+        C_prc[:] = C_prc_raw[0]
+        C_sec[0:3] = C_prc_raw[0] - 2*C_sec_raw[0]
+        C_sec[3:] = C_sec_raw[0]
+    else: 
+        C_prc = C_prc_raw
+        C_sec = C_sec_raw
+    #end if 
+    for i in range(3):
+        for j in range(3):
+            C[i,j] = C_prc[i] if i == j else C_sec[i+j-1]
+            C[i+3,j+3] = C_sec[i+3] if i == j else 0
+        #fin for 
+    #fin if
+    
+    return C
+#end function
+
+if __name__ == "__main__":
+    cc.compile()

ruspectroscopy_tools-0.0.1/rusmodules/compile_rus_module.py

@@ -0,0 +1,208 @@
+import numpy as np
+from numba import njit, types
+from numba.pycc import CC
+
+cc = CC('rus_old')
+@njit("f8(i8)")
+@cc.export("fact2", "f8(i8)")
+def fact2(N):
+    if N < -1:
+        raise ArithmeticError("Está entrando en el doble factorial un númerno menor a -1")
+    elif (N == 0 or N == -1 or N == 1):
+        return 1
+    else:
+        prod = 1.0
+        for i in range(N,1,-2):
+            prod = prod*i
+        #fin for 
+        return prod
+    #fin if
+#fin función
+
+@njit("i8(i8,i8)")
+@cc.export("it_c", "i8(i8,i8)")
+def it_c(i,j):
+    """
+    This function changes the double index convention for single index convention in the elastic constant matrix C.
+    00 is changed to 0, 11 is changed to 1, 22 is changed to 2, 
+    01 or 10 is changed to 5
+    02 or 20 is changed to 4
+    12 or 21 is changed to 3
+
+    @Input i <int>: first index to be changed
+    @Input j <int>: second index to be changed 
+    @Return index <int>: New index 
+    """
+    if i == j:
+        index = i
+    else:
+        index = 6 - (i + j)
+    #fin if
+    return index
+#fin función
+
+@njit("f8(i8[:],i8[:],i8,i8,i8,i8,f8[:,:],f8[:],i8)")
+@cc.export("generate_term_in_gamma_matrix_element", "f8(i8[:],i8[:],i8,i8,i8,i8,f8[:,:],f8[:],i8)")
+def generate_term_in_ſ(exp_index1, exp_index2, i1, i2, j1, j2, C, geo_par, options):
+    """
+    This function generates one term of the sum composing an element of the matrix ſ. See equation 11 in Leisure 1997. Be sure geo_par
+    to be an array of floats NOT INTEGERS!!
+    @Input exp_index1 <np.array>: Exponents lambda, mu and nu of the p element in the matrix and i1 index
+    @Input exp_index2 <np.array>: Exponents lambda, mu and nu of the q element in the matrix and i2 index
+    @Input i1 <int>: index i of the expresion in eq 11. 0 to x, 1 to y, 2 to z
+    @Input i2 <int>: index i' of the expresion in eq 11. 0 to x, 1 to y, 2 to z
+    @Input j1 <int>: index j of the sum in equation 11. 0 to x, 1 to y, 2 to z
+    @Input j2 <int>: index j' of the sum in equation 11. 0 to x, 1 to y, 2 to z
+    @Input C <np.array>: Matrix with the elastic constants
+    @Input geo_par <np.array>: Geometric parameters of the sample, such as Lx, Ly, Lz. Be sure to enter a array of floats NOT INTEGERS!
+    @Return <float>: Returns a term in the equation 11 of Leisure 1997
+    """
+    array_j1 = np.zeros(3)
+    array_j2 = np.zeros(3)
+    array_j1[j1] = 1
+    array_j2[j2] = 1
+    coeff = exp_index1 + exp_index2 + 1 - array_j1 - array_j2
+    Q = (1 - (-1)**coeff[0])*(1 - (-1)**coeff[1])*(1 - (-1)**coeff[2])
+    S = exp_index1[j1]*exp_index2[j2]
+    #geo_par = np.array(geo_par, dtype = float)
+    if Q == 0 or S == 0:
+        return 0
+    #fin if 
+    if options == 1:
+        R = (fact2(coeff[0] - 2)*fact2(coeff[1] - 2))/(fact2(coeff[0] + coeff[1])*coeff[2])
+        alpha = np.pi/4
+    elif options == 2:
+        R = (fact2(coeff[0] - 2)*fact2(coeff[1] - 2)*fact2(coeff[2] - 2))/(fact2(sum(coeff)))
+        alpha = np.pi/6
+    else:
+        R = 1/(coeff[0]*coeff[1]*coeff[2])
+        alpha = 1
+    #fin if 
+    #P = 4*C[it_c(i1,j1),it_c(i2,j2)]/(geo_par[j1]*geo_par[j2])
+    if j1 == j2:
+        beta = np.prod(geo_par)/(geo_par[j1]**2)
+    else:
+        beta = geo_par[3-j1-j2]
+    #fin if 
+    P = 4*alpha*C[it_c(i1,j1),it_c(i2,j2)]*beta
+    return P*Q*S*R
+#fin función    
+
+@njit("f8(i8,i8,i8[:],i8[:],f8[:,:],f8[:],i8)")
+@cc.export("generate_matrix_element_gamma", "f8(i8,i8,i8[:],i8[:],f8[:,:],f8[:],i8)")
+def generate_matrix_element_ſ(i1, i2, exp_index1, exp_index2, C, geo_par, options):
+    """
+    This function generates a matrix element of ſ, given two axis indexes (0 is x, 1 is y, 2 is z), two arrays of indexes which
+    Contain the exponents of the power series, the elastic constants and the geometric parameters
+    @Input i1 <int>: index i of the expresion in eq 11. 0 to x, 1 to y, 2 to z
+    @Input i2 <int>: index i' of the expresion in eq 11. 0 to x, 1 to y, 2 to z
+    @Input exp_index1 <np.array>: Exponents lambda, mu and nu of the p element in the matrix and i1 index
+    @Input exp_index2 <np.array>: Exponents lambda, mu and nu of the q element in the matrix and i2 index
+    @Input C <np.array>: Matrix with the elastic constants
+    @Input geo_par <np.array>: Geometric parameters of the sample, such as Lx, Ly, Lz. Be sure to enter a array of floats NOT INTEGERS!
+    @Return <float>: Returns a matrix element ſ
+    """
+    acum = 0
+    for j1 in range(3):
+        for j2 in range(3):
+            acum += generate_term_in_ſ(exp_index1, exp_index2, i1, i2, j1, j2, C, geo_par, options)
+        # fin for 
+    #fin for
+    return acum
+#fin función
+
+@njit("f8(i8,i8,i8[:],i8[:],i8)")
+@cc.export("generate_matrix_element_E", "f8(i8,i8,i8[:],i8[:],i8)")
+def generate_matrix_element_E(i1, i2, exp_index1, exp_index2, options):
+    """
+    This function generates a matrix element of E, given two axis indexes (0 is x, 1 is y, 2 is z), two arrays of indexes which
+    contain the exponents of the power series, the elastic constants and the geometric parameters. 
+    """
+    if i1 != i2:
+        return 0
+    else:
+        coeff = exp_index1 + exp_index2 + 1
+        Q = (1 - (-1)**coeff[0])*(1 - (-1)**coeff[1])*(1 - (-1)**coeff[2])
+        if Q == 0:
+            return 0
+        #fin if
+        if options == 1:
+            R = (fact2(coeff[0] - 2)*fact2(coeff[1] - 2))/(fact2(coeff[0] + coeff[1])*coeff[2])
+        elif options == 2:
+            R = (fact2(coeff[0] - 2)*fact2(coeff[1] - 2)*fact2(coeff[2] - 2))/(fact2(sum(coeff)))
+        else:
+            R = 1/(coeff[0]*coeff[1]*coeff[2])
+        #fin if
+        #print("Numba coeff: ", coeff, " fact 0: ", fact2(coeff[0]), " fact 1: ", fact2(coeff[1]), " fact 2: ", fact2(coeff[2]))
+        #print("Operacion 1 numba: ", (fact2(coeff[0] - 2)*fact2(coeff[1] - 2)))
+        #print("Operacion 2 numba: ", (fact2(coeff[0] + coeff[1])*coeff[2]))
+        #print("numba's 35!!= ", fact2(35))
+        return Q*R
+    #fin if
+#fin funcion
+
+@njit("i8[:,:](i8)")
+@cc.export("generate_combinations", "i8[:,:](i8)")
+def generate_combinations(N):
+    R = int((1/6) * (N + 1) * (N + 2) * (N + 3))
+    combi = np.zeros((R,3), dtype=np.int64)
+    l = 0
+    for n in range(N + 1):
+        for i in range(n + 1):
+            for j in range(n + 1 - i):
+                k = n - i - j
+                combi[l,:] = np.array([i, j, k])
+                l += 1
+        #fin for 
+    #fin for 
+    return combi
+#fin funcion
+
+@cc.export("E_matrix", "f8[:,:](i8,i8)")
+def E_matrix(N, options):
+    comb = generate_combinations(N)
+    R = len(comb[:,0])
+    E = np.zeros((3*R,3*R), dtype = np.float64)
+    for i in range(3):
+        for j in range(3):
+            for lm in range(R):
+                for lf in range(R):
+                    exp_index1 = comb[lm,:]
+                    exp_index2 = comb[lf,:]
+                    E[(i*R + lm), (j*R + lf)] = generate_matrix_element_E(i, j, exp_index1, exp_index2, options)
+                #fin for
+            #fin for
+        #fin for
+    #fin for 
+    return E
+#fin función
+                    
+@cc.export("gamma_matrix", "f8[:,:](i8,f8[:,:],f8[:],i8)")
+def gamma_matrix(N, C, geo_par, options):
+    comb = generate_combinations(N)
+    R = len(comb[:,0])
+    gamma = np.zeros((3*R,3*R), dtype = np.float64)
+    for i in range(3):
+        for j in range(3):
+            for lm in range(R):
+                for lf in range(R):
+                    exp_index1 = comb[lm,:]
+                    exp_index2 = comb[lf,:]
+                    gamma[(i*R + lm), (j*R + lf)] = generate_matrix_element_ſ(i, j, exp_index1, exp_index2, C, geo_par, options)
+                #fin for 
+            #fin for 
+        #fin for 
+    #fin for
+    #print("Hello from numba")
+    return gamma
+#fin función 
+
+
+if __name__ == "__main__":
+    cc.compile()
+    #C_const = np.genfromtxt('constantes.csv', delimiter=',', skip_header=0, dtype=float)
+    #aa = generate_term_in_ſ(np.array([1, 0, 0]), np.array([0, 0, 1]), 0, 1, 0, 2, C_const, np.array([1.0, 1.0, 1.0]))
+    #print(aa)
+    #aac = generate_matrix_element_ſ(0, 1, np.array([1,0,0]), np.array([0,0,1]), C_const, np.array([1.0,1.0,1.0]))
+    #print(aac/8)
+    #print(gamma_matrix(1, C_const, np.array([1.0, 1.0, 1.0])))

ruspectroscopy_tools-0.0.1/rusmodules/rus.c

@@ -0,0 +1,361 @@
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <stdio.h>
+#include <stdlib.h>
+#include <Python.h>
+#include <numpy/arrayobject.h>
+#include <math.h>
+#include <omp.h>
+
+double fact2(int N)
+{
+	if (N < -1)
+	{
+		printf("Arithmetic Error: Cannot get double factorial of an input less than -1\n");
+		exit(EXIT_FAILURE);
+	} else if ( N == 0 || N == -1 || N == 1){
+		return 1.0;
+	} else {
+		double prod = 1.0;
+		for (int i = N; i > 1; i-=2)
+		{
+			prod = prod * i;
+			//printf("i: %i, prod: %li\n", i, prod);
+		}
+		return prod;
+	}
+}
+
+int it_c(int i, int j)
+{
+	int index;
+	if (i == j) { index = i;}
+	else {index = 6 - (i +j);}
+	return index;
+}
+
+double generate_term_in_gamma_matrix_element(int exp_index1[3], int exp_index2[3], int i1, int i2, int j1, int j2, double C[6][6], double geo_par[3], int options)
+{
+	int coeff[3], Q, S;
+	int array_j1[3] = {0,0,0};
+	int array_j2[3] = {0,0,0};
+	double R, alpha, beta, P;
+	array_j1[j1] = 1;
+	array_j2[j2] = 1;
+	for (int i = 0; i < 3; i++) {coeff[i] = exp_index1[i] + exp_index2[i] + 1 - array_j1[i] - array_j2[i];}
+	Q = (1 - (int)pow(-1,coeff[0]))*(1 - (int)pow(-1,coeff[1]))*(1 - (int)pow(-1,coeff[2]));
+	S = exp_index1[j1]*exp_index2[j2];
+	if (Q == 0 || S == 0) 
+	{
+		return 0;
+	}
+	if (options == 1)
+	{
+		R = (0.0+fact2(coeff[0] - 2)*fact2(coeff[1] - 2))/(fact2(coeff[0] + coeff[1])*coeff[2]);
+		alpha = M_PI/4;
+	} else if (options == 2) {
+		R = (0.0+fact2(coeff[0] - 2)*fact2(coeff[1] - 2)*fact2(coeff[2] - 2))/fact2(coeff[0] + coeff[1] + coeff[2]);
+		alpha = M_PI/6;
+	} else {
+		R = 1.0/(coeff[0]*coeff[1]*coeff[2]);
+		alpha = 1.0;
+	}
+	if (j1 == j2) {beta = (geo_par[0]*geo_par[1]*geo_par[2])/pow(geo_par[j1],2);}
+	else {beta = geo_par[3-j1-j2];}
+	P = 4*alpha*C[it_c(i1,j1)][it_c(i2,j2)]*beta;
+	//for (int i = 0; i < 6; i++){ for (int j = 0; j < 6; j++) {printf("%f ", C[i][j]);} printf("\n");}
+	//for (int i = 0; i < 3; i++) {printf("%f, %i, %i\n", geo_par[i], exp_index1[i], exp_index2[i]); }
+	return P*Q*S*R;
+}
+
+double generate_gamma_matrix_element(int i1, int i2, int exp_index1[3], int exp_index2[3], double C[6][6], double geo_par[3], int options)
+{
+	double suma = 0.0;
+	for (int j = 0; j < 3; j++)
+	{
+		for (int l = 0; l < 3; l++)
+		{
+			suma += generate_term_in_gamma_matrix_element(exp_index1, exp_index2, i1, i2, j, l, C, geo_par, options);
+		}
+	}
+	return suma;
+}
+
+double generate_E_matrix_element(int i1, int i2, int exp_index1[3], int exp_index2[3], int options)
+{
+	if (i1 != i2)
+	{
+		return 0.0;
+	} else {
+		int coeff[3], Q;
+		double R;
+		for (int i = 0; i < 3; i++) {coeff[i] = exp_index1[i] + exp_index2[i] + 1;} 
+		Q = (1 - (int)pow(-1,coeff[0]))*(1 - (int)pow(-1,coeff[1]))*(1 - (int)pow(-1,coeff[2]));
+		if (Q == 0)
+		{
+			return 0.0;
+		}
+		if (options == 1)
+		{
+			R = (0.0+fact2(coeff[0] - 2)*fact2(coeff[1] - 2))/(fact2(coeff[0] + coeff[1])*coeff[2]);
+		} else if (options == 2) {
+			R = (0.0+fact2(coeff[0] - 2)*fact2(coeff[1] - 2)*fact2(coeff[2] - 2))/(0.0+fact2(coeff[0] + coeff[1] + coeff[2]));
+		} else {
+			R = 1.0/(coeff[0]*coeff[1]*coeff[2]);
+		}	
+		//for (int i = 0; i < 3; i++) {printf("coeff %i: %i, fact: %li \n", i, coeff[i], fact2(coeff[i]));}	
+		//printf("Operacion 1: %li\n", (fact2(coeff[0] - 2)*fact2(coeff[1] - 2)));
+		//printf("Operacion 2: %li\n", fact2(coeff[0] + coeff[1])*coeff[2]);
+		//printf("35!!= %f\n", fact2(35));
+		return Q*R;
+	}
+}
+
+// Function to generate combinations
+int **generate_combinations(int N) {
+    int R = ((N + 1) * (N + 2) * (N + 3))/6;
+
+    // Allocate memory for the combinations array
+    int **combi = (int **)malloc(R * sizeof(int *));
+    for (int i = 0; i < R; i++) 
+	{
+        combi[i] = (int *)malloc(3 * sizeof(int));
+    }
+
+    int l = 0;
+    for (int n = 0; n <= N; n++) {
+        for (int i = 0; i <= n; i++) {
+            for (int j = 0; j <= n - i; j++) {
+                int k = n - i - j;
+                combi[l][0] = i;
+                combi[l][1] = j;
+                combi[l][2] = k;
+                l++;
+            }
+        }
+    }
+    return combi;
+}
+
+
+// Function to free allocated memory
+void free_combinations(int **combi, int total_combinations) {
+    for (int i = 0; i < total_combinations; i++) {
+        free(combi[i]);
+    }
+    free(combi);
+}
+
+PyObject  *gamma_matrix_py(PyObject *self, PyObject *args)
+{
+	PyArrayObject *C, *geo_par;
+	int N, options;
+	
+	if (!PyArg_ParseTuple(args, "iO!O!i", &N, &PyArray_Type, &C, &PyArray_Type, &geo_par, &options))
+	{
+		return NULL;
+	}
+
+	if (!PyArray_Check(C) || !PyArray_Check(geo_par))
+	{
+		PyErr_SetString(PyExc_TypeError, "Expected numpy arrays for C and geo_par");
+		return NULL;
+	}
+	double *geo_par_data = (double *)PyArray_DATA(geo_par);
+	double (*C_data)[6] = (double (*)[6])PyArray_DATA(C);
+
+	if (PyArray_NDIM(geo_par) != 1 || PyArray_DIM(geo_par, 0) != 3 || 
+			PyArray_NDIM(C) != 2 || PyArray_DIM(C, 0) != 6 || PyArray_DIM(C, 1) != 6)
+	{
+		PyErr_SetString(PyExc_ValueError, "C must be an np.array of dimensions (6,6) and geo_par must be an array of dimensions (3,)");
+		return NULL;
+	}
+	/*
+	 * Aquí se empieza a escribir la función de verdad. Bueno casi. Aquí definimos que tan grande queremos que sea la matriz de respuesta 
+	 */
+	int R = ((N + 1)*(N + 2)*(N + 3))/6;
+	npy_intp dims[2] = {3*R, 3*R};
+	PyObject *gamma_array = PyArray_SimpleNew(2, dims, NPY_DOUBLE);
+	if (gamma_array == NULL)
+	{
+		PyErr_SetString(PyExc_MemoryError, "Gamma array memory could be not allocated");
+		return NULL;
+	}
+	double *gamma_data = (double *)PyArray_DATA((PyArrayObject *)gamma_array);
+	/*
+	 * Ahora sí aquí empiezas a codificar la lógica de la función 
+	 */
+	 int **combi;
+	 combi = generate_combinations(N); //Recuerde que el primer índice de combi es la combinación específica y el segundo va de cero a 2
+	 if (combi == NULL) 
+	 {
+		 PyErr_SetString(PyExc_MemoryError, "Combinations array memory could not be allocated");
+		 Py_DECREF(gamma_array); // Free gamma_array if combi allocation fails
+		 return NULL;
+     }			
+	 #pragma omp parallel for collapse(4)
+	 for (int i = 0; i < 3; i++)
+	 {
+		 for (int k = 0; k < 3; k++)
+		 {
+			 for (int lm = 0; lm < R; lm++)
+			 {
+				 for (int lf = 0; lf < R; lf++)
+				 {
+					 gamma_data[3*R*(i*R +lm) + (k*R + lf)] = generate_gamma_matrix_element(i, k, combi[lm], combi[lf], C_data, geo_par_data, options);
+				 }
+			 }
+		 } 
+	 }
+	 free_combinations(combi, R);
+	 //printf("Hello from C \n");
+	 return gamma_array;
+
+}
+
+PyObject *E_matrix_py(PyObject *self, PyObject *args)
+{
+	int N, options;
+	if (!PyArg_ParseTuple(args, "ii", &N, &options))
+	{
+		return NULL;
+	}
+	int R = ((N + 1)*(N + 2)*(N + 3))/6;
+	int **combi;
+	npy_intp dims[2] = {3*R, 3*R};
+	PyObject *E_array = PyArray_SimpleNew(2, dims, NPY_DOUBLE);
+	if (E_array == NULL)
+	{
+		PyErr_SetString(PyExc_MemoryError, "Memory for E matrix could not be allocated");
+		return NULL;
+	}
+	double *E_data = (double *)PyArray_DATA((PyArrayObject *)E_array);
+	combi = generate_combinations(N);
+	
+	if (combi == NULL) {
+        PyErr_SetString(PyExc_MemoryError, "Combinations array memory could not be allocated");
+        Py_DECREF(E_array); 
+        return NULL;
+    }
+	#pragma omp parallel for collapse(4)	
+	for (int i = 0; i < 3; i++)
+	{
+		for (int k = 0; k < 3; k++)
+		{
+			for (int lm = 0; lm < R; lm++)
+			{
+				for (int lf = 0; lf < R; lf++)
+				{
+					E_data[3*R*(i*R +lm) + (k*R + lf)] = generate_E_matrix_element(i, k, combi[lm], combi[lf], options);
+				}
+			}
+		} 
+	}
+	free_combinations(combi, R);
+	return E_array;
+
+}
+
+PyObject *generate_element_in_gamma_matrix_py(PyObject *self, PyObject *args)
+{
+	PyArrayObject *exp_index1, *exp_index2, *C, *geo_par;
+    int i1, i2, options;
+	double result;
+
+
+	if (!PyArg_ParseTuple(args, "iiO!O!O!O!i",
+				&i1, &i2,
+				&PyArray_Type, &exp_index1,
+				&PyArray_Type, &exp_index2,
+				&PyArray_Type, &C,
+				&PyArray_Type, &geo_par,
+				&options))
+	{
+		return NULL;
+	}
+	// Validate input arrays
+    if (!PyArray_Check(exp_index1) || !PyArray_Check(exp_index2) ||
+        !PyArray_Check(C) || !PyArray_Check(geo_par))
+    {
+        PyErr_SetString(PyExc_TypeError, "Expected numpy arrays for exp_index1, exp_index2, C, and geo_par.");
+        return NULL;
+    }
+
+    // Convert numpy arrays to C arrays
+    int *exp_index1_data = (int *)PyArray_DATA(exp_index1);
+    int *exp_index2_data = (int *)PyArray_DATA(exp_index2);
+    double (*C_data)[6] = (double (*)[6])PyArray_DATA(C);
+    double *geo_par_data = (double *)PyArray_DATA(geo_par);
+
+    // Ensure dimensions match expected sizes
+    if (PyArray_NDIM(exp_index1) != 1 || PyArray_DIM(exp_index1, 0) != 3 ||
+        PyArray_NDIM(exp_index2) != 1 || PyArray_DIM(exp_index2, 0) != 3 ||
+        PyArray_NDIM(C) != 2 || PyArray_DIM(C, 0) != 6 || PyArray_DIM(C, 1) != 6 ||
+        PyArray_NDIM(geo_par) != 1 || PyArray_DIM(geo_par, 0) != 3)
+    {
+        PyErr_SetString(PyExc_ValueError, "Invalid dimensions for input arrays.");
+        return NULL;
+    }
+	//for (int i = 0; i < 3; i++) {printf("|%i|%i|\n", exp_index1_data[i], exp_index2_data[i]);}
+    // Call the C function
+    result = generate_gamma_matrix_element(i1, i2, exp_index1_data, exp_index2_data,
+                                                   C_data,
+                                                   geo_par_data, options);
+
+    // Return the result as a Python float
+    return PyFloat_FromDouble(result);
+}
+
+PyObject *generate_element_in_E_matrix_py(PyObject *self, PyObject *args)
+{
+	PyArrayObject *exp_index1, *exp_index2;
+	int i1, i2, options;
+	double result;
+	if (!PyArg_ParseTuple(args, "iiO!O!i",
+				&i1, &i2,
+				&PyArray_Type, &exp_index1,
+				&PyArray_Type, &exp_index2,
+				&options))
+	{
+		return NULL;
+	}
+	if (!PyArray_Check(exp_index1) || !PyArray_Check(exp_index2))
+	{
+		PyErr_SetString(PyExc_TypeError, "Expected numpy arrays for exp_index1 and exp_index2");
+		return NULL;
+	}
+
+	int *exp_index1_data = (int *)PyArray_DATA(exp_index1);
+	int *exp_index2_data = (int *)PyArray_DATA(exp_index2);
+	if (PyArray_NDIM(exp_index1) != 1 || PyArray_DIM(exp_index1, 0) != 3 ||
+			PyArray_NDIM(exp_index2) != 1 || PyArray_DIM(exp_index2, 0) != 3)
+	{
+		PyErr_SetString(PyExc_ValueError, "Invalid dimensions for exp_index1 or exp_index2. Must be (3,)");
+		return NULL;
+	}
+	result = generate_E_matrix_element(i1, i2, exp_index1_data, exp_index2_data, options);
+	return PyFloat_FromDouble(result);
+}	
+
+
+static PyMethodDef methods[] = {
+	{"generate_gamma_matrix_element", generate_element_in_gamma_matrix_py, METH_VARARGS, "This functions generates a term in teh sum of an element of gamma matrix"},
+	{"generate_E_matrix_element", generate_element_in_E_matrix_py, METH_VARARGS, "This function generates a matrix element of E"},
+	{"gamma_matrix", gamma_matrix_py, METH_VARARGS, "This function computes the gamma matrix"},
+	{"E_matrix", E_matrix_py, METH_VARARGS, "This function computes the E matrix"},
+	{NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef rus_module = {
+	PyModuleDef_HEAD_INIT,
+	"rus",
+	"Prototipo de modelo de rus.",
+	-1,
+	methods
+};
+
+PyMODINIT_FUNC PyInit_rus()
+{ 
+	PyObject *module = PyModule_Create(&rus_module);
+	import_array();
+	return module;
+}

ruspectroscopy_tools-0.0.1/ruspectroscopy_tools.egg-info/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: ruspectroscopy-tools
+Version: 0.0.1
+Summary: A simple tool that generates Gamma matrix and E matrix, given the elastic constants, mass, dimansions and shape of a sample, in Resonant Ultrasound Spectroscopy. Use scipy.linalg.eigh(...) to solve the forward problem
+Home-page: https://github.com/jacubillos10/RUSpectroscopy_Tools
+Author: Alejandro Cubillos
+Author-email: alejandro4cm@outlook.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# RUSpectroscopy_tools
+
+A C extension module for generating Gamma and Epsilon matrices, in Resonant Ultrasound Spectroscopy.
+
+## Authors
+
+- Alejandro Cubillos - alejandro4cm@outlook.com
+- Manuela Rivas
+- Julián Rincón 
+
+## Import: 
+```python
+from rusmodules import rus
+```
+
+## Usage Example
+```python
+gamma = rus.gamma_matrix(N, C, geometry, shape)
+E = rus.E_matrix(N, shape) 
+```
+
+# Where: 
+* N <int> represents the maximim grade of the polynomials of the basis functions 
+* C <np.array> 6x6 matrix with the elastic constants
+* geometry <np.array> (3,) shape array containing the dimensions of the sample
+* shape <int> 0 for parallelepiped, 1 for cylinder and 2 to spheroid
+
+Solve forward problem with scipy:
+Eigenvalues return $m\omega^2$
+```python
+eigenvals, eigenvects = scipy.linalg.eigh(a = gamma, b = E)
+omega = (eigenvals[6:]/m)**(1/2) #remember the fisrt 6 eigenvalues must be near zero
+frequencies = omega/(2*np.pi)
+``` 
+
+## Installation: 
+```bash
+pip3 install ruspectroscopy_tools

ruspectroscopy_tools-0.0.1/ruspectroscopy_tools.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+rusmodules/__init__.py
+rusmodules/compile_data_generator.py
+rusmodules/compile_rus_module.py
+rusmodules/rus.c
+ruspectroscopy_tools.egg-info/PKG-INFO
+ruspectroscopy_tools.egg-info/SOURCES.txt
+ruspectroscopy_tools.egg-info/dependency_links.txt
+ruspectroscopy_tools.egg-info/top_level.txt

ruspectroscopy_tools-0.0.1/ruspectroscopy_tools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ruspectroscopy_tools-0.0.1/ruspectroscopy_tools.egg-info/top_level.txt

@@ -0,0 +1 @@
+rusmodules

ruspectroscopy_tools-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ruspectroscopy_tools-0.0.1/setup.py

@@ -0,0 +1,35 @@
+from setuptools import setup, Extension 
+import numpy as np 
+import sys
+
+extra_compile_flags = ["-fopenmp"]
+extra_link_flags = ["-fopenmp"]
+
+setup(
+        name = "ruspectroscopy_tools",
+        version = "0.0.1",
+        description = "A simple tool that generates Gamma matrix and E matrix, given the elastic constants, mass, dimansions and shape of a sample, in Resonant Ultrasound Spectroscopy. Use scipy.linalg.eigh(...) to solve the forward problem",
+        long_description = open("README.md").read(),
+        long_description_content_type = "text/markdown",
+        author = "Alejandro Cubillos",
+        author_email = "alejandro4cm@outlook.com",
+        url = "https://github.com/jacubillos10/RUSpectroscopy_Tools",
+        packages = ["rusmodules"],
+        ext_modules =  [
+            Extension(
+                "rusmodules.rus",
+                sources = ["rusmodules/rus.c"],
+                include_dirs = [np.get_include()],
+                extra_compile_args = extra_compile_flags,
+                extra_link_args = extra_link_flags,
+            )
+        ],
+        classifiers = [
+            "Programming Language :: Python :: 3",
+            "License :: OSI Approved :: MIT License",
+            "Operating System :: OS Independent",
+        ],
+        license = "MIT",
+        python_requires = ">=3.6",
+        setup_requires = ["numpy"],
+)