FrameTL Namespace Reference


Classes

class  PolySolBiharmonic
class  SimpleTest
class  SimpleTestRHS
class  SimpleTestGradient
class  AggregatedFrame
class  Biharmonic1D_Solution
class  Biharmonic1D_RHS_Integrand
class  Biharmonic1D_RHS
class  BiharmonicEquation
struct  CDD1Parameters
class  Singularity1D_RHS_2
class  Singularity1D_2
class  EllipticEquation
class  EvaluateFrame
class  EvaluateFrame< IBASIS, 1, 1 >
class  EvaluateFrame< IBASIS, 2, 2 >
struct  Coefficient
class  FrameIndex
class  Functional
class  Index1D
class  Singularity1D_2_prime
class  Poisson_Solution_Ring
class  Poisson_RHS_Ring
class  Poisson_SolutionGradient_Ring
class  SimpleBiharmonicEquation
class  SimpleEllipticEquation

Functions

template<class IBASIS , int DIM>
double H_1_error_interval (const AggregatedFrame< IBASIS, DIM, DIM > &frame, const InfiniteVector< double, typename AggregatedFrame< IBASIS, DIM, DIM >::Index > &coeffs, const Function< 1 > &f)
template<class IBASIS , int DIM>
double error_H_scale_interval (const int order, const AggregatedFrame< IBASIS, DIM, DIM > &frame, const InfiniteVector< double, typename AggregatedFrame< IBASIS, DIM, DIM >::Index > &coeffs, const Function< 1 > &f)
template<class PROBLEM >
void thin_out_ring (PROBLEM &P, const int i, const InfiniteVector< double, typename PROBLEM::Index > &u, InfiniteVector< double, typename PROBLEM::Index > &u_sparse, InfiniteVector< double, typename PROBLEM::Index > &u_very_sparse)
template<class PROBLEM >
void thin_out (PROBLEM &P, const int i, const InfiniteVector< double, typename PROBLEM::Index > &u, InfiniteVector< double, typename PROBLEM::Index > &u_sparse, InfiniteVector< double, typename PROBLEM::Index > &u_very_sparse)
template<class PROBLEM >
void remove_i (const int i, InfiniteVector< double, typename PROBLEM::Index > &u)
template<class PROBLEM >
void AddSchw (const PROBLEM &P, const double epsilon, Array1D< InfiniteVector< double, typename PROBLEM::Index > > &approximations)
 Adaptive additive Schwarz wavelet frame algorithm from PhD thesis Werner 2009.
template<class PROBLEM >
void split (PROBLEM &P, const int i, const InfiniteVector< double, typename PROBLEM::Index > &u, InfiniteVector< double, typename PROBLEM::Index > &u1, InfiniteVector< double, typename PROBLEM::Index > &u2)
template<class PROBLEM >
void MultSchw (const PROBLEM &P, const double epsilon, Array1D< InfiniteVector< double, typename PROBLEM::Index > > &approximations)
 Adaptive multiplicative Schwarz wavelet frame algorithm from Stevenson, Werner 2009.
