Zoltan2
Zoltan2_OrderingSolution.hpp
Go to the documentation of this file.
00001 // @HEADER
00002 //
00003 // ***********************************************************************
00004 //
00005 //   Zoltan2: A package of combinatorial algorithms for scientific computing
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 Karen Devine      (kddevin@sandia.gov)
00039 //                    Erik Boman        (egboman@sandia.gov)
00040 //                    Siva Rajamanickam (srajama@sandia.gov)
00041 //
00042 // ***********************************************************************
00043 //
00044 // @HEADER
00045 
00050 #ifndef _ZOLTAN2_ORDERINGSOLUTION_HPP_
00051 #define _ZOLTAN2_ORDERINGSOLUTION_HPP_
00052 
00053 #include <Zoltan2_Standards.hpp>
00054 #include <Zoltan2_Solution.hpp>
00055 
00056 namespace Zoltan2 {
00057 
00070 template <typename gid_t, typename lno_t>
00071   class OrderingSolution : public Solution
00072 {
00073 public:
00074 
00077   OrderingSolution(
00078     size_t perm_size // This should be equal to nlids
00079   )
00080   {
00081     HELLO;
00082     perm_size_ = perm_size;
00083     gids_   = ArrayRCP<gid_t>(perm_size_);
00084     perm_  = ArrayRCP<lno_t>(perm_size_);
00085     invperm_  = ArrayRCP<lno_t>(perm_size_);
00086     havePerm_ = false;
00087     haveInverse_ = false;
00088   }
00089 
00092   bool havePerm()
00093   {
00094     return havePerm_; 
00095   }
00096 
00099   void setHavePerm(bool status)
00100   {
00101     havePerm_ = status; 
00102   }
00103 
00104 
00107   bool haveInverse()
00108   {
00109     return haveInverse_; 
00110   }
00111 
00114   void setHaveInverse(bool status)
00115   {
00116     haveInverse_ = status; 
00117   }
00118 
00121   void computePerm()
00122   {
00123     if (haveInverse_) {
00124       for(size_t i=0; i<perm_size_; i++) {
00125         perm_[invperm_[i]] = i;
00126       }
00127       havePerm_ = true;
00128     }
00129     else {
00130       // TODO: throw exception
00131       std::cerr << "No inverse!" << std::endl;
00132     }
00133   }
00134 
00137   void computeInverse()
00138   {
00139     if (havePerm_) {
00140       for(size_t i=0; i<perm_size_; i++) {
00141         invperm_[perm_[i]] = i;
00142       }
00143       havePerm_ = true;
00144     }
00145     else {
00146       // TODO: throw exception
00147       std::cerr << "No perm!" << std::endl;
00148     }
00149   }
00150 
00151 
00153   // Accessor functions, allowing algorithms to get ptrs to solution memory.
00154   // Algorithms can then load the memory.
00155   // Non-RCP versions are provided for applications to use.
00156 
00159   inline size_t getPermutationSize() {return perm_size_;}
00160 
00163   inline ArrayRCP<gid_t>  &getGidsRCP()  {return gids_;}
00164 
00170   inline ArrayRCP<lno_t> &getPermutationRCP(bool inverse=false) 
00171   {
00172     if (inverse)
00173       return invperm_;
00174     else
00175       return perm_;
00176   }
00177 
00180   inline ArrayRCP<gid_t>  &getGidsRCPConst()  const
00181   {
00182     return const_cast<ArrayRCP<gid_t>& > (gids_);
00183   }
00184 
00190   inline ArrayRCP<lno_t> &getPermutationRCPConst(bool inverse=false) const
00191   {
00192     if (inverse)
00193       return const_cast<ArrayRCP<lno_t>& > (invperm_);
00194     else
00195       return const_cast<ArrayRCP<lno_t>& > (perm_);
00196   }
00197 
00200   inline gid_t  *getGids()
00201   {
00202     return gids_.getRawPtr();
00203   }
00204 
00210   inline lno_t *getPermutation(bool inverse = false)
00211   {
00212     if (inverse)
00213       return invperm_.getRawPtr();
00214     else
00215       return perm_.getRawPtr();
00216   }
00217 
00218 protected:
00219   // Ordering solution consists of permutation vector(s).
00220   // Either perm or invperm should be computed by the algorithm.
00221   size_t perm_size_;
00222   ArrayRCP<gid_t>  gids_; // TODO: Remove?
00223   // For now, assume permutations are local. Revisit later (e.g., for Scotch)
00224   bool havePerm_;    // has perm_ been computed yet?
00225   bool haveInverse_; // has invperm_ been computed yet?
00226   ArrayRCP<lno_t> perm_;    // zero-based local permutation
00227   ArrayRCP<lno_t> invperm_; // inverse of permutation above
00228 };
00229 
00230 }
00231 
00232 #endif