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 Z2_ISSAME(s,std::complex<double>) || Z2_ISSAME(s,std::complex<float>) )
194
195#define Z2_LTYPES(l) ( Z2_ISSAME(l,int) || \
196 Z2_ISSAME(l,long) || Z2_ISSAME(l,long long) || Z2_ISSAME(l,ssize_t) )
197
198#define Z2_GTYPES(g) ( Z2_ISSAME(g,int) || Z2_ISSAME(g,long) || \
199 Z2_ISSAME(g,long long) || Z2_ISSAME(g,ssize_t) || \
200 Z2_ISSAME(g,unsigned int) || Z2_ISSAME(g,unsigned long) || \
201 Z2_ISSAME(g,unsigned long long) || Z2_ISSAME(g,size_t) )
202
203#define Z2_SERROR "Invalid scalar type. It must be float, double, int, long, long long, int32_t, or int64_t."
204
205#define Z2_LERROR "Invalid local ordinal type. It must be int, long, " \
206 "long long, or ssize_t."
207
208#define Z2_GERROR "Invalid global ordinal type. It must be int, long, " \
209 "long long, ssize_t, unsigned int, unsigned long long, size_t."
210
211#ifdef Z2_INVERT_STATIC_ASSERT_FOR_UNIT_TESTING
212 #define Z2_STATIC_ASSERT_TYPES static_assert( ( !Z2_STYPES(scalar_t) || \
213 !Z2_LTYPES(lno_t) || !Z2_GTYPES(gno_t) ), \
214 "Inverted unit test for InputTraits was supposed to fail but did not." );
215#else
216 #define Z2_STATIC_ASSERT_TYPES static_assert( Z2_STYPES(scalar_t), \
217 Z2_SERROR ); static_assert( Z2_LTYPES(lno_t), Z2_LERROR ); \
218 static_assert( Z2_GTYPES(gno_t), Z2_GERROR );
219#endif
220
221template <typename Scalar,
222 typename LocalOrdinal,
223 typename GlobalOrdinal,
224 typename Node>
225struct InputTraits<BasicUserTypes<Scalar, LocalOrdinal, GlobalOrdinal, Node> >
226{
227 typedef Scalar scalar_t;
228 typedef LocalOrdinal lno_t;
229 typedef GlobalOrdinal gno_t;
230 typedef LocalOrdinal offset_t;
231 typedef Zoltan2::default_part_t part_t;
232 typedef Node node_t;
233 static inline std::string name() {return "BasicUserTypes";}
234
235 Z2_STATIC_ASSERT_TYPES // validate the types
236};
237
238template <typename Scalar,
239 typename LocalOrdinal,
240 typename GlobalOrdinal,
241 typename Node>
242struct InputTraits<Xpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
243{
244 typedef Scalar scalar_t;
245 typedef typename Xpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
246 typedef LocalOrdinal lno_t;
247 typedef GlobalOrdinal gno_t;
248 typedef size_t offset_t;
249 typedef Zoltan2::default_part_t part_t;
250 typedef Node node_t;
251 static inline std::string name() {return "Xpetra::CrsMatrix";}
252
253 Z2_STATIC_ASSERT_TYPES // validate the types
254};
255
256template <typename Scalar,
257 typename LocalOrdinal,
258 typename GlobalOrdinal,
259 typename Node>
260struct InputTraits<Tpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
261{
262 typedef Scalar scalar_t;
263 typedef typename Tpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
264 typedef LocalOrdinal lno_t;
265 typedef GlobalOrdinal gno_t;
266 typedef size_t offset_t;
267 typedef Zoltan2::default_part_t part_t;
268 typedef Node node_t;
269 static inline std::string name() {return "Tpetra::CrsMatrix";}
270
271 Z2_STATIC_ASSERT_TYPES // validate the types
272};
273
274#ifdef HAVE_ZOLTAN2_EPETRA
275template < >
276struct InputTraits<Epetra_CrsMatrix>
277{
278 typedef double scalar_t;
279 typedef double impl_scalar_t;
280 typedef int lno_t;
281 typedef int gno_t;
282 typedef size_t offset_t;
283 typedef Zoltan2::default_part_t part_t;
284 typedef Zoltan2::default_node_t node_t;
285 static inline std::string name() {return "Epetra_CrsMatrix";}
286};
287#endif
288
289template <typename Scalar,
290 typename LocalOrdinal,
291 typename GlobalOrdinal,
292 typename Node>
293struct InputTraits<Xpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
294{
295 typedef Scalar scalar_t;
296 typedef typename Xpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
297 typedef LocalOrdinal lno_t;
298 typedef GlobalOrdinal gno_t;
299 typedef size_t offset_t;
300 typedef Zoltan2::default_part_t part_t;
301 typedef Node node_t;
302 static inline std::string name() {return "Xpetra::RowMatrix";}
303
304 Z2_STATIC_ASSERT_TYPES // validate the types
305};
306
307template <typename Scalar,
308 typename LocalOrdinal,
309 typename GlobalOrdinal,
310 typename Node>
311struct InputTraits<Tpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
312{
313 typedef Scalar scalar_t;
314 typedef typename Tpetra::RowMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
315 typedef LocalOrdinal lno_t;
316 typedef GlobalOrdinal gno_t;
317 typedef size_t offset_t;
318 typedef Zoltan2::default_part_t part_t;
319 typedef Node node_t;
320 static inline std::string name() {return "Tpetra::RowMatrix";}
321
322 Z2_STATIC_ASSERT_TYPES // validate the types
323};
324
325template <typename LocalOrdinal,
326 typename GlobalOrdinal,
327 typename Node>
328struct InputTraits<Tpetra::RowGraph<LocalOrdinal,GlobalOrdinal,Node> >
329{
330 typedef default_scalar_t scalar_t;
331 typedef default_scalar_t impl_scalar_t;
332 typedef LocalOrdinal lno_t;
333 typedef GlobalOrdinal gno_t;
334 typedef size_t offset_t;
335 typedef Zoltan2::default_part_t part_t;
336 typedef Node node_t;
337 static inline std::string name() {return "Tpetra::RowGraph";}
338};
339
340template <typename LocalOrdinal,
341 typename GlobalOrdinal,
342 typename Node>
343struct InputTraits<Xpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> >
344{
345 typedef default_scalar_t scalar_t;
346 typedef default_scalar_t impl_scalar_t;
347 typedef LocalOrdinal lno_t;
348 typedef GlobalOrdinal gno_t;
349 typedef size_t offset_t;
350 typedef Zoltan2::default_part_t part_t;
351 typedef Node node_t;
352 static inline std::string name() {return "Xpetra::CrsGraph";}
353
354 Z2_STATIC_ASSERT_TYPES // validate the types
355};
356
357template <typename LocalOrdinal,
358 typename GlobalOrdinal,
359 typename Node>
360struct InputTraits<Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> >
361{
362 typedef default_scalar_t scalar_t;
363 typedef default_scalar_t impl_scalar_t;
364 typedef LocalOrdinal lno_t;
365 typedef GlobalOrdinal gno_t;
366 typedef size_t offset_t;
367 typedef Zoltan2::default_part_t part_t;
368 typedef Node node_t;
369 static inline std::string name() {return "Tpetra::CrsGraph";}
370
371 Z2_STATIC_ASSERT_TYPES // validate the types
372};
373
374#ifdef HAVE_ZOLTAN2_EPETRA
375template < >
376struct InputTraits<Epetra_CrsGraph>
377{
378 typedef double scalar_t;
379 typedef double impl_scalar_t;
380 typedef int lno_t;
381 typedef int gno_t;
382 typedef size_t offset_t;
383 typedef Zoltan2::default_part_t part_t;
384 typedef Zoltan2::default_node_t node_t;
385 static inline std::string name() {return "Epetra_CrsGraph";}
386};
387#endif
388
389template <typename Scalar,
390 typename LocalOrdinal,
391 typename GlobalOrdinal,
392 typename Node>
393struct InputTraits<Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
394{
395 typedef Scalar scalar_t;
396 typedef typename Xpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
397 typedef LocalOrdinal lno_t;
398 typedef GlobalOrdinal gno_t;
399 typedef size_t offset_t;
400 typedef Zoltan2::default_part_t part_t;
401 typedef Node node_t;
402 static inline std::string name() {return "Xpetra::Vector";}
403
404 Z2_STATIC_ASSERT_TYPES // validate the types
405};
406
410template <typename Scalar,
411 typename LocalOrdinal,
412 typename GlobalOrdinal,
413 typename Node>
414struct InputTraits<Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
415{
416 typedef Scalar scalar_t;
417 typedef typename Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
418 typedef LocalOrdinal lno_t;
419 typedef GlobalOrdinal gno_t;
420 typedef size_t offset_t;
421 typedef Zoltan2::default_part_t part_t;
422 typedef Node node_t;
423 static inline std::string name() {return "Tpetra::Vector";}
424
425 Z2_STATIC_ASSERT_TYPES // validate the types
426};
427
428#ifdef HAVE_ZOLTAN2_EPETRA
429template < >
430struct InputTraits<Epetra_Vector>
431{
432 typedef double scalar_t;
433 typedef double impl_scalar_t;
434 typedef int lno_t;
435 typedef int gno_t;
436 typedef size_t offset_t;
437 typedef Zoltan2::default_part_t part_t;
438 typedef Zoltan2::default_node_t node_t;
439 static inline std::string name() {return "Epetra_Vector";}
440};
441#endif
442
443template <typename Scalar,
444 typename LocalOrdinal,
445 typename GlobalOrdinal,
446 typename Node>
447struct InputTraits<Xpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
448{
449 typedef Scalar scalar_t;
450 typedef typename Xpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
451 typedef LocalOrdinal lno_t;
452 typedef GlobalOrdinal gno_t;
453 typedef size_t offset_t;
454 typedef Zoltan2::default_part_t part_t;
455 typedef Node node_t;
456 static inline std::string name() {return "Xpetra::MultiVector";}
457
458 Z2_STATIC_ASSERT_TYPES // validate the types
459};
460
461template <typename Scalar,
462 typename LocalOrdinal,
463 typename GlobalOrdinal,
464 typename Node>
465struct InputTraits<Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
466{
467 typedef Scalar scalar_t;
468 typedef typename Tpetra::MultiVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>::impl_scalar_type impl_scalar_t;
469 typedef LocalOrdinal lno_t;
470 typedef GlobalOrdinal gno_t;
471 typedef size_t offset_t;
472 typedef Zoltan2::default_part_t part_t;
473 typedef Node node_t;
474 static inline std::string name() {return "Tpetra::MultiVector";}
475
476 Z2_STATIC_ASSERT_TYPES // validate the types
477};
478
479#ifdef HAVE_ZOLTAN2_EPETRA
480template < >
481struct InputTraits<Epetra_MultiVector>
482{
483 typedef double scalar_t;
484 typedef double impl_scalar_t;
485 typedef int lno_t;
486 typedef int gno_t;
487 typedef size_t offset_t;
488 typedef Zoltan2::default_part_t part_t;
489 typedef Zoltan2::default_node_t node_t;
490 static inline std::string name() {return "Epetra_MultiVector";}
491};
492#endif
493
494#endif // DOXYGEN_SHOULD_SKIP_THIS
495
496
497} // namespace Zoltan2
498#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