template<class PROBLEM >
void adaptive_multiplicative_Schwarz_SOLVE (const PROBLEM &P, const double epsilon, Array1D< InfiniteVector< double, typename PROBLEM::Index > > &approximations)
template<class PROBLEM >
void GALERKIN (PROBLEM &P, const set< typename PROBLEM::Index > &Lambda, const InfiniteVector< double, typename PROBLEM::Index > &rhs, Vector< double > &u)
template<class PROBLEM >
void additive_Schwarz_SOLVE (PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon)
template<class PROBLEM >
void addtive_Schwarz_SOLVE (PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon)
template<class PROBLEM >
void additive_Schwarz_SD_SOLVE (const PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon)
template<class PROBLEM >
void addtive_Schwarz_SD_SOLVE (const PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void precompute_supports_simple (const AggregatedFrame< IBASIS, DIM_d, DIM_m > *frame, Array1D< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Support > &all_patch_supports)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
std::ostream & operator<< (std::ostream &, const AggregatedFrame< IBASIS, DIM_d, DIM_m > &)
template<class PROBLEM >
void CDD1_LOCAL_SOLVE (const PROBLEM &P, const int patch, const double epsilon, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &guess, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &u_epsilon, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &v_k, const int jmax, const CompressionStrategy strategy)
 The routine ALGORITHMc from [BB+], with a given initial guess for u_epsilon.
template<class PROBLEM >
void CDD1_LOCAL_SOLVE (const PROBLEM &P, const int patch, const double epsilon, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &guess, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &u_epsilon, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &v_k, const double c1, const double c2, const int jmax, const CompressionStrategy strategy)
 The routine ALGORITHMc from [BB+], with a given initial guess for u_epsilon and for the parameters c1,c2.
template<class PROBLEM >
void NPROG (const PROBLEM &P, const int patch, const CDD1Parameters &params, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &F, const set< typename PROBLEM::WaveletBasis::Index > &Lambda, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &v, const double delta, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &v_hat, set< typename PROBLEM::WaveletBasis::Index > &Lambda_hat, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &r_hat, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &u_Lambda_k, const int jmax, const CompressionStrategy strategy)
 NPROG.
template<class PROBLEM >
void GALERKIN (const PROBLEM &P, const int patch, const CDD1Parameters &params, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &F, const set< typename PROBLEM::WaveletBasis::Index > &Lambda, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &v, const double delta, const double eta, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &u_bar, const int jmax, const CompressionStrategy strategy)
 GALERKIN.
template<class PROBLEM >
void NGROW (const PROBLEM &P, const int patch, const CDD1Parameters &params, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &F, const set< typename PROBLEM::WaveletBasis::Index > &Lambda, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &u_bar, const double xi1, const double xi2, set< typename PROBLEM::WaveletBasis::Index > &Lambda_tilde, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &r, const int jmax, const CompressionStrategy strategy)
 NGROW.
template<class PROBLEM >
void INRESIDUAL (const PROBLEM &P, const int patch, const CDD1Parameters &params, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &F, const set< typename PROBLEM::WaveletBasis::Index > &Lambda, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &v, const double eta1, const double eta2, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &r, const int jmax, const CompressionStrategy strategy)
 INRESIDUAL.
template<class PROBLEM >
void NRESIDUAL (const PROBLEM &P, const int patch, const CDD1Parameters &params, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &F, const set< typename PROBLEM::WaveletBasis::Index > &Lambda, const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &v, const double eta1, const double eta2, InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &r, set< typename PROBLEM::WaveletBasis::Index > &Lambda_tilde, const int jmax, const CompressionStrategy strategy)
 NRESIDUAL.
template<class PROBLEM >
void cg_SOLVE (const PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon)
template<class IBASIS >
double error_H_scale_interval (const int order, const AggregatedFrame< IBASIS, 1, 1 > &frame, const InfiniteVector< double, typename AggregatedFrame< IBASIS, 1, 1 >::Index > &coeffs, const Function< 1 > &f)
 This function computes the $L_2$-norm or $H^1$-seminorm of the difference between the frame expansion given by the coefficients in coeffs and a given function in the unit interval.
template<class IBASIS >
double error_H_scale_Lshaped (const int order, const AggregatedFrame< IBASIS, 2, 2 > &frame, const InfiniteVector< double, typename AggregatedFrame< IBASIS, 2, 2 >::Index > &coeffs, const Function< 2 > &f)
 This function computes the $L_2$-norm or $H^1$-seminorm of the difference between the frame expansion given by the coefficients in coeffs and a given function in the L-shaped domain $[-1,1]^2 \ [0,1)^2$.
double H_1_semi_norm_Lshaped (const Function< 2 > &gradient)
 Computes an approximation to the $H^1$-norm of a function in the L-shaped domain $[-1,1]^2 \ [0,1)^2$.
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > first_generator (const FRAME *frame, const int j)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > last_generator (const FRAME *frame, const int j)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > first_wavelet (const FRAME *frame, const int j)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > last_wavelet (const FRAME *frame, const int j)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int first_generator_num (const FRAME *frame)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int last_generator_num (const FRAME *frame)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int first_wavelet_num (const FRAME *frame, const int j)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int last_wavelet_num (const FRAME *frame, const int j)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
std::ostream & operator<< (std::ostream &os, const FrameIndex< IBASIS, DIM_d, DIM_m > &lambda)
template<class INDEX >
void to_array (const InfiniteVector< double, INDEX > &ivec, Coefficient *coeff_array)
template<class INDEX , class FRAME >
void array_to_map (const Coefficient *coeff_array, const FRAME *frame, InfiniteVector< double, INDEX > &ivec, const int count)
bool eq (const double x, const double y)
bool lt (const double x, const double y)
bool gt (const double x, const double y)
bool leq (const double x, const double y)
template<unsigned int DIM>
unsigned short int pos_wrt_line (const Point< DIM > &p, const Point< DIM > &p1, const Point< DIM > &p2)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool in_support (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const Point< DIM_m > &p)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool in_support (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_lambda, const Point< DIM_m > &p)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool intersect_supports (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &mu, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_lambda, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_mu)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool intersect_supports_simple (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &mu)
template<unsigned int DIM>
bool quadrangles_intersect (FixedArray1D< Point< DIM >, 4 > poly1, FixedArray1D< Point< DIM >, 4 > poly2)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool intersect_supports_1D (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const Index1D< IBASIS > &lambda, const Index1D< IBASIS > &mu, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_lambda, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_mu, const int dir, Array1D< double > &supp_intersect)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool intersect_supports (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &mu, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_lambda, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_mu, FixedArray1D< Array1D< double >, DIM_d > &supp_intersect)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void intersecting_wavelets (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const int j, const bool generators, std::list< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &intersecting)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void intersecting_wavelets (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const int p, const std::set< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &Lambda, std::list< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &intersecting)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void intersecting_wavelets_on_patch (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const int p, const int j, const bool generators, std::list< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &intersecting)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool intersect_singular_support (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &mu)
template<unsigned int DIM>
int edgesIntersect (const Point< DIM > &A, const Point< DIM > &B, const Point< DIM > &C, const Point< DIM > &D)
template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool intersect_supports (const AggregatedFrame< IBASIS, DIM_d, DIM_m > &frame, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &lambda, const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &mu, const typename CubeBasis< IBASIS, DIM_d >::Support *supp_lambda)
template<unsigned int DIM, class VALUE >
const Point< DIM > apply (const Matrix< VALUE > &M, const Point< DIM > &p)
template<unsigned int DIM, class VALUE >
void apply (const Matrix< VALUE > &M, const Point< DIM > &p, Point< DIM > &res)
template<unsigned int DIM>
Point< DIM > add (const Point< DIM > &p, const Vector< double > &b)
template<unsigned int DIM>
Point< DIM > sub (const Point< DIM > &p, const Vector< double > &b)
template<unsigned int DIM>
const double inner_prod (const Point< DIM > &p1, const Point< DIM > &p2)
template<unsigned int DIM>
const double norm2 (Point< DIM > &p)
template<unsigned int DIM>
void swap (const Point< DIM > &p1, const Point< DIM > &p2)
template<class PROBLEM >
void REDUCE_REDUNDANCY (PROBLEM &P, const int i, const InfiniteVector< double, typename PROBLEM::Index > &u, InfiniteVector< double, typename PROBLEM::Index > &u_sparse)
template<class PROBLEM >
bool intersect_line1 (PROBLEM &P, const typename PROBLEM::Index &lambda)
template<class PROBLEM >
bool intersect_line2 (PROBLEM &P, const typename PROBLEM::Index &lambda)
template<class PROBLEM >
bool contact_with_patch2 (PROBLEM &P, const typename PROBLEM::Index &lambda)
template<class PROBLEM >
void multiplicative_Schwarz_SOLVE (const PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon_0, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon_1, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon)
void setup_coefficient_datatype ()
template<class PROBLEM >
void send_to_Master (const InfiniteVector< double, typename PROBLEM::Index > &v)
template<class PROBLEM >
void receive_all_parts (const PROBLEM &P, InfiniteVector< double, typename PROBLEM::Index > &v)
template<class PROBLEM >
void broadcast_vec_from_Master (const PROBLEM &P, InfiniteVector< double, typename PROBLEM::Index > &v)
void broadcast_double_from_Master (double &d)
template<class PROBLEM >
void richardson_SOLVE (const PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon, Array1D< InfiniteVector< double, typename PROBLEM::Index > > &approximations)
 for (int i=0;i< P.basis().n_p();i++)
template<class PROBLEM >
void richardson_SOLVE_CDD2 (const PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon)
template<class PROBLEM >
void simplified_steepest_descent_SOLVE (const PROBLEM &problem, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon, const int jmax)
template<class PROBLEM >
void steepest_descent_SOLVE (const PROBLEM &P, const double epsilon, Array1D< InfiniteVector< double, typename PROBLEM::Index > > &approximations)
 Adaptive steepest descent wavelet frame algorithm from Dahlke, Fornasier, Raasch, Stevenson, Werner 2007.
template<class PROBLEM >
void steepest_descent1_SOLVE (const PROBLEM &P, const double epsilon, InfiniteVector< double, typename PROBLEM::Index > &u_epsilon, const int jmax, InfiniteVector< double, typename PROBLEM::Index > rhs=InfiniteVector< double, typename PROBLEM::Index >())

Variables

MPI_Datatype coefficient_datatype
 approximations [P.basis().n_p()] = u_epsilon

Detailed Description

The namespace FrameTL.


Function Documentation

template<unsigned int DIM>
Point<DIM> FrameTL::add ( const Point< DIM > &  p,
const Vector< double > &  b 
) [inline]

add Point p, viewed as vector, to Vector b

template<class PROBLEM >
void FrameTL::AddSchw ( const PROBLEM &  P,
const double  epsilon,
Array1D< InfiniteVector< double, typename PROBLEM::Index > > &  approximations 
) [inline]

Adaptive additive Schwarz wavelet frame algorithm from PhD thesis Werner 2009.

Parameters:
P The cached discrete problem.
epsilon The target $\ell_2$-accuracy of the algorithm.
approximations An array of length number of patches+1. We return in this array the local discrete approximations on each patch.} The last entry contains the final global discrete approximation at termination.

