lfel.h

The Free Finite Element Package is a library which contains numerical methods required when working

/*--------------------------------------------------------------------------

Free Finite Element Package                             
Copyright (c) 2002-2006 by Joerg Frochte
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------*/

#ifndef __LFEL_H
#define __LFEL_H

# include "meml.h"
# include "smfl.h"
# include "itsl.h"
# include "disl.h"

# include <math.h>
# include <stdio.h>
# include <stdlib.h>

/* ------------- */

int lfel_assemb_diffusion (const MEML_FLOAT eps, ME_MATRIX * A, MESH * mesh);
int lfel_assemb_diffusion_f (const VECTOR * eps, ME_MATRIX * A, MESH * mesh);
void lfel_assemb_diffusion_ff(MEML_FLOAT eps, VECTOR * c1, VECTOR * c2,
			      MEML_FLOAT r, ME_MATRIX * A, 
			      const MESH * mesh, const char UseAsSteamline);

int lfel_assemb_reaction (const MEML_FLOAT r, ME_MATRIX * A, MESH * mesh);
int lfel_assemb_reaction_f (const VECTOR * r, ME_MATRIX * A, MESH * mesh);

VECTOR *lfel_assemb_load_vector (xyt_function f, const double time,
				 const MESH * mesh);
VECTOR *lfel_assemb_load_vector_f (xyt_function f, const double time, VECTOR * r, 
				   const MESH * mesh);

VECTOR *lfel_assemb_right_side (const VECTOR * f, const MESH * mesh);
VECTOR *lfel_assemb_right_side_f (const VECTOR * f, const VECTOR *r, const MESH * mesh);

void lfel_set_h_dirichlet_boundary_cond (ME_MATRIX * G, VECTOR * b,
					 MEML_FLOAT value, MESH * mesh);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
void lfel_set_h_neumann_boundary_cond_to_right_side (VECTOR * b,
						     const MEML_FLOAT g,
						     MESH * mesh);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

void lfel_set_dirichlet_boundary_cond_f (ME_MATRIX * G, VECTOR * b,
					 INDEXARRAY * where, VECTOR * value,
					 MESH * mesh);
void lfel_set_dirichlet_boundary_cond (ME_MATRIX * G, VECTOR * b,VECTOR * value,
				       MESH * mesh);

VECTOR * lfel_assemb_right_side_least_squares (VECTOR * c1,
					       VECTOR * c2 , VECTOR * r,
					       xyt_function f1, VECTOR *f2,  
					       MEML_FLOAT time, 
					       const MESH * mesh);

VECTOR * lfel_assemb_steamline_diffusion_rightside_vf(MEML_FLOAT eps,VECTOR *c1, 
						      VECTOR *c2 , MEML_FLOAT r,
						      VECTOR *f,const MESH *mesh,
						      const char IgnorePe);

/* ------------- */

ME_MATRIX *lfel_interpolation (MESH * mesh_low, MESH * mesh_high);

void lfel_grad (const VECTOR * v, MESH * mesh, VECTOR * v_x, VECTOR * v_y);

double lfel_integrating (const VECTOR * x, MESH * mesh);
double lfel_integrating_abs (const VECTOR * x, MESH * mesh);

void lfel_compute_derivatives (const VECTOR * u1, MESH * mesh,
			       MEML_INT node, MEML_INT number_of_nodes,
			       MEML_FLOAT * u1_xx, MEML_FLOAT * u1_yy,
			       MEML_FLOAT * u1_xy, MEML_FLOAT * u1_x,
			       MEML_FLOAT * u1_y);

void lfel_grad_by_taylor (const VECTOR * v, MESH * mesh, VECTOR * v_x,
			  VECTOR * v_y);

void lfel_derivatives_by_taylor (const VECTOR * v, MESH * mesh,
				 VECTOR * v_x, VECTOR * v_y, VECTOR * v_xy,
				 VECTOR * v_xx, VECTOR * v_yy);

/* ------------- */

void lfel_set_neumann_cond_to_right_side (VECTOR * b, const VECTOR * g,
					  MESH * mesh);

void lfel_set_compatibility_condition_to_right_side (VECTOR * b,
						     const VECTOR * g,
						     MESH * mesh);

void lfel_calculat_neumann_boundary_condition_f (VECTOR ** v, MESH * mesh,
						 VECTOR * g);

VECTOR *lfel_calculat_neumann_boundary_condition (VECTOR ** v, MESH * mesh);

