Xpetra_StridedTpetraMap.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 // WARNING: This code is experimental. Backwards compatibility should not be expected.
00048 
00049 #ifndef XPETRA_STRIDEDTPETRAMAP_HPP
00050 #define XPETRA_STRIDEDTPETRAMAP_HPP
00051 
00052 #include "Xpetra_TpetraConfigDefs.hpp"
00053 
00054 #include <Tpetra_Map_decl.hpp>
00055 
00056 #include "Xpetra_StridedMap.hpp"
00057 #include "Xpetra_TpetraMap.hpp"
00058 //#include "Xpetra_Utils.hpp"
00059 
00060 
00061 namespace Xpetra {
00062 
00063   template <class LocalOrdinal, class GlobalOrdinal = LocalOrdinal, class Node = Kokkos::DefaultNode::DefaultNodeType>
00064   class StridedTpetraMap
00065     : public virtual TpetraMap<LocalOrdinal,GlobalOrdinal,Node>, public virtual StridedMap<LocalOrdinal,GlobalOrdinal,Node> {
00066 
00067   public:
00068 
00070 
00071 
00091     StridedTpetraMap(global_size_t numGlobalElements, GlobalOrdinal indexBase, std::vector<size_t>& stridingInfo, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, LocalOrdinal stridedBlockId=-1, GlobalOrdinal offset = 0,  LocalGlobal lg=GloballyDistributed, const Teuchos::RCP< Node > &node=Kokkos::DefaultNode::getDefaultNode())
00092     : Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(numGlobalElements, indexBase, comm, lg, node), Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node>(numGlobalElements, indexBase, stridingInfo, comm, stridedBlockId, offset)
00093     { 
00094       typedef Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node> StridedMapClass;
00095       // check input data and reorganize map
00096       
00097       global_size_t numGlobalNodes = Teuchos::OrdinalTraits<global_size_t>::invalid();
00098       if(numGlobalElements != Teuchos::OrdinalTraits<global_size_t>::invalid())
00099         numGlobalNodes = numGlobalElements / StridedMapClass::getFixedBlockSize();  // number of nodes (over all processors)
00100 
00101       // build an equally distributed node map
00102       RCP<Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > nodeMap = Teuchos::rcp(new Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node >(numGlobalNodes, indexBase, comm, toTpetra(lg), node));
00103       
00104       // translate local node ids to local dofs
00105       size_t nStridedOffset = 0;
00106       size_t nDofsPerNode = StridedMapClass::getFixedBlockSize(); // dofs per node for local striding block
00107       if(stridedBlockId > -1) {
00108         // determine nStridedOffset
00109         for(int j=0; j<stridedBlockId; j++) {
00110           nStridedOffset += stridingInfo[j];
00111         }
00112         nDofsPerNode = stridingInfo[stridedBlockId];
00113 
00114         numGlobalElements = nodeMap->getGlobalNumElements()*Teuchos::as<global_size_t>(nDofsPerNode);
00115       }
00116       std::vector<GlobalOrdinal> dofgids;
00117       for(LocalOrdinal i = 0; i<Teuchos::as<LocalOrdinal>(nodeMap->getNodeNumElements()); i++) {
00118         GlobalOrdinal gid = nodeMap->getGlobalElement(i);
00119         for(size_t dof = 0; dof < nDofsPerNode; ++dof) {
00120           // dofs are calculated by
00121           // global offset + node_GID * full size of strided map + striding offset of current striding block + dof id of current striding block
00122           dofgids.push_back(StridedMapClass::offset_ + gid*Teuchos::as<GlobalOrdinal>(StridedMapClass::getFixedBlockSize()) + Teuchos::as<GlobalOrdinal>(nStridedOffset + dof));
00123         }
00124       }
00125       
00126       const Teuchos::ArrayView<const GlobalOrdinal> dofgidsview = Teuchos::ArrayView<const GlobalOrdinal>(dofgids);
00127       TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::map_ = Teuchos::rcp(new Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node >(numGlobalElements, dofgidsview, indexBase, comm, node));
00128       
00129       //TEUCHOS_TEST_FOR_EXCEPTION(Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::map_->getNodeNumElements() % nDofsPerNode != 0, Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00130       if(stridedBlockId == -1) {
00131         TEUCHOS_TEST_FOR_EXCEPTION(getNodeNumElements() != Teuchos::as<size_t>(nodeMap->getNodeNumElements()*nDofsPerNode), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00132         TEUCHOS_TEST_FOR_EXCEPTION(getGlobalNumElements() != Teuchos::as<size_t>(nodeMap->getGlobalNumElements()*nDofsPerNode), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00133       } else {
00134         TEUCHOS_TEST_FOR_EXCEPTION(stridingInfo.size() < Teuchos::as<size_t>(stridedBlockId), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: stridedBlockId > stridingInfo.size()");
00135         int nDofsInStridedBlock = stridingInfo[stridedBlockId];
00136         TEUCHOS_TEST_FOR_EXCEPTION(getNodeNumElements() != Teuchos::as<size_t>(nodeMap->getNodeNumElements()*nDofsInStridedBlock), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00137         TEUCHOS_TEST_FOR_EXCEPTION(getGlobalNumElements() != Teuchos::as<size_t>(nodeMap->getGlobalNumElements()*nDofsInStridedBlock), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00138       }  
00139       
00140       TEUCHOS_TEST_FOR_EXCEPTION(CheckConsistency() == false, Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: CheckConsistency() == false"); 
00141     }
00142 
00144 
00164     StridedTpetraMap(global_size_t numGlobalElements, size_t numLocalElements, GlobalOrdinal indexBase, std::vector<size_t>& stridingInfo, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, LocalOrdinal stridedBlockId=-1, GlobalOrdinal offset = 0, const Teuchos::RCP< Node > &node=Kokkos::DefaultNode::getDefaultNode())
00165     : Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(numGlobalElements, numLocalElements, indexBase, comm, node), Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node>(numGlobalElements, numLocalElements, indexBase, stridingInfo, comm, stridedBlockId, offset)
00166     { 
00167       typedef Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node> StridedMapClass;
00168       // check input data and reorganize map
00169 
00170       global_size_t numGlobalNodes = Teuchos::OrdinalTraits<global_size_t>::invalid();
00171       if(numGlobalElements != Teuchos::OrdinalTraits<global_size_t>::invalid())
00172         numGlobalNodes = numGlobalElements / StridedMapClass::getFixedBlockSize();  // number of nodes (over all processors)
00173       global_size_t numLocalNodes  = numLocalElements / StridedMapClass::getFixedBlockSize(); // number of nodes (on one processor)
00174       
00175       // build an equally distributed node map
00176       RCP<Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > nodeMap = Teuchos::rcp(new Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node >(numGlobalNodes, numLocalNodes, indexBase, comm, node));
00177       
00178       // translate local node ids to local dofs
00179       size_t nStridedOffset = 0;
00180       size_t nDofsPerNode = StridedMapClass::getFixedBlockSize(); // dofs per node for local striding block
00181       if(stridedBlockId > -1) {
00182         // determine nStridedOffset
00183         for(int j=0; j<stridedBlockId; j++) {
00184           nStridedOffset += stridingInfo[j];
00185         }
00186         nDofsPerNode = stridingInfo[stridedBlockId];
00187 
00188         numGlobalElements = nodeMap->getGlobalNumElements()*Teuchos::as<global_size_t>(nDofsPerNode);
00189       }
00190       std::vector<GlobalOrdinal> dofgids;
00191       for(LocalOrdinal i = 0; i<Teuchos::as<LocalOrdinal>(nodeMap->getNodeNumElements()); i++) {
00192         GlobalOrdinal gid = nodeMap->getGlobalElement(i);
00193         for(size_t dof = 0; dof < nDofsPerNode; ++dof) {
00194           // dofs are calculated by
00195           // global offset + node_GID * full size of strided map + striding offset of current striding block + dof id of current striding block
00196           dofgids.push_back(StridedMapClass::offset_ + gid*Teuchos::as<GlobalOrdinal>(StridedMapClass::getFixedBlockSize()) + Teuchos::as<GlobalOrdinal>(nStridedOffset + dof));
00197         }
00198       }
00199       
00200       const Teuchos::ArrayView<const GlobalOrdinal> dofgidsview = Teuchos::ArrayView<const GlobalOrdinal>(dofgids);
00201       TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::map_ = Teuchos::rcp(new Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node >(numGlobalElements, dofgidsview, indexBase, comm, node));
00202       
00203       //TEUCHOS_TEST_FOR_EXCEPTION(Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::map_->getNodeNumElements() % nDofsPerNode != 0, Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00204       if(stridedBlockId == -1) {
00205         TEUCHOS_TEST_FOR_EXCEPTION(getNodeNumElements() != Teuchos::as<size_t>(nodeMap->getNodeNumElements()*nDofsPerNode), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00206         TEUCHOS_TEST_FOR_EXCEPTION(getGlobalNumElements() != Teuchos::as<size_t>(nodeMap->getGlobalNumElements()*nDofsPerNode), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00207       } else {
00208         TEUCHOS_TEST_FOR_EXCEPTION(stridingInfo.size() < Teuchos::as<size_t>(stridedBlockId), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: stridedBlockId > stridingInfo.size()");
00209         int nDofsInStridedBlock = stridingInfo[stridedBlockId];
00210         TEUCHOS_TEST_FOR_EXCEPTION(getNodeNumElements() != Teuchos::as<size_t>(nodeMap->getNodeNumElements()*nDofsInStridedBlock), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00211         TEUCHOS_TEST_FOR_EXCEPTION(getGlobalNumElements() != Teuchos::as<size_t>(nodeMap->getGlobalNumElements()*nDofsInStridedBlock), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00212       }  
00213       
00214       TEUCHOS_TEST_FOR_EXCEPTION(CheckConsistency() == false, Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: CheckConsistency() == false"); 
00215 
00216     }
00217 
00228     StridedTpetraMap(global_size_t numGlobalElements, const Teuchos::ArrayView< const GlobalOrdinal > &elementList, GlobalOrdinal indexBase, std::vector<size_t>& stridingInfo, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, LocalOrdinal stridedBlockId=-1, const Teuchos::RCP< Node > &node=Kokkos::DefaultNode::getDefaultNode())
00229     : Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(numGlobalElements, elementList, indexBase, comm, node), Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node>(numGlobalElements, elementList, indexBase, stridingInfo, comm, stridedBlockId)
00230     {
00231       typedef Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node> StridedMapClass;
00232 
00233         if(stridedBlockId != -1) {
00234           TEUCHOS_TEST_FOR_EXCEPTION(stridingInfo.size() < Teuchos::as<size_t>(stridedBlockId), Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: stridedBlockId > stridingInfo.size()");
00235         }
00236 
00237         // create TpetraMap using the dofs from ElementList
00238         TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::map_ = Teuchos::rcp(new Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node >(numGlobalElements, elementList, indexBase, comm, node));
00239 
00240         // set parameters for striding information
00241         TEUCHOS_TEST_FOR_EXCEPTION(CheckConsistency() == false, Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: CheckConsistency() == false");
00242     }
00243 
00245     ~StridedTpetraMap() { }
00246 
00248 
00250 
00251 
00253     global_size_t getGlobalNumElements() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getGlobalNumElements(); }
00254 
00256     size_t getNodeNumElements() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getNodeNumElements(); }
00257 
00259     GlobalOrdinal getIndexBase() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getIndexBase(); }
00260 
00262     LocalOrdinal getMinLocalIndex() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getMinLocalIndex(); }
00263 
00265     LocalOrdinal getMaxLocalIndex() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getMaxLocalIndex(); }
00266 
00268     GlobalOrdinal getMinGlobalIndex() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getMinGlobalIndex(); }
00269 
00271     GlobalOrdinal getMaxGlobalIndex() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getMaxGlobalIndex(); }
00272 
00274     GlobalOrdinal getMinAllGlobalIndex() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getMinAllGlobalIndex(); }
00275 
00277     GlobalOrdinal getMaxAllGlobalIndex() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getMaxAllGlobalIndex(); }
00278 
00280     LocalOrdinal getLocalElement(GlobalOrdinal globalIndex) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getLocalElement(globalIndex); }
00281 
00283     GlobalOrdinal getGlobalElement(LocalOrdinal localIndex) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getGlobalElement(localIndex); }
00284 
00286     LookupStatus getRemoteIndexList(const Teuchos::ArrayView< const GlobalOrdinal > &GIDList, const Teuchos::ArrayView< int > &nodeIDList, const Teuchos::ArrayView< LocalOrdinal > &LIDList) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getRemoteIndexList(GIDList, nodeIDList, LIDList); }
00287 
00289     LookupStatus getRemoteIndexList(const Teuchos::ArrayView< const GlobalOrdinal > &GIDList, const Teuchos::ArrayView< int > &nodeIDList) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getRemoteIndexList(GIDList, nodeIDList); }
00290 
00292     Teuchos::ArrayView< const GlobalOrdinal > getNodeElementList() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getNodeElementList(); }
00293 
00295     bool isNodeLocalElement(LocalOrdinal localIndex) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::isNodeLocalElement(localIndex); }
00296 
00298     bool isNodeGlobalElement(GlobalOrdinal globalIndex) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::isNodeGlobalElement(globalIndex); }
00299 
00301     bool isContiguous() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::isContiguous(); }
00302 
00304     bool isDistributed() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::isDistributed(); }
00305 
00307 
00309 
00310 
00312     bool isCompatible(const Map< LocalOrdinal, GlobalOrdinal, Node > &map) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::isCompatible(map); }
00313 
00315     bool isSameAs(const Map< LocalOrdinal, GlobalOrdinal, Node > &map) const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::isSameAs(map); }
00316 
00318 
00320 
00321 
00323     const Teuchos::RCP< const Teuchos::Comm< int > >  getComm() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getComm(); }
00324 
00326     const Teuchos::RCP< Node >  getNode() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::getNode(); }
00327 
00329 
00331 
00332 
00334     std::string description() const { return TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::description(); }
00335 
00337     void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const { TpetraMap<LocalOrdinal,GlobalOrdinal,Node>::describe(out, verbLevel); }
00338 
00340 
00342 
00343 
00345     StridedTpetraMap(const Teuchos::RCP<const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node > > &map, std::vector<size_t>& stridingInfo, LocalOrdinal stridedBlockId=-1, GlobalOrdinal offset = 0) 
00346       : Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(map), Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node>(stridingInfo, stridedBlockId, offset) {
00347       typedef Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node> StridedMapClass;
00348       //size_t nDofsPerNode = Teuchos::as<size_t>(StridedMapClass::getFixedBlockSize());
00349       //TEUCHOS_TEST_FOR_EXCEPTION((Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node >)::map_->getNodeNumElements() % nDofsPerNode != 0, Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: wrong distribution of dofs among processors.");
00350       TEUCHOS_TEST_FOR_EXCEPTION(CheckConsistency() == false, Exceptions::RuntimeError, "StridedTpetraMap::StridedTpetraMap: CheckConsistency() == false");
00351     }
00352 
00354     UnderlyingLib lib() const { return Xpetra::UseTpetra; }
00355     
00356     /*//! Get the underlying Tpetra map
00357     const RCP< const Tpetra::Map< LocalOrdinal, GlobalOrdinal, Node > > & getTpetra_Map() const { return map_; }*/
00358 
00360 
00361   private:
00362     bool CheckConsistency() {
00363       typedef Xpetra::StridedMap<LocalOrdinal,GlobalOrdinal,Node> StridedMapClass;
00364       
00365       if(StridedMapClass::getStridedBlockId() == -1) {
00366 
00367         if(getNodeNumElements() % StridedMapClass::getFixedBlockSize() != 0) return false;
00368         if(getGlobalNumElements() % StridedMapClass::getFixedBlockSize() != 0) return false;
00369       }
00370       else {
00371         Teuchos::ArrayView< const GlobalOrdinal > dofGids = getNodeElementList();
00372         //std::sort(dofGids.begin(),dofGids.end());
00373 
00374         // determine nStridedOffset
00375         size_t nStridedOffset = 0;
00376         for(int j=0; j<StridedMapClass::stridedBlockId_; j++) {
00377           nStridedOffset += StridedMapClass::stridingInfo_[j];
00378         }
00379         //size_t nDofsPerNode = stridingInfo_[stridedBlockId_];
00380 
00381         const GlobalOrdinal goStridedOffset = Teuchos::as<GlobalOrdinal>(nStridedOffset);
00382         const GlobalOrdinal goZeroOffset = (dofGids[0] - nStridedOffset - StridedMapClass::offset_) / Teuchos::as<GlobalOrdinal>(StridedMapClass::getFixedBlockSize());
00383 
00384         GlobalOrdinal cnt = 0;
00385         for(size_t i = 0; i<Teuchos::as<size_t>(dofGids.size())/StridedMapClass::stridingInfo_[StridedMapClass::stridedBlockId_]; i+=StridedMapClass::stridingInfo_[StridedMapClass::stridedBlockId_]) {
00386 
00387           for(size_t j=0; j<StridedMapClass::stridingInfo_[StridedMapClass::stridedBlockId_]; j++) {
00388             const GlobalOrdinal gid = dofGids[i+j];
00389             if((gid - Teuchos::as<GlobalOrdinal>(j) - goStridedOffset - StridedMapClass::offset_) / Teuchos::as<GlobalOrdinal>(StridedMapClass::getFixedBlockSize()) - goZeroOffset - cnt != 0) {
00390               //std::cout << "gid: " << gid << " GID: " <<  (gid - Teuchos::as<GlobalOrdinal>(j) - goStridedOffset) / Teuchos::as<GlobalOrdinal>(getFixedBlockSize()) - goZeroOffset - cnt << std::endl;
00391               return false;
00392             }
00393           }
00394           cnt++;
00395         }
00396       }
00397       
00398       return true;
00399     }
00400 
00401   }; // StridedTpetraMap class
00402 
00403  
00404 } // Xpetra namespace
00405 
00406 #define XPETRA_STRIDEDTPETRAMAP_SHORT
00407 #endif // XPETRA_STRIDEDTPETRAMAP_HPP