template<unsigned int DIM, class VALUE >
void FrameTL::apply ( const Matrix< VALUE > &  M,
const Point< DIM > &  p,
Point< DIM > &  res 
) [inline]

apply matrix M to point p (p viewed as a vector)

template<unsigned int DIM, class VALUE >
const Point<DIM> FrameTL::apply ( const Matrix< VALUE > &  M,
const Point< DIM > &  p 
) [inline]

apply matrix M to point p (p viewed as a vector)

void FrameTL::broadcast_double_from_Master ( double &  d  ) 

The master processor sends a double to all other (slave) processors.

template<class PROBLEM >
void FrameTL::broadcast_vec_from_Master ( const PROBLEM &  ,
InfiniteVector< double, typename PROBLEM::Index > &   
) [inline]

The master processor sends an InfiniteVector<double, typename PROBLEM::Index> to all other (slave) processors.

template<class PROBLEM >
void FrameTL::CDD1_LOCAL_SOLVE ( const PROBLEM &  P,
const int  patch,
const double  epsilon,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  guess,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  u_epsilon,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  v_k,
const int  jmax,
const CompressionStrategy  strategy 
) [inline]

The routine ALGORITHMc from [BB+], with a given initial guess for u_epsilon.

Parameters:
P The global discrete (cached) problem.
patch The patch on which the local auxiliary problem has to be solved.
epsilon The target accuracy.
gues The initial gues from which the adaptive Galerkin scheme is started.
u_epsilon The final approximation.
v_k For the case of the multiplicative Schwarz method a la Stevenson/Werner 2009, v_k have to be the coefficients u_k^{(j)}, j i f from eq. (6.1.23) in Manuel's PhD thesis. In the additive case, v_k are the frame coeffients of the function in the first argument of the bilinear form a(.,.) in the right-hand side of the local problem in algorithm AddSchw on page 165 of Manuel's thesis. param jmax The maximal alevel of resolution. param strategy The compression strategy (the way to create the matrix A_j from Definition 4.2 in Manuels PhD thesis).}

template<unsigned int DIM>
int FrameTL::edgesIntersect ( const Point< DIM > &  A,
const Point< DIM > &  B,
const Point< DIM > &  C,
const Point< DIM > &  D 
) [inline]

This routine tests whether the line segments defined by the points A and B as well as C and D intersect. 0 = no intersection 1 = infinitely many intersection points 2 = single intersection point, but at least one knot involved 3 = single intersection point situated in the inner of both line segments

template<class IBASIS >
double FrameTL::error_H_scale_interval ( const int  order,
const AggregatedFrame< IBASIS, 1, 1 > &  frame,
const InfiniteVector< double, typename AggregatedFrame< IBASIS, 1, 1 >::Index > &  coeffs,
const Function< 1 > &  f 
) [inline]

This function computes the $L_2$-norm or $H^1$-seminorm of the difference between the frame expansion given by the coefficients in coeffs and a given function in the unit interval.

The last parameter of this routine has to be the function, or, in case of the $H^1$-seminorm, it has to be the derivative of the function.

template<class IBASIS >
double FrameTL::error_H_scale_Lshaped ( const int  order,
const AggregatedFrame< IBASIS, 2, 2 > &  frame,
const InfiniteVector< double, typename AggregatedFrame< IBASIS, 2, 2 >::Index > &  coeffs,
const Function< 2 > &  f 
) [inline]

This function computes the $L_2$-norm or $H^1$-seminorm of the difference between the frame expansion given by the coefficients in coeffs and a given function in the L-shaped domain $[-1,1]^2 \ [0,1)^2$.

The last parameter of this routine has to be the function, or, in case of the $H^1$-seminorm, it has to be the gradient of the function.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > FrameTL::first_generator ( const FRAME *  frame,
const int  j 
) [inline]

Index of first generator on level $j \geq j_0$.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int FrameTL::first_generator_num ( const FRAME *  frame  )  [inline]

Number of first generator on level $j_0$.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > FrameTL::first_wavelet ( const FRAME *  frame,
const int  j 
) [inline]

Index of first wavelet on level $j \geq j_0$.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int FrameTL::first_wavelet_num ( const FRAME *  frame,
const int  j 
) [inline]

Number of first wavelet on level $j \geq j0$.

template<class PROBLEM >
void FrameTL::GALERKIN ( const PROBLEM &  P,
const int  patch,
const CDD1Parameters &  params,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  F,
const set< typename PROBLEM::WaveletBasis::Index > &  Lambda,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  v,
const double  delta,
const double  eta,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  u_bar,
const int  jmax,
const CompressionStrategy  strategy 
) [inline]

GALERKIN.

Given an approximation v to the exact Galerkin solution u_Lambda of Au = F w.r.t. the index set Lambda, such that ||u_Lambda-v||_2 <= delta, and a target accuracy eta, compute an approximation u_bar to u_Lambda which is supported on Lambda and satisfies ||u_bar-u_Lambda||_2 <= eta.

double FrameTL::H_1_semi_norm_Lshaped ( const Function< 2 > &  gradient  ) 

Computes an approximation to the $H^1$-norm of a function in the L-shaped domain $[-1,1]^2 \ [0,1)^2$.

The parameter gradient is assumed to be the gradient of the function.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool FrameTL::in_support ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const Point< DIM_m > &  p 
) [inline]

Checks wether Point 'p' lies in the support of the wavelet frame element $\psi_\lambda$.

template<unsigned int DIM>
const double FrameTL::inner_prod ( const Point< DIM > &  p1,
const Point< DIM > &  p2 
) [inline]

Checks whether p lies left of right of or on the line specified by the Points p1 and p2. This line is oriented by the vector starting in p1 and ending in p2. returning 0 means RIGHT OF LINE returning 1 means LEFT OF LINE returning 2 means ON LINE

computes l_2 inner product will be placed in class Point in the future or replaced by appropriate function in class tensor

template<class PROBLEM >
void FrameTL::INRESIDUAL ( const PROBLEM &  P,
const int  patch,
const CDD1Parameters &  params,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  F,
const set< typename PROBLEM::WaveletBasis::Index > &  Lambda,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  v,
const double  eta1,
const double  eta2,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  r,
const int  jmax,
const CompressionStrategy  strategy 
) [inline]

INRESIDUAL.

