MueLu  Version of the Day
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>
60 #include <Teuchos_ParameterList.hpp>
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"
72 #include "Xpetra_EpetraCrsMatrix.hpp"
73 #include "Xpetra_MapFactory.hpp"
74 #include "Xpetra_VectorFactory.hpp"
75 #include <Tpetra_DefaultPlatform.hpp>
76 
77 namespace MueLu
78 {
79 
81 {
82  INT,
102 };
103 
104 typedef Kokkos::Compat::KokkosDeviceWrapperNode<Kokkos::Serial, Kokkos::HostSpace> mm_node_t;
105 typedef int mm_LocalOrd; //these are used for LocalOrdinal and GlobalOrdinal of all xpetra/tpetra templated types
106 typedef int mm_GlobalOrd;
107 typedef std::complex<double> complex_t;
108 typedef Tpetra::Map<> muemex_map_type;
109 typedef Tpetra::CrsMatrix<double, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_CrsMatrix_double;
110 typedef Tpetra::CrsMatrix<complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_CrsMatrix_complex;
111 typedef Tpetra::MultiVector<double, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_MultiVector_double;
112 typedef Tpetra::MultiVector<complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Tpetra_MultiVector_complex;
113 typedef Xpetra::Map<mm_LocalOrd, mm_GlobalOrd, mm_node_t> Xpetra_map;
114 typedef Xpetra::Vector<mm_LocalOrd, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Xpetra_ordinal_vector;
115 typedef Xpetra::Matrix<double, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Xpetra_Matrix_double;
116 typedef Xpetra::Matrix<complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Xpetra_Matrix_complex;
117 typedef Xpetra::MultiVector<double, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Xpetra_MultiVector_double;
118 typedef Xpetra::MultiVector<complex_t, mm_LocalOrd, mm_GlobalOrd, mm_node_t> Xpetra_MultiVector_complex;
124 
126 {
127  public:
128  MuemexArg(MuemexType dataType) {type = dataType;}
130 };
131 
132 template<typename T>
133 MuemexType getMuemexType(const T & data);
134 
135 template<typename T>
136 class MuemexData : public MuemexArg
137 {
138  public:
139  MuemexData(T& data); //Construct from pre-existing data, to pass to MATLAB.
140  MuemexData(T& data, MuemexType type); //Construct from pre-existing data, to pass to MATLAB.
141  MuemexData(const mxArray* mxa); //Construct from MATLAB array, to get from MATLAB.
142  mxArray* convertToMatlab(); //Create a MATLAB object and copy this data to it
143  T& getData(); //Set and get methods
144  void setData(T& data);
145  private:
146  T data;
147 };
148 
149 template<typename T>
150 MuemexType getMuemexType(const T & data);
151 
152 template<typename T>
154 
155 template<typename T>
156 T loadDataFromMatlab(const mxArray* mxa);
157 
158 template<typename T>
159 mxArray* saveDataToMatlab(T& data);
160 
161 //Add data to level. Set the keep flag on the data to "user-provided" so it's not deleted.
162 template<typename T>
163 void addLevelVariable(const T& data, std::string& name, Level& lvl, Factory *fact = NoFactory::get());
164 
165 template<typename T>
166 const T& getLevelVariable(std::string& name, Level& lvl);
167 
168 //Functions used to put data through matlab factories - first arg is "this" pointer of matlab factory
169 template<typename Scalar = double, typename LocalOrdinal = mm_LocalOrd, typename GlobalOrdinal = mm_GlobalOrd, typename Node = mm_node_t>
170 std::vector<Teuchos::RCP<MuemexArg>> processNeeds(const Factory* factory, std::string& needsParam, Level& lvl);
171 
172 template<typename Scalar = double, typename LocalOrdinal = mm_LocalOrd, typename GlobalOrdinal = mm_GlobalOrd, typename Node = mm_node_t>
173 void processProvides(std::vector<Teuchos::RCP<MuemexArg>>& mexOutput, const Factory* factory, std::string& providesParam, Level& lvl);
174 
175 //create a sparse array in Matlab
176 template<typename Scalar> mxArray* createMatlabSparse(int numRows, int numCols, int nnz);
177 template<typename Scalar> mxArray* createMatlabMultiVector(int numRows, int numCols);
178 template<typename Scalar> void fillMatlabArray(Scalar* array, const mxArray* mxa, int n);
179 int* mwIndex_to_int(int N, mwIndex* mwi_array);
180 bool isValidMatlabAggregates(const mxArray* mxa);
181 bool isValidMatlabGraph(const mxArray* mxa);
182 std::vector<std::string> tokenizeList(const std::string& param);
183 //The two callback functions that MueLu can call to run anything in MATLAB
184 void callMatlabNoArgs(std::string function);
185 std::vector<Teuchos::RCP<MuemexArg>> callMatlab(std::string function, int numOutputs, std::vector<Teuchos::RCP<MuemexArg>> args);
186 Teuchos::RCP<Teuchos::ParameterList> getInputParamList();
187 Teuchos::RCP<MuemexArg> convertMatlabVar(const mxArray* mxa);
188 
189 // trim from start
190 static inline std::string &ltrim(std::string &s) {
191  s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
192  return s;
193 }
194 
195 // trim from end
196 static inline std::string &rtrim(std::string &s) {
197  s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
198  return s;
199 }
200 
201 // trim from both ends
202 static inline std::string &trim(std::string &s) {
203  return ltrim(rtrim(s));
204 }
205 
206 }//end namespace
207 
208 #endif //HAVE_MUELU_MATLAB error handler
209 #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
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)
Namespace for MueLu classes and methods.
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)
static const NoFactory * get()
Teuchos::RCP< Teuchos::ParameterList > getInputParamList()
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
void addLevelVariable(const T &data, std::string &name, Level &lvl, Factory *fact=NoFactory::get())
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)