Commit ad73a04a authored by hrchilds's avatar hrchilds

Separate streamline and poincare specific code from avtStreamline

into avtStateRecorderIntegralCurve.


git-svn-id: http://visit.ilight.com/svn/visit/trunk/src@11577 18c085ea-50e0-402c-830e-de6fd14e8384
parent 8207de42
......@@ -753,8 +753,13 @@ avtMasterSLAlgorithm::PrintStatus()
// Dave Pugmire, Wed Mar 25 10:04:29 EDT 2009
// Control print information for large domain problems.
//
// Hank Childs, Sat Jun 5 11:29:13 CDT 2010
// Change return type to void, since it wasn't returning anything and the
// calling function wasn't looking for a return value.
//
// ****************************************************************************
bool
void
avtMasterSLAlgorithm::UpdateSlaveStatus(vector<int> &status)
{
int src = status[0];
......
......@@ -152,8 +152,11 @@ class avtMasterSlaveSLAlgorithm : public avtParSLAlgorithm
// detect when slave set is done and mark done. Modify logic in how masters
// make decisions. Add domainOffloading (case 5).
//
// Dave Pugmire, Thu Sep 24 13:52:59 EDT 2009
// Change Execute to RunAlgorithm.
// Dave Pugmire, Thu Sep 24 13:52:59 EDT 2009
// Change Execute to RunAlgorithm.
//
// Hank Childs, Sat Jun 5 11:29:13 CDT 2010
// Change return value of UpdateSlaveStatus.
//
// ****************************************************************************
......@@ -204,7 +207,7 @@ class avtMasterSLAlgorithm : public avtMasterSlaveSLAlgorithm
void FindSlackers(int oobFactor=-1,
bool randomize= true,
bool checkJustUpdated=false);
bool UpdateSlaveStatus(std::vector<int> &);
void UpdateSlaveStatus(std::vector<int> &);
void PrintStatus();
void Case1(int &counter);
......
......@@ -419,7 +419,7 @@ avtParSLAlgorithm::MergeTerminatedSLSequences()
//Merge the sequences together, put them into terminated list.
for (int i = 0; i < seqs.size(); i++)
{
avtStreamline *s = avtStreamline::MergeStreamlineSequence(seqs[i]);
avtStreamline *s = seqs[i][0]->MergeIntegralCurveSequence(seqs[i]);
terminatedSLs.push_back(s);
}
}
......@@ -978,6 +978,10 @@ avtParSLAlgorithm::DoSendSLs(int dst,
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// Hank Childs, Sat Jun 5 16:21:27 CDT 2010
// Use the PICS filter to instantiate integral curves, as this is now
// an abstract type.
//
// ****************************************************************************
int
......@@ -1022,7 +1026,7 @@ avtParSLAlgorithm::RecvSLs(list<avtStreamline *> &recvSLs)
for (int j = 0; j < numSLs; j++)
{
avtStreamline *sl = new avtStreamline;
avtStreamline *sl = streamlineFilter->CreateIntegralCurve();
sl->Serialize(MemStream::READ, buff, GetSolver());
recvSLs.push_back(sl);
slCount++;
......
......@@ -89,6 +89,7 @@ Consider the leaveDomains SLs and the balancing at the same time.
#include <avtIntervalTree.h>
#include <avtMetaData.h>
#include <avtParallel.h>
#include <avtStateRecorderIntegralCurve.h>
#include <avtStreamline.h>
#include <avtVector.h>
......@@ -255,6 +256,26 @@ avtStreamlineFilter::~avtStreamlineFilter()
intersectObj->Delete();
}
// ****************************************************************************
// Method: avtStreamlineFilter::CreateIntegralCurve
//
// Purpose:
// Each derived type of avtPICSFilter must know how to create an integral
// curve. The streamline filter creates an avtStateRecorderIntegralCurve.
//
// Programmer: Hank Childs
// Creation: June 5, 2010
//
// ****************************************************************************
avtStreamline *
avtStreamlineFilter::CreateIntegralCurve(void)
{
return new avtStateRecorderIntegralCurve;
}
// ****************************************************************************
// Method: avtStreamlineFilter::ComputeRankList
//
......@@ -1977,12 +1998,13 @@ avtStreamlineFilter::DomainToRank(DomainType &domain)
// ****************************************************************************
void
avtStreamlineFilter::IntegrateDomain(avtStreamline *sl,
avtStreamlineFilter::IntegrateDomain(avtStreamline *sl2,
vtkDataSet *ds,
double *extents,
int maxSteps )
{
int t0 = visitTimer->StartTimer();
avtStateRecorderIntegralCurve *sl = (avtStateRecorderIntegralCurve *)sl2;
sl->scalars.resize(0);
if (coloringVariable != "")
sl->scalars.push_back(coloringVariable);
......@@ -2530,6 +2552,9 @@ avtStreamlineFilter::AddSeedpoints(std::vector<avtVector> &pts,
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// Hank Childs, Sat Jun 5 16:26:12 CDT 2010
// Use avtStateRecorderIntegralCurves.
//
// ****************************************************************************
void
......@@ -2537,16 +2562,16 @@ avtStreamlineFilter::CreateStreamlinesFromSeeds(std::vector<avtVector> &pts,
std::vector<avtStreamline *> &streamlines,
std::vector<std::vector<int> > &ids)
{
avtStreamline::ScalarValueType scalarVal = avtStreamline::NONE;
avtStateRecorderIntegralCurve::ScalarValueType scalarVal = avtStateRecorderIntegralCurve::NONE;
if (coloringMethod == STREAMLINE_COLOR_SPEED)
scalarVal = avtStreamline::SPEED;
scalarVal = avtStateRecorderIntegralCurve::SPEED;
else if (coloringMethod == STREAMLINE_COLOR_VORTICITY)
scalarVal = avtStreamline::VORTICITY;
scalarVal = avtStateRecorderIntegralCurve::VORTICITY;
else if (coloringMethod == STREAMLINE_COLOR_VARIABLE)
scalarVal = avtStreamline::SCALAR_VARIABLE;
scalarVal = avtStateRecorderIntegralCurve::SCALAR_VARIABLE;
if (displayMethod == STREAMLINE_DISPLAY_RIBBONS)
scalarVal = (avtStreamline::ScalarValueType)(scalarVal | avtStreamline::VORTICITY);
scalarVal = (avtStateRecorderIntegralCurve::ScalarValueType)(scalarVal | avtStateRecorderIntegralCurve::VORTICITY);
for (int i = 0; i < pts.size(); i++)
......@@ -2565,8 +2590,10 @@ avtStreamlineFilter::CreateStreamlinesFromSeeds(std::vector<avtVector> &pts,
if (streamlineDirection == VTK_INTEGRATE_FORWARD ||
streamlineDirection == VTK_INTEGRATE_BOTH_DIRECTIONS)
{
avtStreamline *sl = new avtStreamline(solver, seedTime0, pts[i],
GetNextStreamlineID());
avtStateRecorderIntegralCurve *sl = new
avtStateRecorderIntegralCurve(solver,
seedTime0, pts[i],
GetNextStreamlineID());
sl->SetScalarValueType(scalarVal);
sl->domain = dom;
......@@ -2580,7 +2607,9 @@ avtStreamlineFilter::CreateStreamlinesFromSeeds(std::vector<avtVector> &pts,
if (streamlineDirection == VTK_INTEGRATE_BACKWARD ||
streamlineDirection == VTK_INTEGRATE_BOTH_DIRECTIONS)
{
avtStreamline *sl = new avtStreamline(solver, seedTime0, pts[i],
avtStateRecorderIntegralCurve *sl = new
avtStateRecorderIntegralCurve(solver,
seedTime0, pts[i],
GetNextStreamlineID());
sl->SetScalarValueType(scalarVal);
sl->domain = dom;
......
......@@ -223,6 +223,9 @@ class avtSLAlgorithm;
// Hank Childs, Fri Jun 4 19:58:30 CDT 2010
// Use avtStreamlines, not avtStreamlineWrappers.
//
// Hank Childs, Sat Jun 5 16:21:27 CDT 2010
// Add virtual method CreateIntegralCurve.
//
// ****************************************************************************
class AVTFILTERS_API avtStreamlineFilter :
......@@ -237,6 +240,8 @@ class AVTFILTERS_API avtStreamlineFilter :
virtual const char *GetDescription(void)
{ return "Creating streamlines"; };
virtual avtStreamline *CreateIntegralCurve();
// Methods to set the filter's attributes.
void SetSourceType(int sourceType);
void SetMaxStepLength(double len);
......
......@@ -41,7 +41,7 @@
// ************************************************************************* //
#include <avtStreamlinePolyDataFilter.h>
#include "avtStreamline.h"
#include <vtkAppendPolyData.h>
#include <vtkCellArray.h>
#include <vtkCleanPolyData.h>
......@@ -53,6 +53,9 @@
#include <vtkRibbonFilter.h>
#include <vtkTubeFilter.h>
#include <avtParallel.h>
#include <avtStateRecorderIntegralCurve.h>
std::string avtStreamlinePolyDataFilter::colorvarArrayName = "colorVar";
std::string avtStreamlinePolyDataFilter::paramArrayName = "params";
std::string avtStreamlinePolyDataFilter::opacityArrayName = "opacity";
......@@ -107,8 +110,7 @@ avtStreamlinePolyDataFilter::CreateStreamlineOutput(
vtkAppendPolyData *append = vtkAppendPolyData::New();
for (int i = 0; i < streamlines.size(); i++)
{
avtStreamline *sl = (avtStreamline *) streamlines[i];
vector<float> thetas;
avtStreamline *sl = streamlines[i];
vtkPolyData *pd = GetVTKPolyData(sl, sl->id);
if (pd == NULL)
......@@ -170,11 +172,15 @@ avtStreamlinePolyDataFilter::CreateStreamlineOutput(
// Dave Pugmire, Tue Apr 6 08:24:44 EDT 2010
// Bug fix for setting opacity.
//
// Hank Childs, Sat Jun 5 16:24:25 CDT 2010
// Use avtStateRecorderIntegralCurves.
//
// ****************************************************************************
vtkPolyData *
avtStreamlinePolyDataFilter::GetVTKPolyData(avtStreamline *sl, int id)
avtStreamlinePolyDataFilter::GetVTKPolyData(avtStreamline *sl2, int id)
{
avtStateRecorderIntegralCurve *sl = (avtStateRecorderIntegralCurve *) sl2;
if (sl == NULL || sl->size() == 0)
return NULL;
......@@ -209,7 +215,7 @@ avtStreamlinePolyDataFilter::GetVTKPolyData(avtStreamline *sl, int id)
params->Allocate(sl->size());
tangents->SetNumberOfComponents(3);
tangents->SetNumberOfTuples(sl->size());
avtStreamline::iterator siter;
avtStateRecorderIntegralCurve::iterator siter;
unsigned int i = 0;
float val = 0.0, theta = 0.0, param = 0.0;
......
......@@ -36,6 +36,9 @@
#
# Modifications:
#
# Hank Childs, Sat Jun 5 16:26:46 CDT 2010
# Add avtStateRecorderIntegralCurve.
#
#****************************************************************************/
SET(AVTIVP_SOURCES
......@@ -46,6 +49,7 @@ avtIVPM3DC1Field.C
avtIVPM3DC1Integrator.C
avtIVPVTKField.C
avtIVPVTKTimeVaryingField.C
avtStateRecorderIntegralCurve.C
avtStreamline.C
MemStream.C
)
......
This diff is collapsed.
/*****************************************************************************
*
* Copyright (c) 2000 - 2010, Lawrence Livermore National Security, LLC
* Produced at the Lawrence Livermore National Laboratory
* LLNL-CODE-400124
* All rights reserved.
*
* This file is part of VisIt. For details, see https://visit.llnl.gov/. The
* full copyright notice is contained in the file COPYRIGHT located at the root
* of the VisIt distribution or at http://www.llnl.gov/visit/copyright.html.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the disclaimer below.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the disclaimer (as noted below) in the
* documentation and/or other materials provided with the distribution.
* - Neither the name of the LLNS/LLNL nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL SECURITY,
* LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
*****************************************************************************/
// ************************************************************************* //
// avtStateRecorderIntegralCurve.h //
// ************************************************************************* //
#ifndef AVT_STATE_RECORDER_INTEGRAL_CURVE_H
#define AVT_STATE_RECORDER_INTEGRAL_CURVE_H
#include <avtStreamline.h>
// ****************************************************************************
// Class: avtStateRecorderIntegralCurve
//
// Purpose:
// A derived type of avtIntegralCurve. This class records the state for
// every step of the integral curve. As the steps may occur on separate
// processors, it also contains code to collect the steps and reconstitute
// them on the originating processor.
//
// Programmer: Hank Childs (refactoring of work from others)
// Creation: June 4, 2010
//
// ****************************************************************************
class IVP_API avtStateRecorderIntegralCurve : public avtStreamline
{
public:
enum ScalarValueType {NONE=0, SPEED=1, VORTICITY=2, SCALAR_VARIABLE=4};
typedef std::vector<avtIVPStep*>::const_iterator iterator;
avtStateRecorderIntegralCurve(const avtIVPSolver* model,
const double& t_start,
const avtVector &p_start, int ID);
avtStateRecorderIntegralCurve();
virtual ~avtStateRecorderIntegralCurve();
void SetScalarValueType(ScalarValueType t) {scalarValueType = t;}
void SetIntersectionObject(vtkObject *obj);
// Integration steps.
size_t size() const;
iterator begin() const;
iterator end() const;
virtual void Serialize(MemStream::Mode mode, MemStream &buff,
avtIVPSolver *solver);
int GetVariableIdx(const std::string &var) const;
protected:
avtStateRecorderIntegralCurve( const avtStateRecorderIntegralCurve& );
avtStateRecorderIntegralCurve& operator=( const avtStateRecorderIntegralCurve& );
void HandleIntersections(avtIVPStep *step,
avtIVPSolver::TerminateType termType,
double end,
avtIVPSolver::Result *result);
bool IntersectPlane(const avtVector &p0, const avtVector &p1);
public:
// Integration steps.
std::vector<avtIVPStep*> _steps;
protected:
virtual void AnalyzeStep(avtIVPStep *step,
const avtIVPField* field,
avtIVPSolver::TerminateType termType,
double end, avtIVPSolver::Result *result);
// Could be static ... only virtual to get to the right method.
// (Temporary solution until we build a communicator class.)
virtual avtStreamline*
MergeIntegralCurveSequence(
std::vector<avtStreamline *> &v);
// Intersection points.
bool intersectionsSet;
int numIntersections;
double intersectPlaneEq[4];
ScalarValueType scalarValueType;
public:
std::vector<std::string> scalars;
};
#endif
This diff is collapsed.
......@@ -37,11 +37,11 @@
*****************************************************************************/
// ************************************************************************* //
// avtStreamline.h //
// avtIntegralCurve.h //
// ************************************************************************* //
#ifndef AVT_STREAMLINE_H
#define AVT_STREAMLINE_H
#ifndef AVT_INTEGRAL_CURVE_H
#define AVT_INTEGRAL_CURVE_H
#include <avtIVPSolver.h>
#include <MemStream.h>
......@@ -97,7 +97,7 @@ class IVP_API DomainType
int domain, timeStep;
friend std::ostream& operator<<(std::ostream &out, const DomainType &d)
{
{
out<<"["<<d.domain<<", "<<d.timeStep<<"]";
return out;
}
......@@ -105,32 +105,13 @@ class IVP_API DomainType
// ****************************************************************************
// Class: avtStreamline
// Class: avtIntegralCurve
//
// Purpose:
// avtStreamline is a straightforward implementation of streamlines, based
// on avtIVPSolver. It currently keeps two avtIVPSolver instances for
// forward and backward integration, cloned from a model instance passed
// to it. Through this model instance, a user of avtStreamline is able to
// select any IVP scheme to be used in the streamline integration.
//
// A streamline is advanced through the advance() method, and
// avtStreamline keeps track of the current integration length in both
// forward and backward time as well as the avtIVPSteps corresponding to
// the streamline. Based the list of accumulated steps, a simple
// interpolation facility is provided that allows querying the
// streamline points and derivatives at arbitrary parameters, independent
// of the actual nature of the representation (be it a high-order
// polynomial or a simple polyline). In the future, avtStreamline
// could be augmented by methods that take care of typical tasks such as
// e.g. generating a piecewise linear representation for rendering.
// Furthermore, avtStreamline provides boundary detection.
//
// It is not necessarily intended that other streamline implementation
// (such as the planned AMR streamlines) derive from avtStreamline, but
// this is certainly possible if enough functionality can be reused. A
// restructuring of avtStreamline is anticipated once more experience has
// been gathered.
// avtIntegralCurve is a straightforward implementation of integral curves,
// based on avtIVPSolver. Through this model instance, a user of
// avtIntegralCurve is able to select any IVP scheme to be used in the
// integration.
//
// Programmer: Christoph Garth
// Creation: February 25, 2008
......@@ -186,6 +167,10 @@ class IVP_API DomainType
// Hank Childs, Fri Jun 4 15:45:39 CDT 2010
// Combine this class with the contents of avtStreamlineWrapper.
//
// Hank Childs, Fri Jun 4 21:30:18 CDT 2010
// Separate out portions specific to Poincare and Streamline into
// avtStateRecorderIntegralCurve.
//
// ****************************************************************************
class IVP_API avtStreamline
......@@ -212,10 +197,6 @@ class IVP_API avtStreamline
SERIALIZE_INC_SEQ = 2,
};
enum ScalarValueType {NONE=0, SPEED=1, VORTICITY=2, SCALAR_VARIABLE=4};
typedef std::vector<avtIVPStep*>::const_iterator iterator;
avtStreamline(const avtIVPSolver* model, const double& t_start,
const avtVector &p_start, int ID);
avtStreamline();
......@@ -225,22 +206,19 @@ class IVP_API avtStreamline
avtIVPSolver::TerminateType termType,
double end);
void SetScalarValueType(ScalarValueType t) {scalarValueType = t;}
void SetIntersectionObject(vtkObject *obj);
double CurrentTime() const;
void CurrentLocation(avtVector &end);
// Integration steps.
size_t size() const;
iterator begin() const;
iterator end() const;
void Debug() const;
void Serialize(MemStream::Mode mode, MemStream &buff,
virtual void Serialize(MemStream::Mode mode, MemStream &buff,
avtIVPSolver *solver);
static avtStreamline* MergeStreamlineSequence(std::vector<avtStreamline *> &v);
// Could be static ... only virtual to get to the right method.
// (Temporary solution until we build a communicator class.)
virtual avtStreamline*
MergeIntegralCurveSequence(
std::vector<avtStreamline *> &v) {;};
static bool IdSeqCompare(const avtStreamline *slA,
const avtStreamline *slB);
static bool IdRevSeqCompare(const avtStreamline *slA,
......@@ -248,8 +226,6 @@ class IVP_API avtStreamline
static bool DomainCompare(const avtStreamline *slA,
const avtStreamline *slB);
int GetVariableIdx(const std::string &var) const;
protected:
avtStreamline( const avtStreamline& );
avtStreamline& operator=( const avtStreamline& );
......@@ -258,47 +234,39 @@ class IVP_API avtStreamline
const avtIVPField* field,
avtIVPSolver::TerminateType termType,
double end);
virtual void AnalyzeStep(avtIVPStep *step,
const avtIVPField* field,
avtIVPSolver::TerminateType termType,
double end, avtIVPSolver::Result *result) = 0;
void HandleGhostZones(bool forward, double *extents);
void HandleIntersections(avtIVPStep *step,
avtIVPSolver::TerminateType termType,
double end,
avtIVPSolver::Result *result);
bool IntersectPlane(const avtVector &p0, const avtVector &p1);
public:
// Integration steps.
std::vector<avtIVPStep*> _steps;
double termination;
avtIVPSolver::TerminateType terminationType;
bool terminated;
unsigned long serializeFlags;
// needed for ghost cells
avtIVPStep lastStep;
bool lastStepValid;
// Helpers needed for computing figuring out which domain to use next
// Helpers needed for figuring out which domain to use next
std::vector<DomainType> seedPtDomainList;
DomainType domain;
Status status;
long id, sequenceCnt;
long long sortKey;
unsigned long serializeFlags;
protected:
long sequenceCnt;
long long sortKey;
// Intersection points.
bool intersectionsSet;
int numIntersections;
double intersectPlaneEq[4];
long id;
ScalarValueType scalarValueType;
protected:
// Solver.
avtIVPSolver* _ivpSolver;
static const double minH;
public:
std::vector<std::string> scalars;
};
inline std::ostream& operator<<( std::ostream& out, const avtStreamline::Result &res )
......
......@@ -41,26 +41,27 @@
// ************************************************************************* //
#include <avtPoincareFilter.h>
#include <avtSLAlgorithm.h>
#include <avtStreamline.h>
#include <vtkAppendPolyData.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkCleanPolyData.h>
#include <vtkDataSet.h>
#include <vtkSlicer.h>
#include <vtkFloatArray.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkTubeFilter.h>
#include <vtkPolyLine.h>
#include <vtkQuad.h>
#include <vtkSlicer.h>
#include <vtkSphereSource.h>
#include <vtkTubeFilter.h>
#include <vtkUnstructuredGrid.h>
#include <vtkCleanPolyData.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkPointData.h>
#include <vtkAppendPolyData.h>
#include <vtkSphereSource.h>
#include <vtkFloatArray.h>
#include <avtDatasetExaminer.h>
#include <avtExtents.h>
#include <avtSLAlgorithm.h>
#include <avtStateRecorderIntegralCurve.h>
#include <avtStreamline.h>
#include <utility>
......@@ -263,8 +264,11 @@ avtPoincareFilter::PostExecute(void)
// ****************************************************************************
void
avtPoincareFilter::CreateStreamlineOutput(vector<avtStreamline *> &sls)
avtPoincareFilter::CreateStreamlineOutput(vector<avtStreamline *> &sls2)
{
vector<avtStateRecorderIntegralCurve *> sls;
for (int k = 0 ; k < sls2.size() ; k++)
sls.push_back((avtStateRecorderIntegralCurve *) sls2[k]);
streamlines.resize(sls.size());
for ( int i=0; i<sls.size(); ++i )
......@@ -274,7 +278,7 @@ avtPoincareFilter::CreateStreamlineOutput(vector<avtStreamline *> &sls)
unsigned int j = sls[i]->id;
streamlines[j].sl = sls[i];
avtStreamline::iterator siter = sls[i]->begin();
avtStateRecorderIntegralCurve::iterator siter = sls[i]->begin();
streamlines[j].streamlinePts.resize(0);
while (siter != sls[i]->end())
......
......@@ -43,9 +43,12 @@
#ifndef AVT_Poincare_FILTER_H
#define AVT_Poincare_FILTER_H
#include <avtStreamlineFilter.h>
class avtStateRecorderIntegralCurve;
// ****************************************************************************
// Class: avtPoincareFilter
//
......@@ -195,7 +198,7 @@ class avtPoincareFilter : public avtStreamlineFilter
public:
SLHelper() {}
~SLHelper() {}
avtStreamline *sl;
avtStateRecorderIntegralCurve *sl;
std::vector<avtVector> streamlinePts;
};
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment