- Home
- About DUNE
- Download
- Documentation
- Community
- Development
00001 #ifndef DUNE_AMGTRANSFER_HH 00002 #define DUNE_AMGTRANSFER_HH 00003 00004 #include<dune/istl/bvector.hh> 00005 #include<dune/istl/matrixredistribute.hh> 00006 #include<dune/istl/paamg/pinfo.hh> 00007 #include<dune/istl/owneroverlapcopy.hh> 00008 #include<dune/istl/paamg/aggregates.hh> 00009 #include<dune/common/exceptions.hh> 00010 00011 namespace Dune 00012 { 00013 namespace Amg 00014 { 00015 00026 template<class V1, class V2, class T> 00027 class Transfer 00028 { 00029 00030 public: 00031 typedef V1 Vertex; 00032 typedef V2 Vector; 00033 00034 template<typename T1, typename R> 00035 static void prolongate(const AggregatesMap<Vertex>& aggregates, Vector& coarse, Vector& fine, 00036 Vector& fineRedist,T1 damp, R& redistributor=R()); 00037 00038 template<typename T1, typename R> 00039 static void prolongate(const AggregatesMap<Vertex>& aggregates, Vector& coarse, Vector& fine, 00040 T1 damp); 00041 00042 static void restrict(const AggregatesMap<Vertex>& aggregates, Vector& coarse, const Vector& fine, 00043 T& comm); 00044 }; 00045 00046 template<class V,class V1> 00047 class Transfer<V,V1, SequentialInformation> 00048 { 00049 public: 00050 typedef V Vertex; 00051 typedef V1 Vector; 00052 typedef RedistributeInformation<SequentialInformation> Redist; 00053 template<typename T1> 00054 static void prolongate(const AggregatesMap<Vertex>& aggregates, Vector& coarse, Vector& fine, 00055 Vector& fineRedist, T1 damp, 00056 const SequentialInformation& comm=SequentialInformation(), 00057 const Redist& redist=Redist()); 00058 template<typename T1> 00059 static void prolongate(const AggregatesMap<Vertex>& aggregates, Vector& coarse, Vector& fine, 00060 T1 damp, 00061 const SequentialInformation& comm=SequentialInformation()); 00062 00063 00064 static void restrict(const AggregatesMap<Vertex>& aggregates, Vector& coarse, const Vector& fine, 00065 const SequentialInformation& comm); 00066 }; 00067 00068 #if HAVE_MPI 00069 00070 template<class V,class V1, class T1, class T2> 00071 class Transfer<V,V1,OwnerOverlapCopyCommunication<T1,T2> > 00072 { 00073 public: 00074 typedef V Vertex; 00075 typedef V1 Vector; 00076 typedef RedistributeInformation<OwnerOverlapCopyCommunication<T1,T2> > Redist; 00077 template<typename T3> 00078 static void prolongate(const AggregatesMap<Vertex>& aggregates, Vector& coarse, Vector& fine, 00079 Vector& fineRedist, T3 damp, OwnerOverlapCopyCommunication<T1,T2>& comm, 00080 const Redist& redist); 00081 template<typename T3> 00082 static void prolongate(const AggregatesMap<Vertex>& aggregates, Vector& coarse, Vector& fine, 00083 T3 damp, OwnerOverlapCopyCommunication<T1,T2>& comm); 00084 00085 static void restrict(const AggregatesMap<Vertex>& aggregates, Vector& coarse, const Vector& fine, 00086 OwnerOverlapCopyCommunication<T1,T2>& comm); 00087 }; 00088 00089 #endif 00090 00091 template<class V, class V1> 00092 template<typename T> 00093 inline void 00094 Transfer<V,V1,SequentialInformation>::prolongate(const AggregatesMap<Vertex>& aggregates, 00095 Vector& coarse, Vector& fine, Vector& fineRedist, 00096 T damp, 00097 const SequentialInformation& comm, 00098 const Redist& redist) 00099 { 00100 prolongate(aggregates, coarse, fine, damp); 00101 } 00102 template<class V, class V1> 00103 template<typename T> 00104 inline void 00105 Transfer<V,V1,SequentialInformation>::prolongate(const AggregatesMap<Vertex>& aggregates, 00106 Vector& coarse, Vector& fine, 00107 T damp, 00108 const SequentialInformation& comm) 00109 { 00110 typedef typename Vector::iterator Iterator; 00111 00112 Iterator end = coarse.end(); 00113 Iterator begin= coarse.begin(); 00114 for(;begin!=end;++begin) 00115 *begin*=damp; 00116 end=fine.end(); 00117 begin=fine.begin(); 00118 00119 for(Iterator block=begin; block != end; ++block){ 00120 std::ptrdiff_t index=block-begin; 00121 const Vertex& vertex = aggregates[index]; 00122 if(vertex != AggregatesMap<Vertex>::ISOLATED) 00123 *block += coarse[aggregates[index]]; 00124 } 00125 } 00126 00127 template<class V, class V1> 00128 inline void 00129 Transfer<V,V1,SequentialInformation>::restrict(const AggregatesMap<Vertex>& aggregates, 00130 Vector& coarse, 00131 const Vector& fine, 00132 const SequentialInformation& comm) 00133 { 00134 // Set coarse vector to zero 00135 coarse=0; 00136 00137 typedef typename Vector::const_iterator Iterator; 00138 Iterator end = fine.end(); 00139 Iterator begin=fine.begin(); 00140 00141 for(Iterator block=begin; block != end; ++block){ 00142 const Vertex& vertex = aggregates[block-begin]; 00143 if(vertex != AggregatesMap<Vertex>::ISOLATED) 00144 coarse[vertex] += *block; 00145 } 00146 } 00147 00148 #if HAVE_MPI 00149 template<class V, class V1, class T1, class T2> 00150 template<typename T3> 00151 inline void Transfer<V,V1,OwnerOverlapCopyCommunication<T1,T2> >::prolongate(const AggregatesMap<Vertex>& aggregates, 00152 Vector& coarse, Vector& fine, 00153 Vector& fineRedist, T3 damp, 00154 OwnerOverlapCopyCommunication<T1,T2>& comm, 00155 const Redist& redist) 00156 { 00157 if(fineRedist.size()>0) 00158 // we operated on the coarse level 00159 Transfer<V,V1,SequentialInformation>::prolongate(aggregates, coarse, fineRedist, damp); 00160 00161 // TODO This could be accomplished with one communication, too! 00162 redist.redistributeBackward(fine, fineRedist); 00163 comm.copyOwnerToAll(fine,fine); 00164 } 00165 00166 template<class V, class V1, class T1, class T2> 00167 template<typename T3> 00168 inline void Transfer<V,V1,OwnerOverlapCopyCommunication<T1,T2> >::prolongate(const AggregatesMap<Vertex>& aggregates, 00169 Vector& coarse, Vector& fine, 00170 T3 damp, 00171 OwnerOverlapCopyCommunication<T1,T2>& comm) 00172 { 00173 Transfer<V,V1,SequentialInformation>::prolongate(aggregates, coarse, fine, damp); 00174 } 00175 template<class V, class V1, class T1, class T2> 00176 inline void Transfer<V,V1,OwnerOverlapCopyCommunication<T1,T2> >::restrict(const AggregatesMap<Vertex>& aggregates, 00177 Vector& coarse, const Vector& fine, 00178 OwnerOverlapCopyCommunication<T1,T2>& comm) 00179 { 00180 Transfer<V,V1,SequentialInformation>::restrict(aggregates, coarse, fine, SequentialInformation()); 00181 // We need this here to avoid it in the smoothers on the coarse level. 00182 // There (in the preconditioner d is const. 00183 comm.project(coarse); 00184 } 00185 #endif 00186 00187 }// namspace Amg 00188 } // namspace Dune 00189 #endif
Generated on Fri Apr 29 2011 with Doxygen (ver 1.7.1) [doxygen-log,error-log].