Given an index set Lambda, an approximation v to the exact Galerkin solution u_Lambda of Au = F, calculate an approximate INternal residual r, such that ||r - (A_Lambda v - P_Lambda f)||_2 <= eta_1 + eta_2

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool FrameTL::intersect_singular_support ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  nu 
) [inline]

Decide whether the support of a given generator/wavelet $\psi_\lambda$ intersects the singular support of another generator/wavelet $\psi_\nu$.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool FrameTL::intersect_supports ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  mu,
const typename CubeBasis< IBASIS, DIM_d >::Support *  supp_lambda 
) [inline]

Checks wether the support of the wavelet frame elements intersect.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool FrameTL::intersect_supports ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  mu,
const typename CubeBasis< IBASIS, DIM_d >::Support *  supp_lambda,
const typename CubeBasis< IBASIS, DIM_d >::Support *  supp_mu,
FixedArray1D< Array1D< double >, DIM_d > &  supp_intersect 
) [inline]

THIS ROUTINE IS INTENDED FOR THE SPECIAL CASE OF TRIVIAL PARAMETRIZATIONS, NAMELY AFFINE LINEAR MAPPINGS 'A x + B' WITH 'A' BEEING A DIAGONAL MATRIX. The function checks whether two wavelets intersect and returns an irregular partition of the support intersection pulled back to the unit cube by the chart corresponding to $\psi_\lambda$. This is needed to be able to exactly compute the entries of the stiffness matrix for the above case of very simple patch parametrizations.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool FrameTL::intersect_supports ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  mu,
const typename CubeBasis< IBASIS, DIM_d >::Support *  supp_lambda,
const typename CubeBasis< IBASIS, DIM_d >::Support *  supp_mu 
) [inline]

Checks wether the support of the wavelet frame elements $\psi_\lambda$ and $\psi_\mu$ intersect. The supports of the corresponding cube wavelets have to be passed as arguments supp_lambda and supp_mu.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool FrameTL::intersect_supports_1D ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const Index1D< IBASIS > &  lambda,
const Index1D< IBASIS > &  mu,
const typename CubeBasis< IBASIS, DIM_d >::Support *  supp_lambda,
const typename CubeBasis< IBASIS, DIM_d >::Support *  supp_mu,
const int  dir,
Array1D< double > &  supp_intersect 
) [inline]

This function checks whether the supports of the two functions given by lambda and mu intersect. It also generates an irregular partition of the support intersection pulled back to the unit interval by the parametric mapping corresponding to lambda.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
bool FrameTL::intersect_supports_simple ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  mu 
) [inline]

Checks wether the support of the wavelet frame elements intersect. WE ASSUME THAT THE PATCHES ARE RECTANGULAR AND THAT THEY ARE ALIGNED WITH THE CARTESIAN GRID.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void FrameTL::intersecting_wavelets ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const int  p,
const std::set< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &  Lambda,
std::list< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &  intersecting 
) [inline]

For a given wavelet frame element $\psi_\lambda$, compute all generators/wavelets from patch p in the set Lambda, the supports of which intersect the one of $\psi_\lambda$. WE ASSUME AGAIN THAT ONLY RECTANGULAR PATCHTES ALIGNED WITH THE COORDINATE AXES ARE USED.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void FrameTL::intersecting_wavelets ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const int  j,
const bool  generators,
std::list< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &  intersecting 
) [inline]

For a given wavelet frame element $\psi_\lambda$, compute all generators/wavelets $\psi_\nu$ with level $|\nu|=j$, such that the respective supports have a nontrivial intersection.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void FrameTL::intersecting_wavelets_on_patch ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > &  frame,
const typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index &  lambda,
const int  p,
const int  j,
const bool  generators,
std::list< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Index > &  intersecting 
) [inline]

For a given wavelet frame element $\psi_\lambda$, compute all generators/wavelets $\psi_\nu$ with level $|\nu|=j$ on patch p, such that the respective supports have a nontrivial intersection. WE ASSUME AGAIN THAT ONLY RECTANGULAR PATCHTES ALIGNED WITH THE COORDINATE AXES ARE USED.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > FrameTL::last_generator ( const FRAME *  frame,
const int  j 
) [inline]

Index of last generator on level $j \geq j_0$.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int FrameTL::last_generator_num ( const FRAME *  frame  )  [inline]

