Department of Scientific Computing    Institute for Numerical Simulation    University of Bonn

Documentation

Download

Programming References

Bug Reports / Suggestions

FAQ

Authors

           

---

BlendingWeights.hpp

//
// implementation for BlendingWeights
//

#ifndef _BLENDINGWEIGHTS_
# define _BLENDINGWEIGHTS_

#include "LevelAdaptive.hpp"

template<int DIM>
BlendingWeights<DIM>::BlendingWeights() {
 G=NULL ;
 a=NULL ;
 nBD=0  ;
}

template<int DIM>
BlendingWeights<DIM>::BlendingWeights(LevelAdaptiveGrid<DIM> *AG) {
 a=NULL ;
 nBD=0  ;
 Init(AG) ;  
}

template<int DIM>
void BlendingWeights<DIM>::Init(LevelAdaptiveGrid<DIM> *AG) {
 G=AG ;
 G->Attach(this) ;
 
 // test whether LevelAdaptiveGrid has been initialized
 for (int i=0; i<DIM; i++)
   if (G->Level0[i]==0) { std::cout<< "BlendingWeights<DIM>::Init -> initialize LevelAdaptiveGrid first\n"; exit(-1) ;}
 
 // allocate
 a=new Matrix<int,DIM> ;
 int A[DIM]={0}  ;
 a->Init(A,G->L) ;

 Matrix<int,DIM>::iterator it(a) ;
 for (it=(*a).begin(); it <= (*a).end(); ++it) (*a)[it]=false ;
}

template<int DIM>
BlendingWeights<DIM>::~BlendingWeights() {
 delete a ;
}

template<int DIM>
void BlendingWeights<DIM>::Print(int all) {
 int i,s,anz,size ;
 
 if (all&1) {
   std::cout<< "Weights:\n" ;
   Matrix<int,DIM>::iterator it(a,DIM-1) ;
   for (it=(*a).begin(DIM-1); it <= (*a).end(); ++it) {
     std::cout<<'('<<it.i[0] ;
     for (i=1; i<DIM-1; i++) std::cout<<','<<it.i[i] ;
     std::cout<<",.)=" ;
     
     int in[DIM] ;
     for (i=0; i<DIM-1; i++) in[i]=it.i[i] ;
     for (in[DIM-1]=0; in[DIM-1]<=J[DIM-1]; in[DIM-1]++) std::cout<<(*a)[in]<<' ' ;
     std::cout<<'\n' ;
   }
 } 
 
 if (all&2) {
   
   Matrix<int,DIM>::iterator il(a) ;
   size=anz=0 ;
   for (il=(*a).begin(); il<= (*a).end(); ++il) {
     if ((*a)[il] != 0) {
       s=1 ; 
       for (i=0; i<DIM; i++) s *= (1<<il.i[i])+1 ;
       size +=s ;
       anz  ++  ; 
     }
   }
   std::cout<<"BlendigSpaces: "<<anz<<" Spaces , "<<size<<" Elements\n" ; 
 }
}

template<int DIM>
void BlendingWeights<DIM>::Attach(BlendingData<DIM> *B) {
  int i ;
  for (i=0; i<nBD; i++) if (BD[i]==B) break;
  if (i==nBD) BD[nBD++]=B ;
}

//
//
template<int DIM>
size_t BlendingWeights<DIM>::Size() {
  Matrix<int,DIM>::iterator il(a) ;
  size_t size=0 ;
  for (il=(*a).begin(); il<= (*a).end(); ++il) {
    if ((*a)[il] != 0) {
      size_t s=1,i ; 
      for (i=0; i<DIM; i++) s *= (1<<il.i[i])+1 ;
      size +=s ;
    }
  }
  return size ;
}


template<int DIM>
void BlendingWeights<DIM>::Set(LevelAdaptiveGrid<DIM> *A) {
  int i,s,sm=0 ;
  
  if (a==NULL) { std::cout<<"BlendingWeights<"<<DIM<<">::Set(A) : (*this) not initialized\n"; exit(-1) ;} 
  
  // calc |J|_1
  for (i=0; i<DIM; i++) sm+=G->L[i] ;
  
  // loop in decreasing order because of recursive definition of weights
  for (s=sm; s>=0; s--) {
    // check all entries whether |.|_1=s
    Matrix<int , DIM>::iterator it(a) ;
    for (it=(*a).begin(); it <= (*a).end(); ++it) {
      int  l1  =0 ;
      bool lev0=true ; 
      for (i=0; i<DIM; i++) { 
        l1+=it.i[i] ; 
        if (it.i[i]<G->Level0[i]) lev0=false ;
      }
      // if |.|_1 ok and not coarser than Level0 calculate weight
      if (l1==s)
        if ( lev0 && ((*(A->a))[it.i])) {
          int w=0 ;
          Matrix<int , DIM>::iterator in(it.i , G->L) ;
          for (in.Set(it.i); in<=G->L; ++in) if (in != it) w += (*a)[in] ;
          
          (*a)[it]=1-w ;
        } else (*a)[it]=0 ;
      
    } // next it
  }   // next s
  
  for (i=0; i<nBD; i++) BD[i]->Allocate() ;
}

template<int DIM>
void BlendingWeights<DIM>::Clear() {
  Matrix<int , DIM>::iterator it(a) ;
  for (it=(*a).begin(); it <= (*a).end(); ++it) (*a)[it]=0  ;
}
#endif

---