Zoltan2
Loading...
Searching...
No Matches
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
38namespace Zoltan2{
39
40// Default local ordinal
41typedef ::Tpetra::Details::DefaultTypes::local_ordinal_type default_lno_t;
42
43// Default global ordinal
44typedef ::Tpetra::Details::DefaultTypes::global_ordinal_type default_gno_t;
45
46// Default offset type
47typedef size_t default_offset_t;
48
49// Default scalar type (for weights, coordinates)
50typedef ::Tpetra::Details::DefaultTypes::scalar_type default_scalar_t;
51
52// Until Kokkos node types are supported, use default
53typedef ::Tpetra::Details::DefaultTypes::node_type default_node_t;
54
55// Default part number type.
56typedef 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
104template <typename scalar=default_scalar_t,
105 typename lno=default_lno_t,
106 typename gno=default_gno_t,
107 typename node=default_node_t>
108class BasicUserTypes{
109};
110
145template <typename User>
146struct 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
220template <typename Scalar,
221 typename LocalOrdinal,
222 typename GlobalOrdinal,
223 typename Node>
224struct 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
237template <typename Scalar,
238 typename LocalOrdinal,
239 typename GlobalOrdinal,
240 typename Node>
241struct 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
254template <typename Scalar,
255 typename LocalOrdinal,
256 typename GlobalOrdinal,
257 typename Node>
258struct 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
272template < >
273struct 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
285template <typename Scalar,
286 typename LocalOrdinal,
287 typename GlobalOrdinal,
288 typename Node>
289struct 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
302template <typename Scalar,
303 typename LocalOrdinal,
304 typename GlobalOrdinal,
305 typename Node>
306struct 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
319template <typename LocalOrdinal,
320 typename GlobalOrdinal,
321 typename Node>
322struct 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
333template <typename LocalOrdinal,
334 typename GlobalOrdinal,
335 typename Node>
336struct 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
349template <typename LocalOrdinal,
350 typename GlobalOrdinal,
351 typename Node>
352struct 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
366template < >
367struct 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
379template <typename Scalar,
380 typename LocalOrdinal,
381 typename GlobalOrdinal,
382 typename Node>
383struct 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
399template <typename Scalar,
400 typename LocalOrdinal,
401 typename GlobalOrdinal,
402 typename Node>
403struct 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
417template < >
418struct 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
430template <typename Scalar,
431 typename LocalOrdinal,
432 typename GlobalOrdinal,
433 typename Node>
434struct 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
447template <typename Scalar,
448 typename LocalOrdinal,
449 typename GlobalOrdinal,
450 typename Node>
451struct 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
465template < >
466struct 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_Standards.hpp
Gathering definitions used in software development.
Zoltan2::BasicUserTypes
A simple class that can be the User template argument for an InputAdapter.
Definition Zoltan2_InputTraits.hpp:108
Node
Vector::node_type Node
Definition coloring1.cpp:46
Vector
Tpetra::Vector< z2TestScalar, z2TestLO, z2TestGO > Vector
Definition coloring1.cpp:45
Zoltan2
Created by mbenlioglu on Aug 31, 2020.
Definition Zoltan2_AlgHybrid2GL.hpp:47
Zoltan2::default_node_t
::Tpetra::Details::DefaultTypes::node_type default_node_t
Definition Zoltan2_InputTraits.hpp:53
Zoltan2::default_lno_t
::Tpetra::Details::DefaultTypes::local_ordinal_type default_lno_t
Definition Zoltan2_InputTraits.hpp:41
Zoltan2::default_offset_t
size_t default_offset_t
Definition Zoltan2_InputTraits.hpp:47
Zoltan2::default_gno_t
::Tpetra::Details::DefaultTypes::global_ordinal_type default_gno_t
Definition Zoltan2_InputTraits.hpp:44
Zoltan2::default_scalar_t
::Tpetra::Details::DefaultTypes::scalar_type default_scalar_t
Definition Zoltan2_InputTraits.hpp:50
Zoltan2::InputTraits
The traits required of User input classes or structures.
Definition Zoltan2_InputTraits.hpp:146
Zoltan2::InputTraits::offset_t
default_offset_t offset_t
The data type to represent offsets.
Definition Zoltan2_InputTraits.hpp:164
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::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::part_t
default_part_t part_t
The data type to represent part numbers.
Definition Zoltan2_InputTraits.hpp:168
Zoltan2::InputTraits::name
static std::string name()
The name of the user's input object.
Definition Zoltan2_InputTraits.hpp:177
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.9.8