Number of last generator on level $j_0$.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
FrameIndex< IBASIS, DIM_d, DIM_m > FrameTL::last_wavelet ( const FRAME *  frame,
const int  j 
) [inline]

Index of last wavelet on level $j \geq j_0$.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m, class FRAME >
int FrameTL::last_wavelet_num ( const FRAME *  frame,
const int  j 
) [inline]

Index of last wavelet on level $j \geq j0$.

template<class PROBLEM >
void FrameTL::MultSchw ( const PROBLEM &  P,
const double  epsilon,
Array1D< InfiniteVector< double, typename PROBLEM::Index > > &  approximations 
) [inline]

Adaptive multiplicative Schwarz wavelet frame algorithm from Stevenson, Werner 2009.

Parameters:
P The cached discrete problem.
epsilon The target $\ell_2$-accuracy of the algorithm.
approximations An array of length number of patches +1. We return in this array the local discrete approximations on each patch. The last entry contains the final global discrete approximation at termination.

template<class PROBLEM >
void FrameTL::NGROW ( const PROBLEM &  P,
const int  patch,
const CDD1Parameters &  params,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  F,
const set< typename PROBLEM::WaveletBasis::Index > &  Lambda,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  u_bar,
const double  xi1,
const double  xi2,
set< typename PROBLEM::WaveletBasis::Index > &  Lambda_tilde,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  r,
const int  jmax,
const CompressionStrategy  strategy 
) [inline]

NGROW.

Given a set Lambda, an initial approximation ubar (supported in Lambda) to the Galerkin solutin u_Lambda of Au = F, calculate an approximate residual r with ||r-r_Lambda||_2 <= xi_1 + xi_2 + c_2 * ||ubar-u_Lambda||_2 and a new index set Lambda_tilde Lambda as small as possible such that ||P_{Lambda_tilde Lambda}r||_2 >= gamma * ||r||_2

template<unsigned int DIM>
const double FrameTL::norm2 ( Point< DIM > &  p  )  [inline]

computes l_2 inner product will be placed in class Point in the future or replaced by appropriate function in class tensor

template<class PROBLEM >
void FrameTL::NPROG ( const PROBLEM &  P,
const int  patch,
const CDD1Parameters &  params,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  F,
const set< typename PROBLEM::WaveletBasis::Index > &  Lambda,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  v,
const double  delta,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  v_hat,
set< typename PROBLEM::WaveletBasis::Index > &  Lambda_hat,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  r_hat,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  u_Lambda_k,
const int  jmax,
const CompressionStrategy  strategy 
) [inline]

NPROG.

Given an approximation v (the support of which is contained in Lambda) to the exact Galerkin solution u of Au = F with ||u-v||_2 <= delta, compute a new approximation v_hat supported in Lambda_hat, such that ||u-v_hat||_2 <= delta/2. An approximate residual r_hat as well as the last iterand ubar before the final thresholding are also returned.

template<class PROBLEM >
void FrameTL::NRESIDUAL ( const PROBLEM &  P,
const int  patch,
const CDD1Parameters &  params,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  F,
const set< typename PROBLEM::WaveletBasis::Index > &  Lambda,
const InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  v,
const double  eta1,
const double  eta2,
InfiniteVector< double, typename PROBLEM::WaveletBasis::Index > &  r,
set< typename PROBLEM::WaveletBasis::Index > &  Lambda_tilde,
const int  jmax,
const CompressionStrategy  strategy 
) [inline]

NRESIDUAL.

Given an index set Lambda, an approximation v to the exact Galerkin solution u_Lambda of Au = F, calculate an approximate residual r (not necessarily supported in J), such that ||r - r_Lambda||_2 <= eta_1 + eta_2 + c_2 * ||v-u_Lambda||_2 The routine also returns the support set Lambda_tilde of the approximate residual r.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
std::ostream & FrameTL::operator<< ( std::ostream &  ,
const FrameIndex< IBASIS, DIM_d, DIM_m > &   
) [inline]

Stream output for FrameIndex.

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
std::ostream& FrameTL::operator<< ( std::ostream &  ,
const AggregatedFrame< IBASIS, DIM_d, DIM_m > &   
) [inline]

