Zoltan2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
Zoltan2_InputTraits.hpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Zoltan2: A package of combinatorial algorithms for scientific computing
4 //
5 // Copyright 2012 NTESS and the Zoltan2 contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
14 #ifndef ZOLTAN2_INPUTTRAITS_HPP
15 #define ZOLTAN2_INPUTTRAITS_HPP
16 
17 #include <Zoltan2_Standards.hpp>
18 
19 #include <Tpetra_CrsMatrix.hpp>
20 #include <Tpetra_RowMatrix.hpp>
21 #include <Tpetra_CrsGraph.hpp>
22 #include <Tpetra_RowGraph.hpp>
23 
24 #ifdef HAVE_ZOLTAN2_EPETRA
25 #include <Epetra_CrsMatrix.h>
26 #include <Epetra_CrsGraph.h>
27 #endif
28 
29 #include <Xpetra_CrsMatrix.hpp>
30 #include <Xpetra_RowMatrix.hpp>
31 #include <Xpetra_TpetraRowMatrix.hpp>
32 #include <Xpetra_CrsGraph.hpp>
33 
34 #ifdef _WIN32
35 #include <basetsd.h>
36 #endif
37 
38 namespace Zoltan2{
39 
40 // Default local ordinal
41 typedef ::Tpetra::Details::DefaultTypes::local_ordinal_type default_lno_t;
42 
43 // Default global ordinal
44 typedef ::Tpetra::Details::DefaultTypes::global_ordinal_type default_gno_t;
45 
46 // Default offset type
47 typedef size_t default_offset_t;
48 
49 // Default scalar type (for weights, coordinates)
50 typedef ::Tpetra::Details::DefaultTypes::scalar_type default_scalar_t;
51 
52 // Until Kokkos node types are supported, use default
53 typedef ::Tpetra::Details::DefaultTypes::node_type default_node_t;
54 
55 // Default part number type.
56 typedef int default_part_t; // Restrictions in MPI interface will make it
57  // somewhat difficult to change default_part_t to
58  // long long, since we use part_t for ranks
59  // and we sometimes broadcast arrays whose
60  // size has type part_t.
61  // part_t must be a signed data type.
62 
104 template <typename scalar=default_scalar_t,
105  typename lno=default_lno_t,
106  typename gno=default_gno_t,
107  typename node=default_node_t>
108 class BasicUserTypes{
109 };
110 
145 template <typename User>
146 struct InputTraits {
147 
150  typedef default_scalar_t scalar_t;
151 
155  typedef default_lno_t lno_t;
156 
160  typedef default_gno_t gno_t;
161 
164  typedef default_offset_t offset_t;
165 
168  typedef default_part_t part_t;
169 
173  typedef default_node_t node_t;
174 
177  static inline std::string name() {return "InputAdapter";}
178 };
179 
180 #ifndef DOXYGEN_SHOULD_SKIP_THIS
181 
182 #ifdef _WIN32
183  typedef SSIZE_T ssize_t;
184 #endif
185 
186 // This combination of macros is used to define a single line
187 // Z2_STATIC_ASSERT_TYPES for each InputTraits with custom template types
188 #define Z2_ISSAME(s,type) (std::is_same< s, type >::value)
189 
190 #define Z2_STYPES(s) ( Z2_ISSAME(s,float) || \
191  Z2_ISSAME(s,double) || Z2_ISSAME(s,int) || Z2_ISSAME(s,long) || \
192  Z2_ISSAME(s,long long) || Z2_ISSAME(s, int64_t) || Z2_ISSAME(s, int32_t))
193 
194 #define Z2_LTYPES(l) ( Z2_ISSAME(l,int) || \
195  Z2_ISSAME(l,long) || Z2_ISSAME(l,long long) || Z2_ISSAME(l,ssize_t) )
196 
197 #define Z2_GTYPES(g) ( Z2_ISSAME(g,int) || Z2_ISSAME(g,long) || \
198  Z2_ISSAME(g,long long) || Z2_ISSAME(g,ssize_t) || \
199  Z2_ISSAME(g,unsigned int) || Z2_ISSAME(g,unsigned long) || \
200  Z2_ISSAME(g,unsigned long long) || Z2_ISSAME(g,size_t) )
201 
202 #define Z2_SERROR "Invalid scalar type. It must be float, double, int, long, long long, int32_t, or int64_t."
203 
204 #define Z2_LERROR "Invalid local ordinal type. It must be int, long, " \
205  "long long, or ssize_t."
206 
207 #define Z2_GERROR "Invalid global ordinal type. It must be int, long, " \
208  "long long, ssize_t, unsigned int, unsigned long long, size_t."
209 
210 #ifdef Z2_INVERT_STATIC_ASSERT_FOR_UNIT_TESTING
211  #define Z2_STATIC_ASSERT_TYPES static_assert( ( !Z2_STYPES(scalar_t) || \
212  !Z2_LTYPES(lno_t) || !Z2_GTYPES(gno_t) ), \
213  "Inverted unit test for InputTraits was supposed to fail but did not." );
214 #else
215  #define Z2_STATIC_ASSERT_TYPES static_assert( Z2_STYPES(scalar_t), \
216  Z2_SERROR ); static_assert( Z2_LTYPES(lno_t), Z2_LERROR ); \
217  static_assert( Z2_GTYPES(gno_t), Z2_GERROR );
218 #endif
219 
220 template <typename Scalar,
221  typename LocalOrdinal,
222  typename GlobalOrdinal,
223  typename Node>
224 struct InputTraits<BasicUserTypes<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
225 {
226  typedef Scalar scalar_t;
227  typedef LocalOrdinal lno_t;
228  typedef GlobalOrdinal gno_t;
229  typedef LocalOrdinal offset_t;
230  typedef Zoltan2::default_part_t part_t;
231  typedef Node node_t;
232  static inline std::string name() {return "BasicUserTypes";}
233 
234  Z2_STATIC_ASSERT_TYPES // validate the types
235 };
236 
237 template <typename Scalar,
238  typename LocalOrdinal,
239  typename GlobalOrdinal,
240  typename Node>
241 struct InputTraits<Xpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
242 {
243  typedef Scalar scalar_t;
244  typedef LocalOrdinal lno_t;
245  typedef GlobalOrdinal gno_t;
246  typedef size_t offset_t;
247  typedef Zoltan2::default_part_t part_t;
248  typedef Node node_t;
249  static inline std::string name() {return "Xpetra::CrsMatrix";}
250 
251  Z2_STATIC_ASSERT_TYPES // validate the types
252 };
253 
254 template <typename Scalar,
255  typename LocalOrdinal,
256  typename GlobalOrdinal,
257  typename Node>
258 struct InputTraits<Tpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
259 {
260  typedef Scalar scalar_t;
261  typedef LocalOrdinal lno_t;
262  typedef GlobalOrdinal gno_t;
263  typedef size_t offset_t;
264  typedef Zoltan2::default_part_t part_t;
265  typedef Node node_t;
266  static inline std::string name() {return "Tpetra::CrsMatrix";}
267 
268  Z2_STATIC_ASSERT_TYPES // validate the types
269 };
270 
271 #ifdef HAVE_ZOLTAN2_EPETRA
272 template < >
273 struct InputTraits<Epetra_CrsMatrix>
274 {
275  typedef double scalar_t;
276  typedef int lno_t;
277  typedef int gno_t;
278  typedef size_t offset_t;
279  typedef Zoltan2::default_part_t part_t;
280  typedef Zoltan2::default_node_t node_t;
281  static inline std::string name() {return "Epetra_CrsMatrix";}
282 };
283 #endif
284 
285 template <typename Scalar,
286  typename LocalOrdinal,
287  typename GlobalOrdinal,
288  typename Node>
289 struct InputTraits<Xpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
290 {
291  typedef Scalar scalar_t;
292  typedef LocalOrdinal lno_t;
293  typedef GlobalOrdinal gno_t;
294  typedef size_t offset_t;
295  typedef Zoltan2::default_part_t part_t;
296  typedef Node node_t;
297  static inline std::string name() {return "Xpetra::RowMatrix";}
298 
299  Z2_STATIC_ASSERT_TYPES // validate the types
300 };
301 
302 template <typename Scalar,
303  typename LocalOrdinal,
304  typename GlobalOrdinal,
305  typename Node>
306 struct InputTraits<Tpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
307 {
308  typedef Scalar scalar_t;
309  typedef LocalOrdinal lno_t;
310  typedef GlobalOrdinal gno_t;
311  typedef size_t offset_t;
312  typedef Zoltan2::default_part_t part_t;
313  typedef Node node_t;
314  static inline std::string name() {return "Tpetra::RowMatrix";}
315 
316  Z2_STATIC_ASSERT_TYPES // validate the types
317 };
318 
319 template <typename LocalOrdinal,
320  typename GlobalOrdinal,
321  typename Node>
322 struct InputTraits<Tpetra::RowGraph<LocalOrdinal,GlobalOrdinal,Node> >
323 {
324  typedef default_scalar_t scalar_t;
325  typedef LocalOrdinal lno_t;
326  typedef GlobalOrdinal gno_t;
327  typedef size_t offset_t;
328  typedef Zoltan2::default_part_t part_t;
329  typedef Node node_t;
330  static inline std::string name() {return "Tpetra::RowGraph";}
331 };
332 
333 template <typename LocalOrdinal,
334  typename GlobalOrdinal,
335  typename Node>
336 struct InputTraits<Xpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> >
337 {
338  typedef default_scalar_t scalar_t;
339  typedef LocalOrdinal lno_t;
340  typedef GlobalOrdinal gno_t;
341  typedef size_t offset_t;
342  typedef Zoltan2::default_part_t part_t;
343  typedef Node node_t;
344  static inline std::string name() {return "Xpetra::CrsGraph";}
345 
346  Z2_STATIC_ASSERT_TYPES // validate the types
347 };
348 
349 template <typename LocalOrdinal,
350  typename GlobalOrdinal,
351  typename Node>
352 struct InputTraits<Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> >
353 {
354  typedef default_scalar_t scalar_t;
355  typedef LocalOrdinal lno_t;
356  typedef GlobalOrdinal gno_t;
357  typedef size_t offset_t;
358  typedef Zoltan2::default_part_t part_t;
359  typedef Node node_t;
360  static inline std::string name() {return "Tpetra::CrsGraph";}
361 
362  Z2_STATIC_ASSERT_TYPES // validate the types
363 };
364 
365 #ifdef HAVE_ZOLTAN2_EPETRA
366 template < >
367 struct InputTraits<Epetra_CrsGraph>
368 {
369  typedef double scalar_t;
370  typedef int lno_t;
371  typedef int gno_t;
372  typedef size_t offset_t;
373  typedef Zoltan2::default_part_t part_t;
374  typedef Zoltan2::default_node_t node_t;
375  static inline std::string name() {return "Epetra_CrsGraph";}
376 };
377 #endif
378 
379 template <typename Scalar,
380  typename LocalOrdinal,
381  typename GlobalOrdinal,
382  typename Node>
383 struct InputTraits<Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
384 {
385  typedef Scalar scalar_t;
386  typedef LocalOrdinal lno_t;
387  typedef GlobalOrdinal gno_t;
388  typedef size_t offset_t;
389  typedef Zoltan2::default_part_t part_t;
390  typedef Node node_t;
391  static inline std::string name() {return "Xpetra::Vector";}
392 
393  Z2_STATIC_ASSERT_TYPES // validate the types
394 };
395 
399 template <typename Scalar,
400  typename LocalOrdinal,
401  typename GlobalOrdinal,
402  typename Node>
403 struct InputTraits<Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
404 {
405  typedef Scalar scalar_t;
406  typedef LocalOrdinal lno_t;
407  typedef GlobalOrdinal gno_t;
408  typedef size_t offset_t;
409  typedef Zoltan2::default_part_t part_t;
410  typedef Node node_t;
411  static inline std::string name() {return "Tpetra::Vector";}
412 
413  Z2_STATIC_ASSERT_TYPES // validate the types
414 };
415 
416 #ifdef HAVE_ZOLTAN2_EPETRA
417 template < >
418 struct InputTraits<Epetra_Vector>
419 {
420  typedef double scalar_t;
421  typedef int lno_t;
422  typedef int gno_t;
423  typedef size_t offset_t;
424  typedef Zoltan2::default_part_t part_t;
425  typedef Zoltan2::default_node_t node_t;
426  static inline std::string name() {return "Epetra_Vector";}
427 };
428 #endif
429 
430 template <typename Scalar,
431  typename LocalOrdinal,
432  typename GlobalOrdinal,
433  typename Node>
434 struct InputTraits<Xpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
435 {
436  typedef Scalar scalar_t;
437  typedef LocalOrdinal lno_t;
438  typedef GlobalOrdinal gno_t;
439  typedef size_t offset_t;
440  typedef Zoltan2::default_part_t part_t;
441  typedef Node node_t;
442  static inline std::string name() {return "Xpetra::MultiVector";}
443 
444  Z2_STATIC_ASSERT_TYPES // validate the types
445 };
446 
447 template <typename Scalar,
448  typename LocalOrdinal,
449  typename GlobalOrdinal,
450  typename Node>
451 struct InputTraits<Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
452 {
453  typedef Scalar scalar_t;
454  typedef LocalOrdinal lno_t;
455  typedef GlobalOrdinal gno_t;
456  typedef size_t offset_t;
457  typedef Zoltan2::default_part_t part_t;
458  typedef Node node_t;
459  static inline std::string name() {return "Tpetra::MultiVector";}
460 
461  Z2_STATIC_ASSERT_TYPES // validate the types
462 };
463 
464 #ifdef HAVE_ZOLTAN2_EPETRA
465 template < >
466 struct InputTraits<Epetra_MultiVector>
467 {
468  typedef double scalar_t;
469  typedef int lno_t;
470  typedef int gno_t;
471  typedef size_t offset_t;
472  typedef Zoltan2::default_part_t part_t;
473  typedef Zoltan2::default_node_t node_t;
474  static inline std::string name() {return "Epetra_MultiVector";}
475 };
476 #endif
477 
478 #endif // DOXYGEN_SHOULD_SKIP_THIS
479 
480 
481 } // namespace Zoltan2
482 #endif // ZOLTAN2_INPUTTRAITS_HPP
Zoltan2::InputTraits::part_t
default_part_t part_t
The data type to represent part numbers.
Definition: Zoltan2_InputTraits.hpp:168
Zoltan2::InputTraits::offset_t
default_offset_t offset_t
The data type to represent offsets.
Definition: Zoltan2_InputTraits.hpp:164
Zoltan2::BasicUserTypes
A simple class that can be the User template argument for an InputAdapter.
Definition: Zoltan2_InputTraits.hpp:108
Zoltan2::default_gno_t
::Tpetra::Details::DefaultTypes::global_ordinal_type default_gno_t
Definition: Zoltan2_InputTraits.hpp:44
Zoltan2::default_lno_t
::Tpetra::Details::DefaultTypes::local_ordinal_type default_lno_t
Definition: Zoltan2_InputTraits.hpp:41
Vector
Tpetra::Vector< z2TestScalar, z2TestLO, z2TestGO > Vector
Definition: coloring1.cpp:45
Zoltan2::default_scalar_t
::Tpetra::Details::DefaultTypes::scalar_type default_scalar_t
Definition: Zoltan2_InputTraits.hpp:50
Zoltan2::default_offset_t
size_t default_offset_t
Definition: Zoltan2_InputTraits.hpp:47
Zoltan2::InputTraits
The traits required of User input classes or structures.
Definition: Zoltan2_InputTraits.hpp:146
Zoltan2::InputTraits::name
static std::string name()
The name of the user&#39;s input object.
Definition: Zoltan2_InputTraits.hpp:177
Zoltan2::InputTraits::lno_t
default_lno_t lno_t
The ordinal type (e.g., int, long, int64_t) that represents local counts and local indices...
Definition: Zoltan2_InputTraits.hpp:155
Zoltan2::InputTraits::gno_t
default_gno_t gno_t
The ordinal type (e.g., int, long, int64_t) that can represent global counts and identifiers.
Definition: Zoltan2_InputTraits.hpp:160
Zoltan2::InputTraits::node_t
default_node_t node_t
The Kokkos node type. This is only meaningful for users of Tpetra objects.
Definition: Zoltan2_InputTraits.hpp:173
Zoltan2_Standards.hpp
Gathering definitions used in software development.
Zoltan2::default_node_t
::Tpetra::Details::DefaultTypes::node_type default_node_t
Definition: Zoltan2_InputTraits.hpp:53
Node
Vector::node_type Node
Definition: coloring1.cpp:46
Zoltan2::InputTraits::scalar_t
default_scalar_t scalar_t
The data type for weights and coordinates.
Definition: Zoltan2_InputTraits.hpp:150
Generated by   doxygen 1.8.5