Xpetra_MapFactory.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 //                    Jonathan Hu       (jhu@sandia.gov)
00040 //                    Andrey Prokopenko (aprokop@sandia.gov)
00041 //                    Ray Tuminaro      (rstumin@sandia.gov)
00042 //
00043 // ***********************************************************************
00044 //
00045 // @HEADER
00046 #ifndef XPETRA_MAPFACTORY_HPP
00047 #define XPETRA_MAPFACTORY_HPP
00048 
00049 #include "Xpetra_ConfigDefs.hpp"
00050 #include "Xpetra_Map.hpp"
00051 
00052 #ifdef HAVE_XPETRA_TPETRA
00053 #  include "Xpetra_TpetraMap.hpp"
00054 #endif
00055 #ifdef HAVE_XPETRA_EPETRA
00056 #  include "Xpetra_EpetraMap.hpp"
00057 #endif
00058 
00059 #include "Xpetra_Exceptions.hpp"
00060 
00061 namespace Xpetra {
00067   template <class LocalOrdinal = Map<>::local_ordinal_type,
00068             class GlobalOrdinal = typename Map<LocalOrdinal>::global_ordinal_type,
00069             class Node = typename Map<LocalOrdinal, GlobalOrdinal>::node_type>
00070   class MapFactory {
00071 
00072   private:
00074     MapFactory() {}
00075 
00076   public:
00077     static Teuchos::RCP<Node> defaultArgNode() {
00078       // Workaround function for a deferred visual studio bug
00079       //
00080       // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
00081       //
00082       // Use this function for default arguments rather than calling
00083       // what is the return value below.  Also helps in reducing
00084       // duplication in various constructors.
00085       return KokkosClassic::Details::getNode<Node>();
00086     }
00087 
00089     static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00090     Build (UnderlyingLib lib,
00091            global_size_t numGlobalElements,
00092            GlobalOrdinal indexBase,
00093            const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
00094            LocalGlobal lg = Xpetra::GloballyDistributed,
00095            const Teuchos::RCP<Node> &node = defaultArgNode ())
00096     {
00097       XPETRA_MONITOR("MapFactory::Build");
00098 
00099 #ifdef HAVE_XPETRA_TPETRA
00100       if (lib == UseTpetra)
00101         return Teuchos::rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
00102 #endif
00103 
00104       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00105       XPETRA_FACTORY_END;
00106     }
00107 
00109     static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00110     Build (UnderlyingLib lib,
00111            global_size_t numGlobalElements,
00112            size_t numLocalElements,
00113            GlobalOrdinal indexBase,
00114            const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
00115            const Teuchos::RCP<Node> &node = defaultArgNode ())
00116     {
00117       XPETRA_MONITOR("MapFactory::Build");
00118 
00119 #ifdef HAVE_XPETRA_TPETRA
00120       if (lib == UseTpetra)
00121         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
00122 #endif
00123 
00124       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00125       XPETRA_FACTORY_END;
00126     }
00127 
00129     static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00130     Build (UnderlyingLib lib,
00131            global_size_t numGlobalElements,
00132            const Teuchos::ArrayView<const GlobalOrdinal> &elementList,
00133            GlobalOrdinal indexBase,
00134            const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
00135            const Teuchos::RCP<Node> &node = defaultArgNode ())
00136     {
00137       XPETRA_MONITOR("MapFactory::Build");
00138 
00139 #ifdef HAVE_XPETRA_TPETRA
00140       if (lib == UseTpetra)
00141         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
00142 #endif
00143 
00144       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00145       XPETRA_FACTORY_END;
00146     }
00147 
00149     static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00150     Build (const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >& map,
00151            LocalOrdinal numDofPerNode)
00152     {
00153       XPETRA_MONITOR("MapFactory::Build");
00154 
00155 #ifdef HAVE_XPETRA_TPETRA
00156       LocalOrdinal N = map->getNodeNumElements();
00157       Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
00158       Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
00159       for (LocalOrdinal i = 0; i < N; i++)
00160         for (LocalOrdinal j = 0; j < numDofPerNode; j++)
00161           newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
00162       if (map->lib() == UseTpetra)
00163         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
00164 #endif
00165 
00166       XPETRA_FACTORY_ERROR_IF_EPETRA(map->lib());
00167       XPETRA_FACTORY_END;
00168     }
00169 
00171     static Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal, Node> >
00172     createLocalMap (UnderlyingLib lib,
00173                     size_t numElements,
00174                     const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
00175     {
00176        XPETRA_MONITOR("MapFactory::Build");
00177 
00178 #ifdef HAVE_XPETRA_TPETRA
00179       if (lib == UseTpetra)
00180         return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal>(Tpetra::createLocalMap<LocalOrdinal,GlobalOrdinal>(numElements, comm)));
00181 #endif
00182 
00183       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00184       XPETRA_FACTORY_END;
00185     }
00186 
00188     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00189     createLocalMapWithNode (UnderlyingLib lib,
00190                             size_t numElements,
00191                             const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
00192                             const Teuchos::RCP< Node > &node)
00193     {
00194       XPETRA_MONITOR("MapFactory::Build");
00195 
00196 #ifdef HAVE_XPETRA_TPETRA
00197       if (lib == UseTpetra)
00198         return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm, node)));
00199 #endif
00200 
00201       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00202       XPETRA_FACTORY_END;
00203     }
00204 
00206     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00207     createUniformContigMapWithNode (UnderlyingLib lib,
00208                                     global_size_t numElements,
00209                                     const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
00210                                     const Teuchos::RCP< Node > &node)
00211     {
00212       XPETRA_MONITOR("MapFactory::Build");
00213 
00214 #ifdef HAVE_XPETRA_TPETRA
00215       if (lib == UseTpetra)
00216         return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm, node)));
00217 #endif
00218 
00219       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00220       XPETRA_FACTORY_END;
00221     }
00222 
00224     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
00225     createUniformContigMap (UnderlyingLib lib,
00226                             global_size_t numElements,
00227                             const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
00228     {
00229       XPETRA_MONITOR("MapFactory::Build");
00230 
00231 #ifdef HAVE_XPETRA_TPETRA
00232       if (lib == UseTpetra)
00233         return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal>(Tpetra::createUniformContigMap<LocalOrdinal,GlobalOrdinal>(numElements, comm)));
00234 #endif
00235 
00236       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00237       XPETRA_FACTORY_END;
00238     }
00239 
00241     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00242     createContigMap (UnderlyingLib lib,
00243                      global_size_t numElements,
00244                      size_t localNumElements,
00245                      const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
00246     {
00247       XPETRA_MONITOR("MapFactory::Build");
00248 
00249 #ifdef HAVE_XPETRA_TPETRA
00250       if (lib == UseTpetra)
00251         return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal>(Tpetra::createContigMap<LocalOrdinal,GlobalOrdinal>(numElements, localNumElements, comm)));
00252 #endif
00253 
00254       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00255       XPETRA_FACTORY_END;
00256     }
00257 
00259     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00260     createContigMapWithNode (UnderlyingLib lib,
00261                              global_size_t numElements,
00262                              size_t localNumElements,
00263                              const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
00264                              const Teuchos::RCP< Node > &node)
00265     {
00266       XPETRA_MONITOR("MapFactory::Build");
00267 
00268 #ifdef HAVE_XPETRA_TPETRA
00269       if (lib == UseTpetra)
00270         return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
00271 #endif
00272 
00273       XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
00274       XPETRA_FACTORY_END;
00275     }
00276   };
00277 
00278   template <>
00279   class MapFactory<int, int> {
00280 
00281     typedef int LocalOrdinal;
00282     typedef int GlobalOrdinal;
00283     typedef Map<int, GlobalOrdinal>::node_type Node;
00284 
00285   private:
00287     MapFactory() {}
00288 
00289   public:
00290 
00291     static Teuchos::RCP<Node> defaultArgNode () {
00292       // Workaround function for a deferred visual studio bug
00293       //
00294       // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
00295       //
00296       // Use this function for default arguments rather than calling
00297       // what is the return value below.  Also helps in reducing
00298       // duplication in various constructors.
00299       return KokkosClassic::Details::getNode<Node>();
00300     }
00301 
00302     static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00303     Build (UnderlyingLib lib,
00304            global_size_t numGlobalElements,
00305            int indexBase,
00306            const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
00307            LocalGlobal lg=GloballyDistributed,
00308            const Teuchos::RCP<Node>& node = defaultArgNode ()) {
00309       XPETRA_MONITOR("MapFactory::Build");
00310 
00311 #ifdef HAVE_XPETRA_TPETRA
00312       if (lib == UseTpetra)
00313         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
00314 #endif
00315 
00316 #ifdef HAVE_XPETRA_EPETRA
00317 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00318       if (lib == UseEpetra)
00319         return rcp( new EpetraMapT<int>(numGlobalElements, indexBase, comm, lg, node) );
00320 #endif
00321 #endif
00322 
00323       XPETRA_FACTORY_END;
00324     }
00325 
00326     static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00327     Build (UnderlyingLib lib,
00328            global_size_t numGlobalElements,
00329            size_t numLocalElements,
00330            int indexBase,
00331            const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
00332            const Teuchos::RCP<Node>& node = defaultArgNode())
00333     {
00334       XPETRA_MONITOR("MapFactory::Build");
00335 
00336 #ifdef HAVE_XPETRA_TPETRA
00337       if (lib == UseTpetra)
00338         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
00339 #endif
00340 
00341 #ifdef HAVE_XPETRA_EPETRA
00342 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00343       if (lib == UseEpetra)
00344         return rcp( new EpetraMapT<int>(numGlobalElements, numLocalElements, indexBase, comm, node) );
00345 #endif
00346 #endif
00347 
00348       XPETRA_FACTORY_END;
00349     }
00350 
00351     static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(UnderlyingLib lib, global_size_t numGlobalElements, const Teuchos::ArrayView<const GlobalOrdinal> &elementList, int indexBase, const Teuchos::RCP<const Teuchos::Comm<int> > &comm, const Teuchos::RCP<Node>& node = defaultArgNode ()) {
00352       XPETRA_MONITOR("MapFactory::Build");
00353 
00354 #ifdef HAVE_XPETRA_TPETRA
00355       if (lib == UseTpetra)
00356         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
00357 #endif
00358 
00359 #ifdef HAVE_XPETRA_EPETRA
00360 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00361       if (lib == UseEpetra)
00362         return rcp( new EpetraMapT<int>(numGlobalElements, elementList, indexBase, comm, node) );
00363 #endif
00364 #endif
00365 
00366       XPETRA_FACTORY_END;
00367     }
00368 
00370     static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >& map, LocalOrdinal numDofPerNode) {
00371       XPETRA_MONITOR("MapFactory::Build");
00372 
00373       LocalOrdinal N = map->getNodeNumElements();
00374       Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
00375       Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
00376       for (LocalOrdinal i = 0; i < N; i++)
00377         for (LocalOrdinal j = 0; j < numDofPerNode; j++)
00378           newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
00379 
00380 #ifdef HAVE_XPETRA_TPETRA
00381       if (map->lib() == UseTpetra)
00382         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
00383 #endif
00384 
00385 #ifdef HAVE_XPETRA_EPETRA
00386 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00387       if (map->lib() == UseEpetra)
00388         return rcp( new EpetraMapT<int>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
00389 #endif
00390 #endif
00391 
00392       XPETRA_FACTORY_END;
00393     }
00394 
00395     static Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal, Node> >
00396     createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
00397        XPETRA_MONITOR("MapFactory::Build");
00398 
00399 #ifdef HAVE_XPETRA_TPETRA
00400       if (lib == UseTpetra)
00401         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
00402 #endif
00403 
00404 #ifdef HAVE_XPETRA_EPETRA
00405 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00406       if (lib == UseEpetra)
00407         return MapFactory<int, GlobalOrdinal>::createLocalMapWithNode (lib, numElements, comm,
00408                                                              defaultArgNode());
00409 #endif
00410 #endif
00411 
00412       XPETRA_FACTORY_END;
00413     }
00414 
00415     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00416     createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
00417        XPETRA_MONITOR("MapFactory::Build");
00418 
00419 #ifdef HAVE_XPETRA_TPETRA
00420       if (lib == UseTpetra)
00421         return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm, node)));
00422 #endif
00423 
00424 #ifdef HAVE_XPETRA_EPETRA
00425 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00426       if (lib == UseEpetra)
00427         {
00428 
00429           Teuchos::RCP< EpetraMapT<int> > map;
00430           map = Teuchos::rcp( new EpetraMapT<int>((Xpetra::global_size_t)numElements, // num elements, global and local
00431                                             0,                                   // index base is zero
00432                                             comm, LocallyReplicated, node));
00433           return map.getConst();
00434         }
00435 #endif
00436 #endif
00437 
00438       XPETRA_FACTORY_END;
00439     }
00440 
00441     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00442     createUniformContigMapWithNode (UnderlyingLib lib, global_size_t numElements,
00443                                     const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
00444                                     const Teuchos::RCP<Node>& node)
00445     {
00446        XPETRA_MONITOR("MapFactory::Build");
00447 
00448 #ifdef HAVE_XPETRA_TPETRA
00449       if (lib == UseTpetra)
00450         return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm, node)));
00451 #endif
00452 
00453 #ifdef HAVE_XPETRA_EPETRA
00454 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00455       if (lib == UseEpetra)
00456         {
00457 
00458           Teuchos::RCP< EpetraMapT<int> > map;
00459           map = Teuchos::rcp( new EpetraMapT<int>(numElements,        // num elements, global and local
00460                                             0,                  //index base is zero
00461                                             comm, GloballyDistributed, node));
00462           return map.getConst();
00463         }
00464 #endif
00465 #endif
00466 
00467       XPETRA_FACTORY_END;
00468     }
00469 
00470     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
00471     createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
00472        XPETRA_MONITOR("MapFactory::Build");
00473 
00474 #ifdef HAVE_XPETRA_TPETRA
00475       if (lib == UseTpetra)
00476         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
00477 #endif
00478 
00479 #ifdef HAVE_XPETRA_EPETRA
00480 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00481       if (lib == UseEpetra)
00482         return MapFactory<int, GlobalOrdinal, Node>::createUniformContigMapWithNode (lib, numElements, comm,
00483                                                                            defaultArgNode());
00484 #endif
00485 #endif
00486 
00487       XPETRA_FACTORY_END;
00488     }
00489 
00490     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00491     createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
00492        XPETRA_MONITOR("MapFactory::Build");
00493 
00494 #ifdef HAVE_XPETRA_TPETRA
00495       if (lib == UseTpetra)
00496         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMap<int,GlobalOrdinal>(numElements, localNumElements, comm)));
00497 #endif
00498 
00499 #ifdef HAVE_XPETRA_EPETRA
00500 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00501       if (lib == UseEpetra)
00502         return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm, defaultArgNode() );
00503 #endif
00504 #endif
00505 
00506       XPETRA_FACTORY_END;
00507     }
00508 
00509     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00510     createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements,
00511                             const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
00512        XPETRA_MONITOR("MapFactory::Build");
00513 
00514 #ifdef HAVE_XPETRA_TPETRA
00515       if (lib == UseTpetra)
00516         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
00517 #endif
00518 
00519 #ifdef HAVE_XPETRA_EPETRA
00520 #ifndef XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES
00521       if (lib == UseEpetra)
00522         {
00523 
00524           Teuchos::RCP< EpetraMapT<int> > map;
00525           map = Teuchos::rcp( new EpetraMapT<int>(numElements,localNumElements,
00526                                             0,  // index base is zero
00527                                             comm, node) );
00528           return map.getConst();
00529         }
00530 #endif
00531 #endif
00532 
00533       XPETRA_FACTORY_END;
00534     }
00535 
00536   };
00537 
00538 #ifdef HAVE_TEUCHOS_LONG_LONG_INT
00539   template <>
00540   class MapFactory<int, long long> {
00541 
00542     typedef int LocalOrdinal;
00543     typedef long long GlobalOrdinal;
00544     typedef Map<int, GlobalOrdinal>::node_type Node;
00545 
00546   private:
00548     MapFactory() {}
00549 
00550   public:
00551 
00552     static Teuchos::RCP<Node> defaultArgNode() {
00553       // Workaround function for a deferred visual studio bug
00554       //
00555       // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
00556       //
00557       // Use this function for default arguments rather than calling
00558       // what is the return value below.  Also helps in reducing
00559       // duplication in various constructors.
00560       return KokkosClassic::Details::getNode<Node>();
00561     }
00562 
00563     static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00564     Build (UnderlyingLib lib,
00565            global_size_t numGlobalElements,
00566            int indexBase,
00567            const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
00568            LocalGlobal lg=GloballyDistributed,
00569            const Teuchos::RCP<Node>& node = defaultArgNode ()) {
00570       XPETRA_MONITOR("MapFactory::Build");
00571 
00572 #ifdef HAVE_XPETRA_TPETRA
00573       if (lib == UseTpetra)
00574         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
00575 #endif
00576 
00577 #ifdef HAVE_XPETRA_EPETRA
00578 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00579       if (lib == UseEpetra)
00580         return rcp( new EpetraMapT<long long>(numGlobalElements, indexBase, comm, lg, node) );
00581 #endif
00582 #endif
00583 
00584       XPETRA_FACTORY_END;
00585     }
00586 
00587     static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
00588     Build (UnderlyingLib lib,
00589            global_size_t numGlobalElements,
00590            size_t numLocalElements,
00591            int indexBase,
00592            const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
00593            const Teuchos::RCP<Node>& node = defaultArgNode())
00594     {
00595       XPETRA_MONITOR("MapFactory::Build");
00596 
00597 #ifdef HAVE_XPETRA_TPETRA
00598       if (lib == UseTpetra)
00599         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
00600 #endif
00601 
00602 #ifdef HAVE_XPETRA_EPETRA
00603 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00604       if (lib == UseEpetra)
00605         return rcp( new EpetraMapT<long long>(numGlobalElements, numLocalElements, indexBase, comm, node) );
00606 #endif
00607 #endif
00608 
00609       XPETRA_FACTORY_END;
00610     }
00611 
00612     static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(UnderlyingLib lib, global_size_t numGlobalElements, const Teuchos::ArrayView<const GlobalOrdinal> &elementList, int indexBase, const Teuchos::RCP<const Teuchos::Comm<int> > &comm, const Teuchos::RCP<Node>& node = defaultArgNode ()) {
00613       XPETRA_MONITOR("MapFactory::Build");
00614 
00615 #ifdef HAVE_XPETRA_TPETRA
00616       if (lib == UseTpetra)
00617         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
00618 #endif
00619 
00620 #ifdef HAVE_XPETRA_EPETRA
00621 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00622       if (lib == UseEpetra)
00623         return rcp( new EpetraMapT<long long>(numGlobalElements, elementList, indexBase, comm, node) );
00624 #endif
00625 #endif
00626 
00627       XPETRA_FACTORY_END;
00628     }
00629 
00631     static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >& map, LocalOrdinal numDofPerNode) {
00632       XPETRA_MONITOR("MapFactory::Build");
00633 
00634       LocalOrdinal N = map->getNodeNumElements();
00635       Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
00636       Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
00637       for (LocalOrdinal i = 0; i < N; i++)
00638         for (LocalOrdinal j = 0; j < numDofPerNode; j++)
00639           newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
00640 
00641 #ifdef HAVE_XPETRA_TPETRA
00642       if (map->lib() == UseTpetra)
00643         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
00644 #endif
00645 
00646 #ifdef HAVE_XPETRA_EPETRA
00647 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00648       if (map->lib() == UseEpetra)
00649         return rcp( new EpetraMapT<long long>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
00650 #endif
00651 #endif
00652 
00653       XPETRA_FACTORY_END;
00654     }
00655 
00656     static Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal, Node> >
00657     createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
00658        XPETRA_MONITOR("MapFactory::Build");
00659 
00660 #ifdef HAVE_XPETRA_TPETRA
00661       if (lib == UseTpetra)
00662         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
00663 #endif
00664 
00665 #ifdef HAVE_XPETRA_EPETRA
00666 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00667       if (lib == UseEpetra)
00668         return MapFactory<int, GlobalOrdinal>::createLocalMapWithNode (lib, numElements, comm,
00669                                                              defaultArgNode());
00670 #endif
00671 #endif
00672 
00673       XPETRA_FACTORY_END;
00674     }
00675 
00676     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00677     createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
00678        XPETRA_MONITOR("MapFactory::Build");
00679 
00680 #ifdef HAVE_XPETRA_TPETRA
00681       if (lib == UseTpetra)
00682         return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm, node)));
00683 #endif
00684 
00685 #ifdef HAVE_XPETRA_EPETRA
00686 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00687       if (lib == UseEpetra)
00688         {
00689 
00690           Teuchos::RCP< EpetraMapT<long long> > map;
00691           map = Teuchos::rcp( new EpetraMapT<long long>((Xpetra::global_size_t)numElements, // num elements, global and local
00692                                             0,                                   // index base is zero
00693                                             comm, LocallyReplicated, node));
00694           return map.getConst();
00695         }
00696 #endif
00697 #endif
00698 
00699       XPETRA_FACTORY_END;
00700     }
00701 
00702     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00703     createUniformContigMapWithNode (UnderlyingLib lib, global_size_t numElements,
00704                                     const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
00705                                     const Teuchos::RCP<Node>& node)
00706     {
00707        XPETRA_MONITOR("MapFactory::Build");
00708 
00709 #ifdef HAVE_XPETRA_TPETRA
00710       if (lib == UseTpetra)
00711         return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm, node)));
00712 #endif
00713 
00714 #ifdef HAVE_XPETRA_EPETRA
00715 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00716       if (lib == UseEpetra)
00717         {
00718 
00719           Teuchos::RCP< EpetraMapT<long long> > map;
00720           map = Teuchos::rcp( new EpetraMapT<long long>(numElements,        // num elements, global and local
00721                                             0,                  //index base is zero
00722                                             comm, GloballyDistributed, node));
00723           return map.getConst();
00724         }
00725 #endif
00726 #endif
00727 
00728       XPETRA_FACTORY_END;
00729     }
00730 
00731     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
00732     createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
00733        XPETRA_MONITOR("MapFactory::Build");
00734 
00735 #ifdef HAVE_XPETRA_TPETRA
00736       if (lib == UseTpetra)
00737         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
00738 #endif
00739 
00740 #ifdef HAVE_XPETRA_EPETRA
00741 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00742       if (lib == UseEpetra)
00743         return MapFactory<int, GlobalOrdinal, Node>::createUniformContigMapWithNode (lib, numElements, comm,
00744                                                                            defaultArgNode());
00745 #endif
00746 #endif
00747 
00748       XPETRA_FACTORY_END;
00749     }
00750 
00751     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00752     createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
00753        XPETRA_MONITOR("MapFactory::Build");
00754 
00755 #ifdef HAVE_XPETRA_TPETRA
00756       if (lib == UseTpetra)
00757         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMap<int,GlobalOrdinal>(numElements, localNumElements, comm)));
00758 #endif
00759 
00760 #ifdef HAVE_XPETRA_EPETRA
00761 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00762       if (lib == UseEpetra)
00763         return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm, defaultArgNode() );
00764 #endif
00765 #endif
00766 
00767       XPETRA_FACTORY_END;
00768     }
00769 
00770     static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node>  >
00771     createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements,
00772                             const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
00773        XPETRA_MONITOR("MapFactory::Build");
00774 
00775 #ifdef HAVE_XPETRA_TPETRA
00776       if (lib == UseTpetra)
00777         return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
00778 #endif
00779 
00780 #ifdef HAVE_XPETRA_EPETRA
00781 #ifndef XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES
00782       if (lib == UseEpetra)
00783         {
00784 
00785           Teuchos::RCP< EpetraMapT<long long> > map;
00786           map = Teuchos::rcp( new EpetraMapT<long long>(numElements,localNumElements,
00787                                             0,  // index base is zero
00788                                             comm, node) );
00789           return map.getConst();
00790         }
00791 #endif
00792 #endif
00793 
00794       XPETRA_FACTORY_END;
00795     }
00796 
00797   };
00798 #endif // HAVE_TEUCHOS_LONG_LONG_INT
00799 
00800 }
00801 
00802 #define XPETRA_MAPFACTORY_SHORT
00803 #endif
00804 //TODO: removed unused methods