construction.hh

Go to the documentation of this file.
00001 // $Id: construction.hh 751 2007-04-20 13:59:25Z mblatt $
00002 #ifndef DUNE_AMGCONSTRUCTION_HH
00003 #define DUNE_AMGCONSTRUCTION_HH
00004 
00005 #include<dune/istl/bvector.hh>
00006 #include<dune/istl/operators.hh>
00007 #include<dune/istl/owneroverlapcopy.hh>
00008 #include"pinfo.hh"
00009 
00010 namespace Dune
00011 {
00012   namespace Amg
00013   {
00014     
00033     template<typename T>
00034     class ConstructionTraits
00035     {
00036     public:
00041       typedef const void* Arguments;
00042       
00049       static inline T* construct(Arguments&  args)
00050       {
00051          return new T();
00052       }
00053 
00058       static inline void deconstruct(T* t)
00059       {
00060         delete t;
00061       }
00062       
00063     };
00064     
00065     template<class T>
00066     class ConstructionTraits<BlockVector<T> >
00067     {
00068     public:
00069       typedef const int Arguments;
00070       static inline BlockVector<T>* construct(Arguments& n)
00071       {
00072         return new BlockVector<T>(n);
00073       }
00074 
00075       static inline void deconstruct(BlockVector<T>* t)
00076       {
00077         delete t;
00078       }
00079     };
00080 
00081     template<class M, class C>
00082     struct OverlappingSchwarzOperatorArgs
00083     {
00084       OverlappingSchwarzOperatorArgs(M& matrix, C& comm)
00085         : matrix_(&matrix), comm_(&comm)
00086       {}
00087       
00088       M* matrix_;
00089       C* comm_;
00090     };
00091     
00092   }// end Amg namspace
00093 
00094   // foward declaration
00095   template<class M, class X, class Y, class C>
00096   class OverlappingSchwarzOperator;
00097 
00098   namespace Amg
00099   {
00100     template<class M, class X, class Y, class C>
00101     class ConstructionTraits<OverlappingSchwarzOperator<M,X,Y,C> >
00102     {
00103     public:
00104       typedef OverlappingSchwarzOperatorArgs<M,C> Arguments;
00105       
00106       static inline OverlappingSchwarzOperator<M,X,Y,C>* construct(const Arguments& args)
00107       {
00108         return new OverlappingSchwarzOperator<M,X,Y,C>(*args.matrix_, *args.comm_);
00109       }
00110       
00111       static inline void deconstruct(OverlappingSchwarzOperator<M,X,Y,C>* t)
00112       {
00113         delete t;
00114       }
00115     };
00116 
00117 
00118     template<class M, class X, class Y>
00119     struct MatrixAdapterArgs
00120     {
00121       MatrixAdapterArgs(M& matrix, const SequentialInformation&)
00122         : matrix_(&matrix)
00123       {}
00124       
00125       M* matrix_;
00126     };
00127         
00128     template<class M, class X, class Y>
00129     class ConstructionTraits<MatrixAdapter<M,X,Y> >
00130     {
00131     public:
00132       typedef const MatrixAdapterArgs<M,X,Y> Arguments;
00133       
00134       static inline MatrixAdapter<M,X,Y>* construct(Arguments& args)
00135       {
00136         return new MatrixAdapter<M,X,Y>(*args.matrix_);
00137       }
00138 
00139       static inline void deconstruct(MatrixAdapter<M,X,Y>* m)
00140       {
00141         delete m;
00142       }
00143     };
00144 
00145     template<>
00146     class ConstructionTraits<SequentialInformation>
00147     {
00148     public:
00149       typedef const CollectiveCommunication<void*> Arguments;
00150       
00151       static inline SequentialInformation* construct(Arguments& args)
00152       {
00153         return new SequentialInformation(args);
00154       }
00155       
00156       static inline void deconstruct(SequentialInformation* si)
00157       {
00158         delete si;
00159       }
00160     };
00161     
00162 
00163 #if HAVE_MPI
00164     template<typename T>
00165     class ConstructionTraits<ParallelInformation<T> >
00166     {
00167     public:
00168       typedef const MPI_Comm Arguments;
00169       
00170       static inline ParallelInformation<T>* construct(Arguments& args)
00171       {
00172         return new ParallelInformation<T>(args);
00173       }
00174       
00175       static inline void deconstruct(ParallelInformation<T>* pi)
00176       {
00177         delete pi;
00178       }
00179     };
00180     
00181 
00182     template<class T1, class T2>
00183     class ConstructionTraits<OwnerOverlapCopyCommunication<T1,T2> >
00184     {
00185     public:
00186       typedef const MPI_Comm Arguments;
00187       
00188       static inline OwnerOverlapCopyCommunication<T1,T2>* construct(Arguments& args)
00189       {
00190         return new OwnerOverlapCopyCommunication<T1,T2>(args);
00191       }
00192       
00193       static inline void deconstruct(OwnerOverlapCopyCommunication<T1,T2>* com)
00194       {
00195         delete com;
00196       }
00197     };
00198 
00199 #endif
00200     
00202 } // namespace Amg
00203 } // namespace Dune
00204 #endif

Generated on 9 Apr 2008 with Doxygen (ver 1.5.2) [logfile].