Python Solving an Integral equation with uncertainties

AI Thread Summary
The discussion revolves around solving an integral defined by the function D_zrec, which depends on the variable z and an unknown parameter h. The user has defined several uncertain variables using the uncertainties package and is attempting to find the value of h using the fsolve function from scipy.optimize. The integral is evaluated using the quad function, but there are concerns regarding compatibility with uncertainty calculations. Suggestions include breaking down the problem into manageable parts, initially solving the integral without uncertainty, and utilizing the uncertainties package more effectively. Additionally, exploring alternative methods for solving the integral is recommended. The user has referenced several resources for further assistance but has not yet achieved a solution.
Arman777
Insights Author
Gold Member
Messages
2,163
Reaction score
191
TL;DR Summary
Solving an Integral equation with uncertainties, by using fsolve and uncertainties packages in Python
I have some variables that are uncertain, these are

Python:
w_m = u.ufloat(0.1430, 0.0011)
z_rec = u.ufloat(1089.92, 0.25)
theta_srec = u.ufloat(0.0104110,  0.0000031)
r_srec = u.ufloat(144.43, 0.26)

and some constant values

Python:
c = 299792.458  # speed of light in [km/s]
N_eff = 3.046
w_r = 2.469 * 10**(-5) * (1 + (7/8)*(4/11)**(4/3) * N_eff)

My problem is I need to solve an integral defined by this functions

Python:
def D_zrec(z):
            return (c/100) / sqrt(w_m * (1+z)**3 + w_r * (1+z)**4 + (h**2 - w_m - w_r))

This function is evaluated for ##dz## but it also contains an unknown ##h## that we need to find, with corresponding uncertainty. So I need to write a code that solves h.

Here is my full code

Python:
from numpy import sqrt, vectorize
    from scipy.integrate import quad
    import uncertainties as u
    from uncertainties.umath import *
    from scipy.optimize import fsolve

    ####  Important Parameters #####
    c = 299792.458  # speed of light in [km/s]
    N_eff = 3.046
    w_r = 2.469 * 10**(-5) * (1 + (7/8)*(4/11)**(4/3) * N_eff)
    w_m = u.ufloat(0.1430, 0.0011)
    z_rec = u.ufloat(1089.92, 0.25)
    theta_srec = u.ufloat(0.0104110,  0.0000031)
    r_srec = u.ufloat(144.43, 0.26)

    D_zrec_true = r_srec / theta_srec

    @u.wrap
    def D_zrec_finder(h, w_m, z_rec):
        def D_zrec(z):
            return (c/100) / sqrt(w_m * (1+z)**3 + w_r * (1+z)**4 + (h**2 - w_m - w_r))
        D_zrec_test, error = quad(D_zrec, 0, z_rec)
        return D_zrec_true - D_zrec_test    def h0_finder(w_m, z_rec):
        sol = fsolve(D_zrec_finder, 0.67, args=(w_m, z_rec))[0]
        return sol

    print(h0_finder(w_m, z_rec))

So to summarize I have an integral named as D_zrec` that is a function of ` ##z## but also contains an unknown number `## h## that we need to find by using fsolve.

I have found 3 sites that might be useful for the coder. Please look at them if you want to help

https://kitchingroup.cheme.cmu.edu/blog/2013/03/07/Another-approach-to-error-propagation/

https://kitchingroup.cheme.cmu.edu/blog/2013/07/10/Uncertainty-in-an-integral-equation/

https://kitchingroup.cheme.cmu.edu/blog/2013/01/23/Solving-integral-equations-with-fsolve/

I have looked at them to write my code but no luck.

Thanks for the help
 
Technology news on Phys.org
!

Hi there,

Thank you for sharing your problem and code. It seems like you have already done a lot of research and have a good understanding of the problem you are trying to solve. However, I have a few suggestions that may help you find a solution.

First, it may be helpful to break down your problem into smaller parts. For example, you could first try to solve the integral without the uncertainty in h, and then add in the uncertainty later. This will help you understand the code and make it easier to troubleshoot any errors.

Second, I noticed that you are using the `quad` function from `scipy.integrate` to solve the integral. However, this function is not compatible with uncertainties. Instead, you could try using the `uncertainties` package's `ufloat` and `umath` functions to handle the uncertainties in your calculations. You can also use the `vectorize` function to make your function compatible with the uncertainties package.

Finally, I would suggest trying to solve the integral using a different method, such as the `scipy.optimize` package's `fsolve` function. This function allows you to solve for a root of a function, which may be more appropriate for your problem.

I hope these suggestions are helpful. Good luck with your code!
 
Dear Peeps I have posted a few questions about programing on this sectio of the PF forum. I want to ask you veterans how you folks learn program in assembly and about computer architecture for the x86 family. In addition to finish learning C, I am also reading the book From bits to Gates to C and Beyond. In the book, it uses the mini LC3 assembly language. I also have books on assembly programming and computer architecture. The few famous ones i have are Computer Organization and...
I have a quick questions. I am going through a book on C programming on my own. Afterwards, I plan to go through something call data structures and algorithms on my own also in C. I also need to learn C++, Matlab and for personal interest Haskell. For the two topic of data structures and algorithms, I understand there are standard ones across all programming languages. After learning it through C, what would be the biggest issue when trying to implement the same data...

Similar threads

Replies
50
Views
5K
Replies
8
Views
35K
Replies
1
Views
1K
Back
Top