stream output of an AggregatedFrame

template<unsigned int DIM>
unsigned short int FrameTL::pos_wrt_line ( const Point< DIM > &  p,
const Point< DIM > &  p1,
const Point< DIM > &  p2 
) [inline]

Checks whether p lies left of right of or on the line specified by the Points p1 and p2. This line's orientation is given by the vector starting in p1 and ending in p2. returning 0 means RIGHT OF LINE returning 1 means LEFT OF LINE returning 2 means ON LINE

template<class IBASIS , unsigned int DIM_d, unsigned int DIM_m>
void FrameTL::precompute_supports_simple ( const AggregatedFrame< IBASIS, DIM_d, DIM_m > *  frame,
Array1D< typename AggregatedFrame< IBASIS, DIM_d, DIM_m >::Support > &  all_patch_supports 
) [inline]

For the case of rectangular patches, the supports of all wavelets frame elements between minimal and maximal level are computed. This routine is supposed to be called during the initialization process of an AggregatedFrame in its constructor.

template<unsigned int DIM>
bool FrameTL::quadrangles_intersect ( FixedArray1D< Point< DIM >, 4 >  poly1,
FixedArray1D< Point< DIM >, 4 >  poly2 
) [inline]

This function checks whether the convex qudrangles given by the vertices in poly1 and poly2 have a non-trivial intersection.

template<class PROBLEM >
void FrameTL::receive_all_parts ( const PROBLEM &  ,
InfiniteVector< double, typename PROBLEM::Index > &   
) [inline]

All processors, apart from the master, receive an InfiniteVector<double, typename PROBLEM::Index>. This routine is intended to work hand in hand with broadcast_vec_from_Master. In a parallel adaptive Schwarz frame algorithm, the master broadcasts the new global discrete iterate in an InfiniteVector<double, typename PROBLEM::Index> while the others are receiving this message with receive_all_parts.

template<class PROBLEM >
void FrameTL::send_to_Master ( const InfiniteVector< double, typename PROBLEM::Index > &   )  [inline]

This routine sends an InfiniteVector<double, typename PROBLEM::Index> from the current processor to the master (the one with pid 0).

void FrameTL::setup_coefficient_datatype (  ) 

Create mpi datatype, consisting of an int and a double. Don't forget to call this routine at the very beginning of the mpi program.

template<class PROBLEM >
void FrameTL::simplified_steepest_descent_SOLVE ( const PROBLEM &  problem,
const double  epsilon,
InfiniteVector< double, typename PROBLEM::Index > &  u_epsilon,
const int  jmax 
) [inline]

Implementation of a simplified steepest descent solver as described in [DRWFS] Simplified means that the appearing constants are "guessed" and not estimated as in above publication. That is, we have a standard steepest descent algorithm with APPLY and RHS instead of the normal matrix vector operations. The main iteration step is u := u + alpha * (RHS[eta] - APPLY[eta, u]) with the acceleration parameter alpha = res^T res / (res^T APPLY[eta, res]) and the residual res = (RHS[eta] - APPLY[eta, u])

[DRWFS] Stephan Dahlke, Thorsten Raasch, Manuel Werner, Massimo Fornasier and Rob Stevenson Adaptive frame methods for elliptic operator equations: the steepest descent approach

template<class PROBLEM >
void FrameTL::steepest_descent_SOLVE ( const PROBLEM &  P,
const double  epsilon,
Array1D< InfiniteVector< double, typename PROBLEM::Index > > &  approximations 
) [inline]

Adaptive steepest descent wavelet frame algorithm from Dahlke, Fornasier, Raasch, Stevenson, Werner 2007.

Parameters:
P The cached discrete problem.
epsilon The target $\ell_2$-accuracy of the algorithm.
approximations An array of length number of patches+1. We return in this array the local discrete approximations on each patch. The last entry contains the final global discrete approximation at termination.

template<unsigned int DIM>
Point<DIM> FrameTL::sub ( const Point< DIM > &  p,
const Vector< double > &  b 
) [inline]

difference between Point p, viewed as vector, and Vector b


Generated on Fri Mar 26 17:28:15 2010 by  doxygen 1.5.8