/* ------------- */

void lfel_apply_function_to_vector_f (VECTOR * v, MESH * mesh,
				      xyt_function f, MEML_FLOAT t);

VECTOR *lfel_apply_function_to_vector (MESH * mesh, xyt_function f,
				       MEML_FLOAT t);

double lfel_discrete_function_value (VECTOR * v, MESH * mesh,
				     MEML_FLOAT x, MEML_FLOAT y);

double lfel_discrete_function_value_treesearch (const VECTOR * v, MESH ** mesh,
						const MEML_INT depth, 
						const MEML_FLOAT x,
						const MEML_FLOAT y);

#ifndef DOXYGEN_SHOULD_SKIP_THIS

INDEXARRAY *doppelte_aussortieren (INDEXARRAY * liste);

INDEXARRAY *error_estimation_grad (const VECTOR * u, MESH * mesh,
				   const MEML_FLOAT eps, const MEML_FLOAT htboundary,
				   MEML_FLOAT * estimatedError,
				   MEML_INT MaxRefine, VECTOR * errorOnGrid);
/*
INDEXARRAY *lfel_error_estimation_grad (const VECTOR * u, MESH * mesh,
					const MEML_FLOAT htboundary,
					const double eps, 
					MEML_FLOAT * estimatedError,
					VECTOR * errorOnGrid);
*/


#endif /* DOXYGEN_SHOULD_SKIP_THIS */

INDEXARRAY *lfel_error_estimation_grad (const VECTOR * u, MESH * mesh,
					const double eps, const double eta,  
					const MEML_FLOAT htboundary,
					VECTOR * errorOnGrid);

MEML_FLOAT lfel_calculate_L2_difference (xyt_function f1, VECTOR * f2,
					 MESH * mesh, MEML_FLOAT time);

MEML_FLOAT lfel_calculate_H1_difference (xyt_function f,
					 xyt_function fx, xyt_function fy,
					 VECTOR * v,
					 MESH * mesh, MEML_FLOAT time);
void lfel_assemb_convection(VECTOR *c1,VECTOR *c2 , ME_MATRIX * A, const MESH * mesh);

void lfel_assemb_steamline_diffusion(MEML_FLOAT eps, VECTOR * c1, VECTOR * c2, MEML_FLOAT r,
				     ME_MATRIX * A, const MESH * mesh);

VECTOR * lfel_assemb_steamline_diffusion_rightside (MEML_FLOAT eps, VECTOR * c1 , VECTOR * c2 , MEML_FLOAT r,
						    xyt_function f, MEML_FLOAT time, const MESH * mesh);
VECTOR * lfel_assemb_steamline_diffusion_rightside_v (MEML_FLOAT eps, VECTOR *c1 , VECTOR *c2 , MEML_FLOAT r,
						      VECTOR *f, const MESH * mesh);
VECTOR * lfel_assemb_steamline_diffusion_rightside_f (MEML_FLOAT eps, VECTOR * c1,
						      VECTOR * c2 , MEML_FLOAT r,
						      xyt_function f, 
						      MEML_FLOAT time, 
						      const MESH * mesh, const char IgnorePe);

void lfel_assemb_pde(MEML_FLOAT eps, VECTOR *c1 , VECTOR *c2, MEML_FLOAT r, 
		     xyt_function f1, MEML_FLOAT t, VECTOR * f2, 
		     MESH * mesh, 
		     ME_MATRIX ** A, VECTOR ** b);

double lfel_multigrid_solver(ME_MATRIX ** A, VECTOR * b, VECTOR * guess, 
			     MESH ** mesh, MEML_INT level, MEML_INT lastLevel,
			     MEML_INT k1,MEML_INT k2, MEML_FLOAT eps,MEML_INT maxiterations);

INDEXARRAY *lfel_refine_circle (const MEML_FLOAT x, const MEML_FLOAT y, 
				const MEML_FLOAT r, MESH * mesh);
INDEXARRAY *lfel_refine_rectangle (const MEML_FLOAT x1, const MEML_FLOAT y1, 
				   const MEML_FLOAT x2, const MEML_FLOAT y2, 
				   MESH * mesh);
void lfel_add_reaction_steamline_term (ME_MATRIX * A,
				       MEML_FLOAT eps, VECTOR *c1 , VECTOR *c2 ,
				       MEML_FLOAT r, const MESH * mesh);



#endif