1D Adaptive Mesh Refinement in C - c

Question

I am a Physics PhD student currently entering the field of numerical relativity and I have to implement an adaptive mesh refinement code in 2 dimensions. As with every other bit of my program, I usually prefer to do something much simpler to understand what is going on before jumping to a more sophisticated case. However, I still seem to be doing something fundamentally wrong.
My code performs (or at least should perform) the following procedure: I discretize the x-axis in N intervals of size h. Every time a point is computed, the program stops and computes that point again by changing the interval of size h to another interval with two steps h/2. The program checks if the results are below some user specified tolerance and, if not, the process starts again with step size h/4 and so on. The following sketch illustrates the procedure
After the refinement function acts, I have absolutely no interest in keeping the values of the function on the refined grids. All I want is to compute the function on the coarse grid with maximum accuracy (in the image all I want to keep - and change - are the values of the black dots of the coarse [base] grid).
Unfortunately I see no improvement on the solution after the refinement algorithm is passed. I do not expect the plot of the function to be perfect, but I expect every point to be very close to the analytic solution. This is my refinement function (the function is called recursively until a maximum level of refinement - user specified - is reached):
void refine( int l, long double dx, long double x_min, long double x_max, long double f_min, long double *f_max ){
// l = level of refinement, dx = step size, x_min is current x position, x_max = point we want to calculate, f_min = function evaluated at x_min, f_max = function evaluated at x_max
int i;
long double *f_aux, f_point;
f_aux = (long double *) malloc ( (2*l + 1) * sizeof (long double) );
dx = 0.5 * dx;
f_aux[0] = f_min;
for( i=1; i<2*l+1; i++ ){
f_aux[i] = ( 1.0 - 2.0 * dx * ( x_min + (i-1)*dx - X0 ) / DELTA ) * f_aux[i-1];
}
if( l < lMAX ){
if( fabs( f_aux[2*l] - *f_max ) > TOL ){
f_point = f_aux[2*l];
free( f_aux );
l++;
refine( l, dx, x_min+dx, x_max, f_min, &f_point );
}
else{
*f_max = f_aux[2*l];
free( f_aux );
}
}
else{
*f_max = f_aux[2*l];
free( f_aux );
}
return;
}
Can anyone shed some light on the problem? I feel completely stuck.
Thanks in advance!

Answer 1

It looks that your iteration enhances around last point, but is still coarse around start point:
*---------------* refine 0
*-------*-------* refine 1
*-------*---*---* refine 2
*-------*---*-*-* refine 3
And as your equation looks hyperbolic (depends on all previous iterations) the solution error will be cumuluative in nature. I think you shall iterate with fine grid from the begining to get proper solution - not only around neighborhood. Eg. for simple equation df/dx=f with such implementation:
float update(float f_prev, float dx, float /* unused */ target_dx) {
return f_prev*dx + f_prev;
}
int main(void)
{
int n = 8;
float dx = 2.f/(float)(n-1);
float f[n];
f[0] = 1.f;
for (int i = 1; i < n; i++) {
f[i] = update(f[i-1], dx, dx / 16.f);
}
return 0;
}
I would go with simple recursive formula:
float update_recursive(float f_prev, float dx, float target_dx) {
if (dx > target_dx) {
return update_recursive(
update_recursive(f_prev, dx / 2.f, target_dx), dx / 2.f, target_dx
);
}
return dx * f_prev + f_prev;
}
The approach enhances the quality of solution. The terminating condition may be more adaptive to solution than target_dx is. Of course, it is needed to ensure that recursion is well bounded.