Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 10:35:42 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
8d60ed57ad
vtk-m/vtkm/cont/Field.h

527 lines
14 KiB
C
Raw Normal View History

encapsulating field for data set.
2015-02-10 17:36:10 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
Correct headers to have the new copyright.
2015-06-03 19:06:43 +00:00
// Copyright 2014 Los Alamos National Security.
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
Correct the include guards on vtkm::cont::Field.
2015-05-29 13:51:11 +00:00
#ifndef vtk_m_cont_Field_h
#define vtk_m_cont_Field_h
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
#include <vtkm/Math.h>
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
#include <vtkm/Range.h>
#include <vtkm/Types.h>
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
#include <vtkm/VecTraits.h>
Refactor MinAndMax to be a shared binary operator.
2016-11-23 20:18:58 +00:00
#include <vtkm/BinaryOperators.h>
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
#include <vtkm/cont/ArrayHandle.h>
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
#include <vtkm/cont/ArrayHandleTransform.h>
CoordinateSystem handles uniform point coordinates. The point of making CoordinateSystem a special type of Field object was so that it could handle special array types like implicit regular point coordinates. Overload the GetData and GetBounds methods to properly handle this type of array.
2015-08-19 04:56:10 +00:00
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
#include <vtkm/cont/DynamicArrayHandle.h>
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
#include <vtkm/cont/internal/ArrayPortalFromIterators.h>
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
namespace vtkm {
namespace cont {
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
namespace internal {
Refactor DynamicArrayHandle to have a common base. Originally, DynamicArrayHandle only automatically handled the default type and storage lists. There was an internal subclass that expanded that to user defined lists, but it was a bit inaccessible. This change makes DynamicArrayHandle match the structure of DynamicCellSet. There is now a templated base class named DynamicArrayHandleBase that can accept any pair of lists. DynamicArrayHandle itself is really just a typedef of DynamicArrayHandleBase with the default lists.
2015-08-18 03:56:04 +00:00
template<typename DeviceAdapterTag>
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
class ComputeRange
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
public:
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
ComputeRange(ArrayHandle<vtkm::Range>& range) : Range(&range) {}
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
template<typename ArrayHandleType>
void operator()(const ArrayHandleType &input) const
{
typedef typename ArrayHandleType::ValueType ValueType;
typedef vtkm::VecTraits<ValueType> VecType;
const vtkm::IdComponent NumberOfComponents = VecType::NUM_COMPONENTS;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag> Algorithm;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
//not the greatest way of doing this for performance reasons. But
//this implementation should generate the smallest amount of code
Update Bound computations to always use a single Reduce call
2016-11-23 14:10:57 +00:00
const vtkm::Pair<ValueType, ValueType> initial(
input.GetPortalConstControl().Get(0),
input.GetPortalConstControl().Get(0));
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Update Bound computations to always use a single Reduce call
2016-11-23 14:10:57 +00:00
vtkm::Pair<ValueType, ValueType> result =
Refactor MinAndMax to be a shared binary operator.
2016-11-23 20:18:58 +00:00
Algorithm::Reduce(input, initial, vtkm::MinAndMax<ValueType>());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
this->Range->Allocate(NumberOfComponents);
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
for (vtkm::IdComponent i = 0; i < NumberOfComponents; ++i)
CoordinateSystem handles uniform point coordinates. The point of making CoordinateSystem a special type of Field object was so that it could handle special array types like implicit regular point coordinates. Overload the GetData and GetBounds methods to properly handle this type of array.
2015-08-19 04:56:10 +00:00
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
this->Range->GetPortalControl().Set(
Update Bound computations to always use a single Reduce call
2016-11-23 14:10:57 +00:00
i, vtkm::Range(VecType::GetComponent(result.first, i),
VecType::GetComponent(result.second, i)));
CoordinateSystem handles uniform point coordinates. The point of making CoordinateSystem a special type of Field object was so that it could handle special array types like implicit regular point coordinates. Overload the GetData and GetBounds methods to properly handle this type of array.
2015-08-19 04:56:10 +00:00
}
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
// Special implementation for regular point coordinates, which are easy
// to determine.
void operator()(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>
&array)
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
array.GetPortalConstControl();
// In this portal we know that the min value is the first entry and the
// max value is the last entry.
vtkm::Vec<vtkm::FloatDefault,3> minimum = portal.Get(0);
vtkm::Vec<vtkm::FloatDefault,3> maximum =
portal.Get(portal.GetNumberOfValues()-1);
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
this->Range->Allocate(3);
vtkm::cont::ArrayHandle<vtkm::Range>::PortalControl outPortal =
this->Range->GetPortalControl();
outPortal.Set(0, vtkm::Range(minimum[0], maximum[0]));
outPortal.Set(1, vtkm::Range(minimum[1], maximum[1]));
outPortal.Set(2, vtkm::Range(minimum[2], maximum[2]));
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
private:
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
vtkm::cont::ArrayHandle<vtkm::Range> *Range;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
};
} // namespace internal
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
/// A \c Field encapsulates an array on some piece of the mesh, such as
Change Node -> Point Most of VTK-m follows the convention of calling the 0D topology elements "points" (which follows the convention of VTK). However, there were several places where they were referred to as "nodes." Make things consistent by calling them points everywhere. Also merged some redundant ExecutionSignature tags.
2015-08-03 16:06:59 +00:00
/// the points, a cell set, a point logical dimension, or the whole mesh.
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
///
class Field
{
public:
completing field.
2015-05-11 20:15:58 +00:00
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
enum AssociationEnum
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
{
adding ability to specify an association type when requesting fields. also adding testing of GetField to UnitTestDataSet tests.
2015-08-12 15:51:14 +00:00
ASSOC_ANY,
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ASSOC_WHOLE_MESH,
ASSOC_POINTS,
ASSOC_CELL_SET,
ASSOC_LOGICAL_DIM
};
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
/// constructors for points / whole mesh
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
Field(std::string name,
AssociationEnum association,
Have CoordinateSystem inherit from Field Previously, coordinate systems in a DataSet simply pointed to field data specifying the coordinate information (although the ability to get that back out of the DataSet was missing). This makes sense since point coordinates are in fact just fields with a particular semantic meaning to them. However, there is an issue with this approach. It turns out that there are special representations that are very common for point coordinates and very uncommon for other types of fields. For example, a uniform (a.k.a. regular or image) grid has point coordinates that are easily derived from the point index, but such fields are quite uncommon elsewhere. Representing this kind of structure in the Field list of a DataSet is problematic. Either all fields have to check to see if they are this type, which will cause an explosion of unnecessary generated code, or you will have to actually write out the coordinates in memory, which is really wasteful but what was done previously. However, by storing fields representing coordinate systems in a separate batch, we can use these special types without the stated explosion.
2015-08-17 18:47:46 +00:00
const vtkm::cont::DynamicArrayHandle &data)
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
ModifiedFlag(true)
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_WHOLE_MESH ||
this->Association == ASSOC_POINTS);
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
}
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
template<typename T, typename Storage>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
Have CoordinateSystem inherit from Field Previously, coordinate systems in a DataSet simply pointed to field data specifying the coordinate information (although the ability to get that back out of the DataSet was missing). This makes sense since point coordinates are in fact just fields with a particular semantic meaning to them. However, there is an issue with this approach. It turns out that there are special representations that are very common for point coordinates and very uncommon for other types of fields. For example, a uniform (a.k.a. regular or image) grid has point coordinates that are easily derived from the point index, but such fields are quite uncommon elsewhere. Representing this kind of structure in the Field list of a DataSet is problematic. Either all fields have to check to see if they are this type, which will cause an explosion of unnecessary generated code, or you will have to actually write out the coordinates in memory, which is really wasteful but what was done previously. However, by storing fields representing coordinate systems in a separate batch, we can use these special types without the stated explosion.
2015-08-17 18:47:46 +00:00
const ArrayHandle<T, Storage> &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
completing field.
2015-05-11 20:15:58 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
completing field.
2015-05-11 20:15:58 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::vector<T> &data)
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const T *data,
vtkm::Id nvals)
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->CopyData(data, nvals);
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
/// constructors for cell set associations
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::DynamicArrayHandle &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
}
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
template <typename T, typename Storage>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::ArrayHandle<T, Storage> &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
completing field.
2015-05-11 20:15:58 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
completing field.
2015-05-11 20:15:58 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
const std::vector<T> &data)
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
const T *data,
vtkm::Id nvals)
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->CopyData(data, nvals);
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
/// constructors for logical dimension associations
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::DynamicArrayHandle &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(logicalDim),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
}
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
template <typename T, typename Storage>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::ArrayHandle<T, Storage> &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocLogicalDim(logicalDim),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
completing field.
2015-05-11 20:15:58 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
completing field.
2015-05-11 20:15:58 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
const std::vector<T> &data)
: Name(name),
Association(association),
AssocLogicalDim(logicalDim),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
const T *data, vtkm::Id nvals)
: Name(name),
Association(association),
AssocLogicalDim(logicalDim),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
CopyData(data, nvals);
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Allow vtkm::cont::Field to have a default constructor. When designing vtkm::filter we needed the ability to construct invalid Fields. This now allows us to do exactly that.
2016-01-04 20:40:37 +00:00
Field()
: Name(),
Fix vtkm::cont::Field default constructor to have valid values.
2016-01-12 21:29:54 +00:00
Association(ASSOC_ANY),
Allow vtkm::cont::Field to have a default constructor. When designing vtkm::filter we needed the ability to construct invalid Fields. This now allows us to do exactly that.
2016-01-04 20:40:37 +00:00
AssocCellSetName(),
AssocLogicalDim(),
Data(),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Allow vtkm::cont::Field to have a default constructor. When designing vtkm::filter we needed the ability to construct invalid Fields. This now allows us to do exactly that.
2016-01-04 20:40:37 +00:00
ModifiedFlag(true)
{
//Generate an empty field
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Make vtkm::cont::Field class const correct
2015-07-13 20:20:39 +00:00
const std::string &GetName() const
starting some field/dataset cleanup
2015-05-19 20:21:15 +00:00
{
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
return this->Name;
starting some field/dataset cleanup
2015-05-19 20:21:15 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
AssociationEnum GetAssociation() const
completing field.
2015-05-11 20:15:58 +00:00
{
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
return this->Association;
completing field.
2015-05-11 20:15:58 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Make vtkm::cont::Field class const correct
2015-07-13 20:20:39 +00:00
std::string GetAssocCellSet() const
completing field.
2015-05-11 20:15:58 +00:00
{
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
return this->AssocCellSetName;
completing field.
2015-05-11 20:15:58 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
vtkm::IdComponent GetAssocLogicalDim() const
completing field.
2015-05-11 20:15:58 +00:00
{
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
return this->AssocLogicalDim;
completing field.
2015-05-11 20:15:58 +00:00
}
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag,
TypeList,
StorageList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
if (this->ModifiedFlag)
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
internal::ComputeRange<DeviceAdapterTag> computeRange(this->Range);
this->Data.ResetTypeAndStorageLists(TypeList(),StorageList()).CastAndCall(computeRange);
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
this->ModifiedFlag = false;
}
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
return this->Range;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
void GetRange(vtkm::Range *range,
DeviceAdapterTag,
TypeList,
StorageList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
this->GetRange(DeviceAdapterTag(), TypeList(), StorageList());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
vtkm::Id length = this->Range.GetNumberOfValues();
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
for (vtkm::Id i = 0; i < length; ++i)
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
range[i] = this->Range.GetPortalConstControl().Get(i);
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
}
template<typename DeviceAdapterTag, typename TypeList>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag,
TypeList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
return this->GetRange(DeviceAdapterTag(),
TypeList(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
template<typename DeviceAdapterTag, typename TypeList>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
void GetRange(vtkm::Range *range, DeviceAdapterTag, TypeList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
this->GetRange(range,
DeviceAdapterTag(),
TypeList(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
template<typename DeviceAdapterTag>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
return this->GetRange(DeviceAdapterTag(),
VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
template<typename DeviceAdapterTag>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
void GetRange(vtkm::Range *range, DeviceAdapterTag) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
this->GetRange(range,
DeviceAdapterTag(),
VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
const vtkm::cont::DynamicArrayHandle &GetData() const
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
{
return this->Data;
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
vtkm::cont::DynamicArrayHandle &GetData()
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
{
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
this->ModifiedFlag = true;
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
return this->Data;
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
}
completing field.
2015-05-11 20:15:58 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
void SetData(const vtkm::cont::ArrayHandle<T> &newdata)
{
this->Data = newdata;
this->ModifiedFlag = true;
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
void SetData(const vtkm::cont::DynamicArrayHandle &newdata)
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
{
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->Data = newdata;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
this->ModifiedFlag = true;
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
}
starting some field/dataset cleanup
2015-05-19 20:21:15 +00:00
template <typename T>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
void CopyData(const T *ptr, vtkm::Id nvals)
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
{
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
//allocate main memory using an array handle
vtkm::cont::ArrayHandle<T> tmp;
tmp.Allocate(nvals);
//copy into the memory owned by the array handle
std::copy(ptr,
ptr + static_cast<std::size_t>(nvals),
vtkm::cont::ArrayPortalToIteratorBegin(tmp.GetPortalControl()));
//assign to the dynamic array handle
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->Data = tmp;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
this->ModifiedFlag = true;
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
}
Add PrintSummary() for DataSet.
2015-05-20 19:26:10 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Make vtkm::cont::Field class const correct
2015-07-13 20:20:39 +00:00
virtual void PrintSummary(std::ostream &out) const
Add PrintSummary() for DataSet.
2015-05-20 19:26:10 +00:00
{
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
out<<" "<<this->Name;
Add PrintSummary() for DataSet.
2015-05-20 19:26:10 +00:00
out<<" assoc= ";
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
switch (this->GetAssociation())
Add PrintSummary() for DataSet.
2015-05-20 19:26:10 +00:00
{
adding case for new "ANY" association.
2015-08-12 17:37:36 +00:00
case ASSOC_ANY: out<<"Any "; break;
Add PrintSummary() for DataSet.
2015-05-20 19:26:10 +00:00
case ASSOC_WHOLE_MESH: out<<"Mesh "; break;
case ASSOC_POINTS: out<<"Points "; break;
case ASSOC_CELL_SET: out<<"Cells "; break;
case ASSOC_LOGICAL_DIM: out<<"LogicalDim "; break;
}
Make PrintSummary actually work for Field and CoordinateSystem. The PrintSummary for CoordinateSystem went in an infinite loop. It was supposed to call PrintSummary of its superclass (Field), but instead it called itself. The PrintSummary for Field only worked for fields of type vtkm::Float32. To make it work for all array types, I added a PrintSummary method to DynamicArrayHandle, and Field calls that without trying to cast to a static type.
2015-08-27 16:20:30 +00:00
this->Data.PrintSummary(out);
Add PrintSummary() for DataSet.
2015-05-20 19:26:10 +00:00
out<<"\n";
}
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
private:
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
std::string Name; ///< name of field
starting some field/dataset cleanup
2015-05-19 20:21:15 +00:00
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
AssociationEnum Association;
std::string AssocCellSetName; ///< only populate if assoc is cells
vtkm::IdComponent AssocLogicalDim; ///< only populate if assoc is logical dim
completing field.
2015-05-11 20:15:58 +00:00
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
vtkm::cont::DynamicArrayHandle Data;
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
mutable vtkm::cont::ArrayHandle<vtkm::Range> Range;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
mutable bool ModifiedFlag;
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
};
make CastAndCall a free function instead of a class. Overloading the function serves the same purpose of specializing the class, but requires less syntax sugar to do.
2016-08-05 18:47:19 +00:00
template<typename Functor>
void CastAndCall(const vtkm::cont::Field& field, const Functor &f)
{
field.GetData().CastAndCall(f);
}
Add vtkm::cont::Field,CoordinateSystem as Invokable parameters. Originally, only array handles could be passed to the dispatcher. This update extends the list to Field and CoordinateSystem as dynamic objects.
2016-08-03 18:38:25 +00:00
make CastAndCall a free function instead of a class. Overloading the function serves the same purpose of specializing the class, but requires less syntax sugar to do.
2016-08-05 18:47:19 +00:00
namespace internal {
Add vtkm::cont::Field,CoordinateSystem as Invokable parameters. Originally, only array handles could be passed to the dispatcher. This update extends the list to Field and CoordinateSystem as dynamic objects.
2016-08-03 18:38:25 +00:00
template<>
struct DynamicTransformTraits<vtkm::cont::Field>
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
Add vtkm::cont::Field,CoordinateSystem as Invokable parameters. Originally, only array handles could be passed to the dispatcher. This update extends the list to Field and CoordinateSystem as dynamic objects.
2016-08-03 18:38:25 +00:00
} // namespace internal
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
} // namespace cont
} // namespace vtkm
Correct the include guards on vtkm::cont::Field.
2015-05-29 13:51:11 +00:00
#endif //vtk_m_cont_Field_h
Reference in New Issue Copy Permalink