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

Merge topic 'template_particletype'

Browse Source 
69af0f003 Merge branch 'master' of https://gitlab.kitware.com/vtk/vtk-m into template_particletype
34a2e762f Merge branch 'master' of https://gitlab.kitware.com/vtk/vtk-m into template_particletype
c19e5eaab Remove newline that was added.
108f4f1f2 fix compile error.
7dc0194ea Fix compile error.
86fba6846 Create typedefs for existing filters with same name.
09f4ff380 fix compiler errors.
9ee00e395 Fix examples and test
...

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Abhishek Yenpure <abhishek@uoregon.edu>
Merge-request: !2636
This commit is contained in:
Dave Pugmire 2021-12-17 00:59:34 +00:00 committed by Kitware Robot
commit 88bedf34f8
14 changed files with 100 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
vtkm/filter/FilterParticleAdvection.h
View File

@ -25,7 +25,7 @@ namespace filter
/// Takes as input a vector field and seed locations and advects the seeds
/// through the flow field.
template <class Derived>
template <class Derived, typename ParticleType>
class FilterParticleAdvection : public vtkm::filter::FilterDataSetWithField<Derived>
{
public:
@ -41,14 +41,14 @@ public:
void SetNumberOfSteps(vtkm::Id n) { this->NumberOfSteps = n; }
VTKM_CONT
void SetSeeds(const std::vector<vtkm::Particle>& seeds,
void SetSeeds(const std::vector<ParticleType>& seeds,
vtkm::CopyFlag copyFlag = vtkm::CopyFlag::On)
{
this->Seeds = vtkm::cont::make_ArrayHandle(seeds, copyFlag);
}
VTKM_CONT
void SetSeeds(vtkm::cont::ArrayHandle<vtkm::Particle>& seeds) { this->Seeds = seeds; }
void SetSeeds(vtkm::cont::ArrayHandle<ParticleType>& seeds) { this->Seeds = seeds; }
VTKM_CONT
bool GetUseThreadedAlgorithm() { return this->UseThreadedAlgorithm; }
@ -71,14 +71,13 @@ public:
protected:
VTKM_CONT virtual void ValidateOptions() const;
using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
VTKM_CONT std::vector<DSIType> CreateDataSetIntegrators(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
VTKM_CONT std::vector<vtkm::filter::particleadvection::DataSetIntegrator>
CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
vtkm::Id NumberOfSteps;
vtkm::FloatDefault StepSize;
vtkm::cont::ArrayHandle<vtkm::Particle> Seeds;
vtkm::cont::ArrayHandle<ParticleType> Seeds;
bool UseThreadedAlgorithm;
private:

21
vtkm/filter/FilterParticleAdvection.hxx
View File

@ -18,8 +18,8 @@ namespace filter
{
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT FilterParticleAdvection<Derived>::FilterParticleAdvection()
template <typename Derived, typename ParticleType>
inline VTKM_CONT FilterParticleAdvection<Derived, ParticleType>::FilterParticleAdvection()
: vtkm::filter::FilterDataSetWithField<Derived>()
, NumberOfSteps(0)
, StepSize(0)
@ -27,8 +27,8 @@ inline VTKM_CONT FilterParticleAdvection<Derived>::FilterParticleAdvection()
{
}
template <typename Derived>
void FilterParticleAdvection<Derived>::ValidateOptions() const
template <typename Derived, typename ParticleType>
void FilterParticleAdvection<Derived, ParticleType>::ValidateOptions() const
{
if (this->GetUseCoordinateSystemAsField())
throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");
@ -40,13 +40,15 @@ void FilterParticleAdvection<Derived>::ValidateOptions() const
throw vtkm::cont::ErrorFilterExecution("Step size not specified.");
}
template <typename Derived>
template <typename Derived, typename ParticleType>
std::vector<vtkm::filter::particleadvection::DataSetIntegrator>
FilterParticleAdvection<Derived>::CreateDataSetIntegrators(
FilterParticleAdvection<Derived, ParticleType>::CreateDataSetIntegrators(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
{
std::vector<vtkm::filter::particleadvection::DataSetIntegrator> dsi;
using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
std::vector<DSIType> dsi;
if (boundsMap.GetTotalNumBlocks() == 0)
throw vtkm::cont::ErrorFilterExecution("No input datasets.");
@ -66,9 +68,10 @@ FilterParticleAdvection<Derived>::CreateDataSetIntegrators(
}
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename Derived, typename ParticleType>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet FilterParticleAdvection<Derived>::PrepareForExecution(
inline VTKM_CONT vtkm::cont::DataSet
FilterParticleAdvection<Derived, ParticleType>::PrepareForExecution(
const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{

14
vtkm/filter/FilterTemporalParticleAdvection.h
View File

@ -25,8 +25,9 @@ namespace filter
/// Takes as input a vector field and seed locations and advects the seeds
/// through the flow field.
template <class Derived>
class FilterTemporalParticleAdvection : public vtkm::filter::FilterParticleAdvection<Derived>
template <class Derived, typename ParticleType>
class FilterTemporalParticleAdvection
: public vtkm::filter::FilterParticleAdvection<Derived, ParticleType>
{
public:
VTKM_CONT
@ -52,12 +53,11 @@ public:
protected:
VTKM_CONT void ValidateOptions(const vtkm::cont::PartitionedDataSet& input) const;
using vtkm::filter::FilterParticleAdvection<Derived>::ValidateOptions;
using vtkm::filter::FilterParticleAdvection<Derived, ParticleType>::ValidateOptions;
using DSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
VTKM_CONT std::vector<DSIType> CreateDataSetIntegrators(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
VTKM_CONT std::vector<vtkm::filter::particleadvection::TemporalDataSetIntegrator>
CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::particleadvection::BoundsMap& boundsMap) const;
vtkm::FloatDefault PreviousTime;
vtkm::FloatDefault NextTime;

23
vtkm/filter/FilterTemporalParticleAdvection.hxx
View File

@ -18,19 +18,20 @@ namespace filter
{
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT FilterTemporalParticleAdvection<Derived>::FilterTemporalParticleAdvection()
: vtkm::filter::FilterParticleAdvection<Derived>()
template <typename Derived, typename ParticleType>
inline VTKM_CONT
FilterTemporalParticleAdvection<Derived, ParticleType>::FilterTemporalParticleAdvection()
: vtkm::filter::FilterParticleAdvection<Derived, ParticleType>()
, PreviousTime(0)
, NextTime(0)
{
}
template <typename Derived>
void FilterTemporalParticleAdvection<Derived>::ValidateOptions(
template <typename Derived, typename ParticleType>
void FilterTemporalParticleAdvection<Derived, ParticleType>::ValidateOptions(
const vtkm::cont::PartitionedDataSet& input) const
{
this->vtkm::filter::FilterParticleAdvection<Derived>::ValidateOptions();
this->vtkm::filter::FilterParticleAdvection<Derived, ParticleType>::ValidateOptions();
if (this->NextDataSet.GetNumberOfPartitions() != input.GetNumberOfPartitions())
throw vtkm::cont::ErrorFilterExecution("Number of partitions do not match");
@ -38,12 +39,13 @@ void FilterTemporalParticleAdvection<Derived>::ValidateOptions(
throw vtkm::cont::ErrorFilterExecution("Previous time must be less than Next time.");
}
template <typename Derived>
template <typename Derived, typename ParticleType>
std::vector<vtkm::filter::particleadvection::TemporalDataSetIntegrator>
FilterTemporalParticleAdvection<Derived>::CreateDataSetIntegrators(
FilterTemporalParticleAdvection<Derived, ParticleType>::CreateDataSetIntegrators(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::particleadvection::BoundsMap& boundsMap) const
{
using DSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
std::vector<DSIType> dsi;
std::string activeField = this->GetActiveFieldName();
@ -65,9 +67,10 @@ FilterTemporalParticleAdvection<Derived>::CreateDataSetIntegrators(
}
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename Derived, typename ParticleType>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet FilterTemporalParticleAdvection<Derived>::PrepareForExecution(
inline VTKM_CONT vtkm::cont::DataSet
FilterTemporalParticleAdvection<Derived, ParticleType>::PrepareForExecution(
const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{

8
vtkm/filter/ParticleAdvection.h
View File

@ -23,16 +23,20 @@ namespace filter
/// Takes as input a vector field and seed locations and generates the
/// end points for each seed through the vector field.
class ParticleAdvection : public vtkm::filter::FilterParticleAdvection<ParticleAdvection>
template <typename ParticleType = vtkm::Particle>
class ParticleAdvectionBase
: public vtkm::filter::FilterParticleAdvection<ParticleAdvectionBase<ParticleType>, ParticleType>
{
public:
VTKM_CONT ParticleAdvection();
VTKM_CONT ParticleAdvectionBase();
template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
};
using ParticleAdvection = ParticleAdvectionBase<vtkm::Particle>;
}
} // namespace vtkm::filter

10
vtkm/filter/ParticleAdvection.hxx
View File

@ -22,19 +22,23 @@ namespace filter
{
//-----------------------------------------------------------------------------
inline VTKM_CONT ParticleAdvection::ParticleAdvection()
: vtkm::filter::FilterParticleAdvection<ParticleAdvection>()
template <typename ParticleType>
inline VTKM_CONT ParticleAdvectionBase<ParticleType>::ParticleAdvectionBase()
: vtkm::filter::FilterParticleAdvection<ParticleAdvectionBase<ParticleType>, ParticleType>()
{
}
//-----------------------------------------------------------------------------
template <typename ParticleType>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::PartitionedDataSet ParticleAdvection::PrepareForExecution(
inline VTKM_CONT vtkm::cont::PartitionedDataSet
ParticleAdvectionBase<ParticleType>::PrepareForExecution(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
using AlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionAlgorithm;
using ThreadedAlgorithmType = vtkm::filter::particleadvection::ParticleAdvectionThreadedAlgorithm;
using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
this->ValidateOptions();
vtkm::filter::particleadvection::BoundsMap boundsMap(input);

9
vtkm/filter/PathParticle.h
View File

@ -21,11 +21,14 @@ namespace filter
/// Takes as input a vector field and seed locations and generates the
/// paths taken by the seeds through the vector field.
class PathParticle : public vtkm::filter::FilterTemporalParticleAdvection<PathParticle>
template <typename ParticleType>
class PathParticleBase
: public vtkm::filter::FilterTemporalParticleAdvection<PathParticleBase<ParticleType>,
ParticleType>
{
public:
VTKM_CONT
PathParticle();
PathParticleBase();
template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution(
@ -36,6 +39,8 @@ protected:
private:
};
using PathParticle = PathParticleBase<vtkm::Particle>;
}
} // namespace vtkm::filter

13
vtkm/filter/PathParticle.hxx
View File

@ -23,19 +23,22 @@ namespace filter
{
//-----------------------------------------------------------------------------
inline VTKM_CONT PathParticle::PathParticle()
: vtkm::filter::FilterTemporalParticleAdvection<PathParticle>()
template <typename ParticleType>
inline VTKM_CONT PathParticleBase<ParticleType>::PathParticleBase()
: vtkm::filter::FilterTemporalParticleAdvection<PathParticleBase<ParticleType>, ParticleType>()
{
}
//-----------------------------------------------------------------------------
template <typename ParticleType>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::PrepareForExecution(
inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticleBase<ParticleType>::PrepareForExecution(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
using AlgorithmType = vtkm::filter::particleadvection::PathParticleAlgorithm;
using ThreadedAlgorithmType = vtkm::filter::particleadvection::PathParticleThreadedAlgorithm;
using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
this->ValidateOptions(input);
@ -43,10 +46,10 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet PathParticle::PrepareForExecutio
auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
if (this->GetUseThreadedAlgorithm())
return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
return vtkm::filter::particleadvection::RunAlgo<TDSIType, ThreadedAlgorithmType>(
boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
else
return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
return vtkm::filter::particleadvection::RunAlgo<TDSIType, AlgorithmType>(
boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
}

8
vtkm/filter/Pathline.h
View File

@ -21,11 +21,13 @@ namespace filter
/// Takes as input a vector field and seed locations and generates the
/// paths taken by the seeds through the vector field.
class Pathline : public vtkm::filter::FilterTemporalParticleAdvection<Pathline>
template <typename ParticleType>
class PathlineBase
: public vtkm::filter::FilterTemporalParticleAdvection<PathlineBase<ParticleType>, ParticleType>
{
public:
VTKM_CONT
Pathline();
PathlineBase();
template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution(
@ -36,6 +38,8 @@ protected:
private:
};
using Pathline = PathlineBase<vtkm::Particle>;
}
} // namespace vtkm::filter

13
vtkm/filter/Pathline.hxx
View File

@ -23,19 +23,22 @@ namespace filter
{
//-----------------------------------------------------------------------------
inline VTKM_CONT Pathline::Pathline()
: vtkm::filter::FilterTemporalParticleAdvection<Pathline>()
template <typename ParticleType>
inline VTKM_CONT PathlineBase<ParticleType>::PathlineBase()
: vtkm::filter::FilterTemporalParticleAdvection<PathlineBase<ParticleType>, ParticleType>()
{
}
//-----------------------------------------------------------------------------
template <typename ParticleType>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::PrepareForExecution(
inline VTKM_CONT vtkm::cont::PartitionedDataSet PathlineBase<ParticleType>::PrepareForExecution(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
using AlgorithmType = vtkm::filter::particleadvection::PathlineAlgorithm;
using ThreadedAlgorithmType = vtkm::filter::particleadvection::PathlineThreadedAlgorithm;
using TDSIType = vtkm::filter::particleadvection::TemporalDataSetIntegrator;
this->ValidateOptions(input);
@ -43,10 +46,10 @@ inline VTKM_CONT vtkm::cont::PartitionedDataSet Pathline::PrepareForExecution(
auto dsi = this->CreateDataSetIntegrators(input, boundsMap);
if (this->GetUseThreadedAlgorithm())
return vtkm::filter::particleadvection::RunAlgo<DSIType, ThreadedAlgorithmType>(
return vtkm::filter::particleadvection::RunAlgo<TDSIType, ThreadedAlgorithmType>(
boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
else
return vtkm::filter::particleadvection::RunAlgo<DSIType, AlgorithmType>(
return vtkm::filter::particleadvection::RunAlgo<TDSIType, AlgorithmType>(
boundsMap, dsi, this->NumberOfSteps, this->StepSize, this->Seeds);
}

8
vtkm/filter/Streamline.h
View File

@ -21,11 +21,13 @@ namespace filter
/// Takes as input a vector field and seed locations and generates the
/// paths taken by the seeds through the vector field.
class Streamline : public vtkm::filter::FilterParticleAdvection<Streamline>
template <typename ParticleType = vtkm::Particle>
class StreamlineBase
: public vtkm::filter::FilterParticleAdvection<StreamlineBase<ParticleType>, ParticleType>
{
public:
VTKM_CONT
Streamline();
StreamlineBase();
template <typename DerivedPolicy>
vtkm::cont::PartitionedDataSet PrepareForExecution(
@ -34,6 +36,8 @@ public:
private:
};
using Streamline = StreamlineBase<vtkm::Particle>;
}
} // namespace vtkm::filter

9
vtkm/filter/Streamline.hxx
View File

@ -22,19 +22,22 @@ namespace filter
{
//-----------------------------------------------------------------------------
inline VTKM_CONT Streamline::Streamline()
: vtkm::filter::FilterParticleAdvection<Streamline>()
template <typename ParticleType>
inline VTKM_CONT StreamlineBase<ParticleType>::StreamlineBase()
: vtkm::filter::FilterParticleAdvection<StreamlineBase<ParticleType>, ParticleType>()
{
}
//-----------------------------------------------------------------------------
template <typename ParticleType>
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::PartitionedDataSet Streamline::PrepareForExecution(
inline VTKM_CONT vtkm::cont::PartitionedDataSet StreamlineBase<ParticleType>::PrepareForExecution(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
using AlgorithmType = vtkm::filter::particleadvection::StreamlineAlgorithm;
using ThreadedAlgorithmType = vtkm::filter::particleadvection::StreamlineThreadedAlgorithm;
using DSIType = vtkm::filter::particleadvection::DataSetIntegrator;
this->ValidateOptions();
vtkm::filter::particleadvection::BoundsMap boundsMap(input);

3
vtkm/worklet/ParticleAdvection.h
View File

@ -32,11 +32,12 @@ public:
using ExecutionSignature = void(_1, _2, _3, _4, _5);
using InputDomain = _1;
template <typename ParticleType>
VTKM_EXEC void operator()(const vtkm::Vec3f& pt,
const vtkm::Id& id,
const vtkm::FloatDefault& time,
const vtkm::Id& step,
vtkm::Particle& particle) const
ParticleType& particle) const
{
particle.Pos = pt;
particle.ID = id;

7
vtkm/worklet/particleadvection/ParticleAdvectionWorklets.h
View File

@ -145,7 +145,9 @@ public:
GetSteps() {}
using ControlSignature = void(FieldIn, FieldOut);
using ExecutionSignature = void(_1, _2);
VTKM_EXEC void operator()(const vtkm::Particle& p, vtkm::Id& numSteps) const
template <typename ParticleType>
VTKM_EXEC void operator()(const ParticleType& p, vtkm::Id& numSteps) const
{
numSteps = p.NumSteps;
}
@ -161,7 +163,8 @@ public:
// Offset is number of points in streamline.
// 1 (inital point) + number of steps taken (p.NumSteps - initalNumSteps)
VTKM_EXEC void operator()(const vtkm::Particle& p,
template <typename ParticleType>
VTKM_EXEC void operator()(const ParticleType& p,
const vtkm::Id& initialNumSteps,
vtkm::Id& diff) const
{