Xpetra_TpetraMapExtractor.hpp Source File

Go to the documentation of this file.
00001 // @HEADER
00002 //
00003 // ***********************************************************************
00004 //
00005 //             Xpetra: A linear algebra interface package
00006 //                  Copyright 2012 Sandia Corporation
00007 //
00008 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
00009 // the U.S. Government retains certain rights in this software.
00010 //
00011 // Redistribution and use in source and binary forms, with or without
00012 // modification, are permitted provided that the following conditions are
00013 // met:
00014 //
00015 // 1. Redistributions of source code must retain the above copyright
00016 // notice, this list of conditions and the following disclaimer.
00017 //
00018 // 2. Redistributions in binary form must reproduce the above copyright
00019 // notice, this list of conditions and the following disclaimer in the
00020 // documentation and/or other materials provided with the distribution.
00021 //
00022 // 3. Neither the name of the Corporation nor the names of the
00023 // contributors may be used to endorse or promote products derived from
00024 // this software without specific prior written permission.
00025 //
00026 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
00027 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00028 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00029 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
00030 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00031 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00032 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00033 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00034 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00035 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00036 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00037 //
00038 // Questions? Contact
00039 //                    Jeremie Gaidamour (jngaida@sandia.gov)
00040 //                    Jonathan Hu       (jhu@sandia.gov)
00041 //                    Ray Tuminaro      (rstumin@sandia.gov)
00042 //
00043 // ***********************************************************************
00044 //
00045 // @HEADER
00046 /*
00047  * Xpetra_TpetraMapExtractor.hpp
00048  *
00049  *  Created on: Aug 22, 2011
00050  *      Author: wiesner
00051  */
00052 
00053 // WARNING: This code is experimental. Backwards compatibility should not be expected.
00054 
00055 #ifndef XPETRA_TPETRAMAPEXTRACTOR_HPP_
00056 #define XPETRA_TPETRAMAPEXTRACTOR_HPP_
00057 
00058 #include <Xpetra_MapExtractor.hpp>
00059 
00060 namespace Xpetra
00061 {
00062   template <class Scalar, class LocalOrdinal = int, class GlobalOrdinal = LocalOrdinal, class Node = Kokkos::DefaultNode::DefaultNodeType>
00063   class TpetraMapExtractor : public Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node>
00064   {
00065     typedef Map<LocalOrdinal,GlobalOrdinal,Node> MapClass;
00066     typedef TpetraMap<LocalOrdinal,GlobalOrdinal,Node> TpetraMapClass;
00067     typedef Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> VectorClass;
00068     typedef MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> MultiVectorClass;
00069     typedef TpetraVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> TpetraVectorClass;
00070     typedef TpetraMultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> TpetraMultiVectorClass;
00071     typedef Import<LocalOrdinal,GlobalOrdinal,Node> ImportClass;
00072     typedef TpetraImport<LocalOrdinal,GlobalOrdinal,Node> TpetraImportClass;
00073 
00074   public:
00076     TpetraMapExtractor(const Teuchos::RCP<const MapClass>& fullmap, const std::vector<Teuchos::RCP<const MapClass> >& maps)
00077     {
00078       XPETRA_RCP_DYNAMIC_CAST(const TpetraMapClass, fullmap, tfullmap, "Xpetra::TpetraMapextractor constructors only accept Xpetra::TpetraMap as input arguments.");
00079 
00080       fullmap_ = tfullmap;
00081 
00082       unsigned int numMaps = maps.size();
00083       maps_.empty();
00084       importer_.resize(numMaps);
00085       for (unsigned i=0; i<numMaps; ++i)
00086       {
00087         if (maps[i]!=Teuchos::null)
00088         {
00089           XPETRA_RCP_DYNAMIC_CAST(const TpetraMapClass, maps[i], tmapi, "Xpetra::TpetraMapextractor constructors only accept Xpetra::TpetraMap as input arguments.");
00090           maps_.push_back(tmapi);
00091           importer_[i] = Teuchos::rcp(new Xpetra::TpetraImport<LocalOrdinal,GlobalOrdinal,Node>(tfullmap,tmapi));
00092         }
00093       }
00094       TEUCHOS_TEST_FOR_EXCEPTION(CheckConsistency()==false,std::logic_error,"logic error. full map and sub maps are inconsistently distributed over the processors.");
00095     }
00096 
00098     TpetraMapExtractor(const Teuchos::RCP<const TpetraMapClass>& fullmap, const std::vector<Teuchos::RCP<const TpetraMapClass> >& maps)
00099     {
00100       XPETRA_RCP_DYNAMIC_CAST(const TpetraMapClass, fullmap, tfullmap, "Xpetra::TpetraMapextractor constructors only accept Xpetra::TpetraMap as input arguments.");
00101 
00102       fullmap_ = tfullmap;
00103       maps_    = maps;
00104 
00105       importer_.resize(maps_.size());
00106       for (unsigned i=0; i< importer_.size(); ++i)
00107       {
00108         if (maps_[i]!=Teuchos::null)
00109         {
00110           Teuchos::RCP<TpetraImportClass> tImport = Teuchos::rcp_dynamic_cast<TpetraImportClass>(Xpetra::ImportFactory<LocalOrdinal,GlobalOrdinal,Node>::Build(fullmap_,maps_[i]));
00111           if (tImport == Teuchos::null) std::cout << "no TpetraImportFactory?" << std::endl;
00112           importer_[i] = tImport;
00113           std::cout << *importer_[i] << std::endl;
00114         }
00115       }
00116       TEUCHOS_TEST_FOR_EXCEPTION(CheckConsistency()==false,std::logic_error,"logic error. full map and sub maps are inconsistently distributed over the processors.");
00117     }
00118 
00120     inline virtual ~TpetraMapExtractor() {};
00121 
00122     void InsertVector(const TpetraVectorClass& partial, size_t block, TpetraVectorClass& full) const
00123     {
00124       if (maps_[block] == Teuchos::null)
00125         std::cout << "null map at block" << block << std::endl;
00126 
00127       full.doExport(partial,*importer_[block],Xpetra::INSERT);
00128     }
00129 
00130     void InsertVector(Teuchos::RCP<const VectorClass>& partial, size_t block, Teuchos::RCP<VectorClass>& full) const
00131     {
00132       XPETRA_RCP_DYNAMIC_CAST(TpetraVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00133       XPETRA_RCP_DYNAMIC_CAST(const TpetraVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00134 
00135       InsertVector(*tpartial,block,*tfull);
00136     }
00137 
00138     void InsertVector(Teuchos::RCP<VectorClass>& partial, size_t block, Teuchos::RCP<VectorClass>& full) const
00139     {
00140       XPETRA_RCP_DYNAMIC_CAST(TpetraVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accept Xpetra::TpetraMap as input arguments.");
00141       XPETRA_RCP_DYNAMIC_CAST(TpetraVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accept Xpetra::TpetraMap as input arguments.");
00142 
00143       InsertVector(*tpartial,block,*tfull);
00144     }
00145 
00146     void InsertVector(const TpetraMultiVectorClass& partial, size_t block, TpetraMultiVectorClass& full) const
00147     {
00148       if (maps_[block] == Teuchos::null)
00149         std::cout << "null map at block" << block << std::endl;
00150 
00151       full.doExport(partial,*importer_[block],Xpetra::INSERT);
00152     }
00153 
00154     void InsertVector(Teuchos::RCP<const MultiVectorClass>& partial, size_t block, Teuchos::RCP<MultiVectorClass>& full) const
00155     {
00156       XPETRA_RCP_DYNAMIC_CAST(TpetraMultiVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00157       XPETRA_RCP_DYNAMIC_CAST(const TpetraMultiVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00158 
00159       InsertVector(*tpartial,block,*tfull);
00160     }
00161 
00162     void InsertVector(Teuchos::RCP<MultiVectorClass>& partial, size_t block, Teuchos::RCP<MultiVectorClass>& full) const
00163     {
00164       XPETRA_RCP_DYNAMIC_CAST(TpetraMultiVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accept Xpetra::TpetraMap as input arguments.");
00165       XPETRA_RCP_DYNAMIC_CAST(TpetraMultiVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accept Xpetra::TpetraMap as input arguments.");
00166 
00167       InsertVector(*tpartial,block,*tfull);
00168     }
00169 
00170     void ExtractVector(const TpetraVectorClass& full, size_t block, TpetraVectorClass& partial) const
00171     {
00172       if (maps_[block] == Teuchos::null)
00173         std::cout << "null map at block " << block << std::endl;
00174       partial.doImport(full, *importer_[block], Xpetra::INSERT);
00175     }
00176 
00177     void ExtractVector(Teuchos::RCP<const VectorClass>& full, size_t block, Teuchos::RCP<VectorClass>& partial) const
00178     {
00179       XPETRA_RCP_DYNAMIC_CAST(const TpetraVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00180       XPETRA_RCP_DYNAMIC_CAST(      TpetraVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00181 
00182       ExtractVector(*tfull,block,*tpartial);
00183     }
00184 
00185     virtual Teuchos::RCP<VectorClass> ExtractVector(Teuchos::RCP<const VectorClass>& full, size_t block) const
00186     {
00187       XPETRA_RCP_DYNAMIC_CAST(const TpetraVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00188       TEUCHOS_TEST_FOR_EXCEPTION( maps_[block] == Teuchos::null, Xpetra::Exceptions::RuntimeError,
00189             "ExtractVector: maps_[" << block << "]=Teuchos::null" );
00190       const Teuchos::RCP<TpetraVectorClass> ret = Teuchos::rcp(new TpetraVectorClass(getMap(block),true));
00191       ExtractVector(*tfull,block,*ret);
00192       return ret;
00193     }
00194 
00195     virtual Teuchos::RCP<VectorClass> ExtractVector(Teuchos::RCP<VectorClass>& full, size_t block) const
00196     {
00197       XPETRA_RCP_DYNAMIC_CAST(TpetraVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00198       TEUCHOS_TEST_FOR_EXCEPTION( maps_[block] == Teuchos::null, Xpetra::Exceptions::RuntimeError,
00199             "ExtractVector: maps_[" << block << "]=Teuchos::null" );
00200       const Teuchos::RCP<TpetraVectorClass> ret = Teuchos::rcp(new TpetraVectorClass(getMap(block),true));
00201       ExtractVector(*tfull,block,*ret);
00202       return ret;
00203     }
00204 
00205     void ExtractVector(Teuchos::RCP<VectorClass>& full, size_t block, Teuchos::RCP<VectorClass>& partial) const
00206     {
00207       XPETRA_RCP_DYNAMIC_CAST(TpetraVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00208       XPETRA_RCP_DYNAMIC_CAST(TpetraVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00209 
00210       ExtractVector(*tfull,block,*tpartial);
00211     }
00212 
00213     void ExtractVector(const TpetraMultiVectorClass& full, size_t block, TpetraMultiVectorClass& partial) const
00214     {
00215       if (maps_[block] == Teuchos::null)
00216         std::cout << "null map at block " << block << std::endl;
00217       partial.doImport(full, *importer_[block], Xpetra::INSERT);
00218     }
00219 
00220     virtual void ExtractVector(Teuchos::RCP<const MultiVectorClass>& full, size_t block, Teuchos::RCP<MultiVectorClass>& partial) const
00221     {
00222       XPETRA_RCP_DYNAMIC_CAST(const TpetraMultiVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00223       XPETRA_RCP_DYNAMIC_CAST(      TpetraMultiVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00224 
00225       ExtractVector(*tfull,block,*tpartial);
00226     }
00227 
00228     virtual void ExtractVector(Teuchos::RCP<      MultiVectorClass>& full, size_t block, Teuchos::RCP<MultiVectorClass>& partial) const
00229     {
00230       XPETRA_RCP_DYNAMIC_CAST(      TpetraMultiVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00231       XPETRA_RCP_DYNAMIC_CAST(      TpetraMultiVectorClass, partial, tpartial, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00232 
00233       ExtractVector(*tfull,block,*tpartial);
00234     }
00235 
00236     virtual Teuchos::RCP<MultiVectorClass> ExtractVector(Teuchos::RCP<const MultiVectorClass>& full, size_t block) const
00237     {
00238       XPETRA_RCP_DYNAMIC_CAST(const TpetraMultiVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00239       TEUCHOS_TEST_FOR_EXCEPTION( maps_[block] == Teuchos::null, Xpetra::Exceptions::RuntimeError,
00240             "ExtractVector: maps_[" << block << "]=Teuchos::null" );
00241       const Teuchos::RCP<TpetraMultiVectorClass> ret = Teuchos::rcp(new TpetraMultiVectorClass(getMap(block),full->getNumVectors(),true));
00242       ExtractVector(*tfull,block,*ret);
00243       return ret;
00244     }
00245 
00246     virtual Teuchos::RCP<MultiVectorClass> ExtractVector(Teuchos::RCP<MultiVectorClass>& full, size_t block) const
00247     {
00248       XPETRA_RCP_DYNAMIC_CAST(TpetraMultiVectorClass, full, tfull, "Xpetra::TpetraMapextractor constructors only accepts Xpetra::TpetraMap as input arguments.");
00249       TEUCHOS_TEST_FOR_EXCEPTION( maps_[block] == Teuchos::null, Xpetra::Exceptions::RuntimeError,
00250             "ExtractVector: maps_[" << block << "]=Teuchos::null" );
00251       const Teuchos::RCP<TpetraMultiVectorClass> ret = Teuchos::rcp(new TpetraMultiVectorClass(getMap(block),full->getNumVectors(),true));
00252       ExtractVector(*tfull,block,*ret);
00253       return ret;
00254     }
00255 
00256     virtual Teuchos::RCP<VectorClass> getVector(size_t i) const
00257     {
00258       return Teuchos::rcp(new TpetraVectorClass(getMap(i),true));
00259     }
00260 
00261     virtual Teuchos::RCP<MultiVectorClass> getVector(size_t i, size_t numvec) const
00262     {
00263       return Teuchos::rcp(new TpetraMultiVectorClass(getMap(i),numvec,true));
00264     }
00265 
00266 
00269 
00271     size_t NumMaps() const { return maps_.size(); }
00272 
00274     const Teuchos::RCP<const MapClass> getMap(size_t i) const { return maps_[i]; }
00275 
00277     const Teuchos::RCP<const MapClass> getFullMap() const { return fullmap_; }
00278 
00279     size_t getMapIndexForGID(GlobalOrdinal gid) const {
00280 
00281       for(size_t i = 0; i < NumMaps(); i++) {
00282         if(getMap(i)->isNodeGlobalElement(gid) == true)
00283           return i;
00284       }
00285       TEUCHOS_TEST_FOR_EXCEPTION( false, Xpetra::Exceptions::RuntimeError,
00286                   "getMapIndexForGID: GID " << gid << " is not contained by a map in mapextractor." );
00287       return 0;
00288     }
00289 
00291   private:
00292 
00293     virtual bool CheckConsistency() const {
00294       const Teuchos::RCP<const MapClass> fullMap = getFullMap();
00295 
00296       for(size_t i = 0; i<NumMaps(); i++) {
00297         const Teuchos::RCP<const MapClass> map = getMap(i);
00298 
00299         Teuchos::ArrayView< const GlobalOrdinal > mapGids = map->getNodeElementList();
00300         typename Teuchos::ArrayView< const GlobalOrdinal >::const_iterator it;
00301         for(it = mapGids.begin(); it!=mapGids.end(); it++) {
00302           if(fullMap->isNodeGlobalElement(*it)==false)
00303             return false; // Global ID (*it) not found locally on this proc in fullMap -> error
00304         }
00305       }
00306       return true;
00307     }
00308   protected:
00309     std::vector<Teuchos::RCP<const TpetraMapClass > > maps_;
00310     Teuchos::RCP<const TpetraMapClass > fullmap_;
00311     std::vector<Teuchos::RCP<TpetraImportClass > > importer_;
00312   };
00313 }
00314 
00315 
00316 #endif /* XPETRA_TPETRAMAPEXTRACTOR_HPP_ */