MueLu  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MueLu_MatlabUtils_decl.hpp
Go to the documentation of this file.
1 // @HEADER
2 //
3 // ***********************************************************************
4 //
5 // MueLu: A package for multigrid based preconditioning
6 // Copyright 2012 Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact
39 // Jonathan Hu (jhu@sandia.gov)
40 // Andrey Prokopenko (aprokop@sandia.gov)
41 // Ray Tuminaro (rstumin@sandia.gov)
42 //
43 // ***********************************************************************
44 //
45 // @HEADER
46 
47 #ifndef MUELU_MATLABUTILS_DECL_HPP
48 #define MUELU_MATLABUTILS_DECL_HPP
49 
50 #include "MueLu_ConfigDefs.hpp"
51 
52 #if !defined(HAVE_MUELU_MATLAB) || !defined(HAVE_MUELU_EPETRA) || !defined(HAVE_MUELU_TPETRA)
53 #error "Muemex requires MATLAB, Epetra and Tpetra."
54 #else
55 
56 #include "mex.h"
57 #include <string>
58 #include <complex>
59 #include <stdexcept>
61 #include <Teuchos_RCP.hpp>
62 #include <Teuchos_DefaultComm.hpp>
63 #include "MueLu_Factory.hpp"
64 #include "MueLu_Hierarchy_decl.hpp"
67 #include "MueLu_Utilities_decl.hpp"
68 #include "MueLu_Graph_decl.hpp"
69 #include "Epetra_MultiVector.h"
70 #include "Epetra_CrsMatrix.h"
71 #include "Tpetra_CrsMatrix_decl.hpp"
73 #include "Xpetra_MapFactory.hpp"
74 #include "Xpetra_CrsGraph.hpp"
75 #include "Xpetra_VectorFactory.hpp"
76 #include <Tpetra_Core.hpp>
77 
78 #include "Kokkos_DynRankView.hpp"
79 
80 
81 namespace MueLu
82 {
83 
85 {
86  INT,
106 #ifdef HAVE_MUELU_INTREPID2
107 , FIELDCONTAINER_ORDINAL
108 #endif
109 };
110 
111 typedef Kokkos::Compat::KokkosDeviceWrapperNode<Kokkos::Serial, Kokkos::HostSpace> mm_node_t;
112 typedef int mm_LocalOrd; //these are used for LocalOrdinal and GlobalOrdinal of all xpetra/tpetra templated types
113 typedef int mm_GlobalOrd;
114 typedef std::complex<double> complex_t;
115 typedef Tpetra::Map<> muemex_map_type;
116 typedef Tpetra::CrsMatrix<double, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_CrsMatrix_double;
117 typedef Tpetra::CrsMatrix<complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_CrsMatrix_complex;
118 typedef Tpetra::MultiVector<double, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_MultiVector_double;
119 typedef Tpetra::MultiVector<complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_MultiVector_complex;
132 
133 #ifdef HAVE_MUELU_INTREPID2
134  typedef Kokkos::DynRankView<mm_LocalOrd,typename mm_node_t::device_type> FieldContainer_ordinal;
135 #endif
136 
138 {
139  public:
140  MuemexArg(MuemexType dataType) {type = dataType;}
142 };
143 
144 template<typename T>
145 MuemexType getMuemexType(const T & data);
146 
147 template<typename T>
148 class MuemexData : public MuemexArg
149 {
150  public:
151  MuemexData(T& data); //Construct from pre-existing data, to pass to MATLAB.
152  MuemexData(T& data, MuemexType type); //Construct from pre-existing data, to pass to MATLAB.
153  MuemexData(const mxArray* mxa); //Construct from MATLAB array, to get from MATLAB.
154  mxArray* convertToMatlab(); //Create a MATLAB object and copy this data to it
155  T& getData(); //Set and get methods
156  void setData(T& data);
157  private:
158  T data;
159 };
160 
161 template<typename T>
162 MuemexType getMuemexType(const T & data);
163 
164 template<typename T>
166 
167 template<typename T>
168 T loadDataFromMatlab(const mxArray* mxa);
169 
170 template<typename T>
171 mxArray* saveDataToMatlab(T& data);
172 
173 //Add data to level. Set the keep flag on the data to "user-provided" so it's not deleted.
174 template<typename T>
175 void addLevelVariable(const T& data, std::string& name, Level& lvl, const FactoryBase *fact = NoFactory::get());
176 
177 template<typename T>
178 const T& getLevelVariable(std::string& name, Level& lvl);
179 
180 //Functions used to put data through matlab factories - first arg is "this" pointer of matlab factory
181 template<typename Scalar = double, typename LocalOrdinal = mm_LocalOrd, typename GlobalOrdinal = mm_GlobalOrd, typename Node = mm_node_t>
182 std::vector<Teuchos::RCP<MuemexArg>> processNeeds(const Factory* factory, std::string& needsParam, Level& lvl);
183 
184 template<typename Scalar = double, typename LocalOrdinal = mm_LocalOrd, typename GlobalOrdinal = mm_GlobalOrd, typename Node = mm_node_t>
185 void processProvides(std::vector<Teuchos::RCP<MuemexArg>>& mexOutput, const Factory* factory, std::string& providesParam, Level& lvl);
186 
187 //create a sparse array in Matlab
188 template<typename Scalar> mxArray* createMatlabSparse(int numRows, int numCols, int nnz);
189 template<typename Scalar> mxArray* createMatlabMultiVector(int numRows, int numCols);
190 template<typename Scalar> void fillMatlabArray(Scalar* array, const mxArray* mxa, int n);
191 int* mwIndex_to_int(int N, mwIndex* mwi_array);
192 bool isValidMatlabAggregates(const mxArray* mxa);
193 bool isValidMatlabGraph(const mxArray* mxa);
194 std::vector<std::string> tokenizeList(const std::string& param);
195 //The two callback functions that MueLu can call to run anything in MATLAB
196 void callMatlabNoArgs(std::string function);
197 std::vector<Teuchos::RCP<MuemexArg>> callMatlab(std::string function, int numOutputs, std::vector<Teuchos::RCP<MuemexArg>> args);
199 Teuchos::RCP<MuemexArg> convertMatlabVar(const mxArray* mxa);
200 
201 // trim from start
202 static inline std::string &ltrim(std::string &s) {
203  s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
204  return s;
205 }
206 
207 // trim from end
208 static inline std::string &rtrim(std::string &s) {
209  s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
210  return s;
211 }
212 
213 // trim from both ends
214 static inline std::string &trim(std::string &s) {
215  return ltrim(rtrim(s));
216 }
217 
218 }//end namespace
219 
220 #endif //HAVE_MUELU_MATLAB error handler
221 #endif //MUELU_MATLABUTILS_DECL_HPP guard
Xpetra::MultiVector< double, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Xpetra_MultiVector_double
bool isValidMatlabAggregates(const mxArray *mxa)
template mxArray * saveDataToMatlab(bool &data)
std::vector< std::string > tokenizeList(const std::string &params)
Xpetra::MultiVector< complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Xpetra_MultiVector_complex
Xpetra::CrsGraph< mm_LocalOrd, mm_GlobalOrd, mm_node_t > Xpetra_CrsGraph
Container class for aggregation information.
Tpetra::CrsMatrix< complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Tpetra_CrsMatrix_complex
void fillMatlabArray(Scalar *array, const mxArray *mxa, int n)
T loadDataFromMatlab(const mxArray *mxa)
bool isValidMatlabGraph(const mxArray *mxa)
MueLu::Hierarchy< complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Hierarchy_complex
MuemexType getMuemexType(const T &data)
std::vector< Teuchos::RCP< MuemexArg > > processNeeds(const Factory *factory, std::string &needsParam, Level &lvl)
void addLevelVariable(const T &data, std::string &name, Level &lvl, const FactoryBase *fact=NoFactory::get())
static const NoFactory * get()
Teuchos::RCP< Teuchos::ParameterList > getInputParamList()
Base class for factories (e.g., R, P, and A_coarse).
Xpetra::Vector< mm_LocalOrd, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Xpetra_ordinal_vector
MuemexArg(MuemexType dataType)
MueLu::AmalgamationInfo< mm_LocalOrd, mm_GlobalOrd, mm_node_t > MAmalInfo
int * mwIndex_to_int(int N, mwIndex *mwi_array)
Class that holds all level-specific information.
Definition: MueLu_Level.hpp:99
MueLu::Hierarchy< double, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Hierarchy_double
Kokkos::Compat::KokkosDeviceWrapperNode< Kokkos::Serial, Kokkos::HostSpace > mm_node_t
Xpetra::Matrix< double, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Xpetra_Matrix_double
const T & getLevelVariable(std::string &name, Level &lvl)
Xpetra::Matrix< complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Xpetra_Matrix_complex
static std::string & trim(std::string &s)
MueLu::GraphBase< mm_LocalOrd, mm_GlobalOrd, mm_node_t > MGraph
void callMatlabNoArgs(std::string function)
MueLu representation of a graph.
static std::string & ltrim(std::string &s)
std::complex< double > complex_t
static std::string & rtrim(std::string &s)
MueLu::Aggregates< mm_LocalOrd, mm_GlobalOrd, mm_node_t > MAggregates
Tpetra::Map muemex_map_type
void processProvides(std::vector< Teuchos::RCP< MuemexArg >> &mexOutput, const Factory *factory, std::string &providesParam, Level &lvl)
Tpetra::MultiVector< complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Tpetra_MultiVector_complex
Xpetra::Map< mm_LocalOrd, mm_GlobalOrd, mm_node_t > Xpetra_map
mxArray * createMatlabSparse(int numRows, int numCols, int nnz)
Tpetra::MultiVector< double, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Tpetra_MultiVector_double
int mwIndex
minimal container class for storing amalgamation information
mxArray * createMatlabMultiVector(int numRows, int numCols)
Tpetra::CrsMatrix< double, mm_LocalOrd, mm_GlobalOrd, mm_node_t > Tpetra_CrsMatrix_double
Provides methods to build a multigrid hierarchy and apply multigrid cycles.
std::vector< RCP< MuemexArg > > callMatlab(std::string function, int numOutputs, std::vector< RCP< MuemexArg >> args)
Teuchos::RCP< MuemexArg > convertMatlabVar(const mxArray *mxa)