Commit b0b20831 authored by pugmire's avatar pugmire

Removed the moulton corrector from the AdamsBashforth solver in IVP.

Enabled the AdamsBashforth solver to terminate based on number of steps.
Added Hank's initial changes to getting pathline creation to work.




git-svn-id: http://visit.ilight.com/svn/visit/trunk/src@6385 18c085ea-50e0-402c-830e-de6fd14e8384
parent 5596f236
......@@ -73,11 +73,15 @@ Consider the leaveDomains SLs and the balancing at the same time.
#include <vtkVisItCellLocator.h>
#include <avtCallback.h>
#include <avtDatabase.h>
#include <avtDatabaseMetaData.h>
#include <avtDataset.h>
#include <avtDataTree.h>
#include <avtDatasetExaminer.h>
#include <avtExtents.h>
#include <avtIVPVTKField.h>
#include <avtIVPVTKTimeVaryingField.h>
#include <avtIVPDopri5.h>
#include <avtIVPAdamsBashforth.h>
#include <avtIntervalTree.h>
......@@ -89,10 +93,13 @@ Consider the leaveDomains SLs and the balancing at the same time.
#include <DebugStream.h>
#include <MemStream.h>
#include <TimingsManager.h>
#include <InvalidFilesException.h>
#include <Expression.h>
#include <ExpressionList.h>
#include <ParsingExprList.h>
#include <snprintf.h>
#ifdef PARALLEL
#include <time.h> // needed for nanosleep
#include <mpi.h>
......@@ -139,11 +146,15 @@ Consider the leaveDomains SLs and the balancing at the same time.
//
// Dave Pugmire, Mon Feb 23 13:38:49 EST 2009
// Initialize the initial domain load count and timer.
//
//
// Dave Pugmire (on behalf of Hank Childs), Tue Feb 24 09:39:17 EST 2009
// Initial implemenation of pathlines.
//
// ****************************************************************************
avtStreamlineFilter::avtStreamlineFilter()
{
doPathlines = false;
normalizedVecExprName = "";
maxStepLength = 0.;
terminationType = avtIVPSolver::TIME;
......@@ -1095,7 +1106,7 @@ avtStreamlineFilter::Initialize()
ds->Register(NULL);
dataSets[ ds_list.domains[i] ] = ds;
}
InitialDomLoads = ds_list.domains.size();
InitialDomLoads = ds_list.domains.size();
}
#ifdef PARALLEL
......@@ -1328,7 +1339,10 @@ avtStreamlineFilter::DomainToRank(int domain)
// Remove accurate distance calculate option.
//
// Dave Pugmire, Mon Feb 23, 09:11:34 EST 2009
// Added termination by number of steps. Cleanup of other term types.
// Added termination by number of steps. Cleanup of other term types.
//
// Dave Pugmire (on behalf of Hank Childs), Tue Feb 24 09:39:17 EST 2009
// Initial implemenation of pathlines.
//
// ****************************************************************************
......@@ -1345,24 +1359,75 @@ avtStreamlineFilter::IntegrateDomain(avtStreamlineWrapper *slSeg,
<<slSeg->domain<<") HGZ = "<<haveGhostZones <<endl;
// prepare streamline integration ingredients
vtkInterpolatedVelocityField* velocity=vtkInterpolatedVelocityField::New();
vtkInterpolatedVelocityField* velocity1=vtkInterpolatedVelocityField::New();
if (doPathlines)
{
// Our expression will be the active variable, so reset it.
if (ds->GetPointData()->GetArray(velocityName.c_str()) != NULL)
ds->GetPointData()->SetActiveVectors(velocityName.c_str());
if (ds->GetCellData()->GetArray(velocityName.c_str()) != NULL)
ds->GetCellData()->SetActiveVectors(velocityName.c_str());
}
// See if we have cell cenetered data...
vtkCellDataToPointData *cellToPt = NULL;
vtkCellDataToPointData *cellToPt1 = NULL;
if (ds->GetPointData()->GetVectors() == NULL)
{
cellToPt = vtkCellDataToPointData::New();
cellToPt1 = vtkCellDataToPointData::New();
cellToPt->SetInput(ds);
cellToPt->Update();
velocity->AddDataSet(cellToPt->GetOutput());
cellToPt1->SetInput(ds);
cellToPt1->Update();
velocity1->AddDataSet(cellToPt1->GetOutput());
}
else
velocity->AddDataSet(ds);
velocity->CachingOn();
avtIVPVTKField field(velocity);
velocity1->AddDataSet(ds);
velocity1->CachingOn();
vtkInterpolatedVelocityField* velocity2=NULL;
vtkDataSet *ds2 = NULL;
vtkCellDataToPointData *cellToPt2 = NULL;
double t1, t2;
if (doPathlines)
{
velocity2 = vtkInterpolatedVelocityField::New();
ds2 = (vtkDataSet *) ds->NewInstance();
ds2->ShallowCopy(ds);
if (ds2->GetPointData()->GetVectors() != NULL)
ds2->GetPointData()->SetActiveVectors("_pathline_vecs");
else
ds2->GetCellData()->SetActiveVectors("_pathline_vecs");
// See if we have cell cenetered data...
if (ds2->GetPointData()->GetVectors() == NULL)
{
cellToPt2 = vtkCellDataToPointData::New();
cellToPt2->SetInput(ds2);
cellToPt2->Update();
velocity2->AddDataSet(cellToPt2->GetOutput());
}
else
velocity2->AddDataSet(ds2);
velocity2->CachingOn();
std::string db = GetInput()->GetInfo().GetAttributes().GetFullDBName();
ref_ptr<avtDatabase> dbp = avtCallback::GetDatabase(db, 0, NULL);
if (*dbp == NULL)
EXCEPTION1(InvalidFilesException, db.c_str());
avtDatabaseMetaData *md = dbp->GetMetaData(curTimeSlice, false,
false, false);
t1 = md->GetTimes()[curTimeSlice];
t2 = md->GetTimes()[curTimeSlice+1];
}
avtIVPField *field = NULL;
if (doPathlines)
field = new avtIVPVTKTimeVaryingField(velocity1, velocity2, t1, t2);
else
field = new avtIVPVTKField(velocity1);
double end = termination;
if (slSeg->dir == avtStreamlineWrapper::BWD)
end = - end;
......@@ -1370,7 +1435,7 @@ avtStreamlineFilter::IntegrateDomain(avtStreamlineWrapper *slSeg,
//slSeg->Debug();
bool doVorticity = ((coloringMethod == STREAMLINE_COLOR_VORTICITY)
|| (displayMethod == STREAMLINE_DISPLAY_RIBBONS));
avtIVPSolver::Result result = slSeg->sl->Advance(&field,
avtIVPSolver::Result result = slSeg->sl->Advance(field,
terminationType,
end,
doVorticity,
......@@ -1400,10 +1465,14 @@ avtStreamlineFilter::IntegrateDomain(avtStreamlineWrapper *slSeg,
else
slSeg->status = avtStreamlineWrapper::TERMINATE;
velocity->Delete();
if (cellToPt)
cellToPt->Delete();
velocity1->Delete();
if (velocity2)
velocity2->Delete();
if (cellToPt1)
cellToPt1->Delete();
if (cellToPt2)
cellToPt2->Delete();
debug5<<"::IntegrateDomain() result= "<<result<<endl;
return result;
}
......@@ -2012,6 +2081,9 @@ avtStreamlineFilter::StartSphere(float val, double pt[3])
// Dave Pugmire, Tue Aug 19 17:13:04EST 2008
// Remove accurate distance calculate option.
//
// Dave Pugmire (on behalf of Hank Childs), Tue Feb 24 09:39:17 EST 2009
// Initial implemenation of pathlines.
//
// ****************************************************************************
avtContract_p
......@@ -2020,13 +2092,15 @@ avtStreamlineFilter::ModifyContract(avtContract_p in_contract)
avtDataRequest_p in_dr = in_contract->GetDataRequest();
avtDataRequest_p out_dr = NULL;
if (strcmp(in_dr->GetVariable(), "colorVar") == 0)
if (strcmp(in_dr->GetVariable(), "colorVar") == 0 || doPathlines)
{
// The avtStreamlinePlot requested "colorVar", so remove that from the
// contract now.
out_dr = new avtDataRequest(in_dr,in_dr->GetOriginalVariable());
}
if (doPathlines)
out_dr->AddSecondaryVariable("_pathline_vecs");
avtContract_p out_contract;
if ( *out_dr )
out_contract = new avtContract(in_contract, out_dr);
......@@ -2036,5 +2110,32 @@ avtStreamlineFilter::ModifyContract(avtContract_p in_contract)
//out_contract->GetDataRequest()->SetDesiredGhostDataType(NO_GHOST_DATA);
out_contract->GetDataRequest()->SetDesiredGhostDataType(GHOST_ZONE_DATA);
if (doPathlines)
{
bool needExpr = true;
ExpressionList *elist = ParsingExprList::Instance()->GetList();
for (int i = 0 ; i < elist->GetNumExpressions() ; i++)
{
if (elist->GetExpressions(i).GetName() == "_pathline_vecs")
needExpr = false;
}
if (needExpr)
{
velocityName = out_dr->GetVariable(); // HANK: ASSUMPTION
std::string meshname = out_dr->GetVariable(); // Can reuse varname here.
Expression *e = new Expression();
e->SetName("_pathline_vecs");
char defn[1024];
SNPRINTF(defn, 1024, "conn_cmfe(<[1]id:%s>, %s)", velocityName.c_str(), meshname.c_str());
e->SetDefinition(defn);
e->SetType(Expression::VectorMeshVar);
elist->AddExpressions(*e);
delete e;
}
curTimeSlice = out_dr->GetTimestep();
}
return avtDatasetOnDemandFilter::ModifyContract(out_contract);
}
......@@ -155,6 +155,9 @@ class avtStreamlineWrapper;
// Dave Pugmire, Mon Feb 23 13:40:28 EST 2009
// Initial IO time and domain load counter.
//
// Dave Pugmire (on behalf of Hank Childs), Tue Feb 24 09:39:17 EST 2009
// Initial implemenation of pathlines.
//
// ****************************************************************************
class AVTFILTERS_API avtStreamlineFilter : public avtDatasetOnDemandFilter
......@@ -208,6 +211,9 @@ class AVTFILTERS_API avtStreamlineFilter : public avtDatasetOnDemandFilter
int coloringMethod;
int dataSpatialDimension;
std::string normalizedVecExprName;
int curTimeSlice;
std::string velocityName;
bool doPathlines;
avtIntervalTree *intervalTree;
avtIVPSolver *solver;
......
......@@ -34,6 +34,9 @@
#
# Modifications:
#
# Dave Pugmire, Tue Feb 24 09:24:49 EST 2009
# Added avtIVPVTKTimeVaryingField.C
#
##############################################################################
##
......@@ -47,7 +50,7 @@
##
## Files...
##
SRC=avtIVPDopri5.C avtIVPSolver.C avtIVPVTKField.C avtStreamline.C MemStream.C avtIVPAdamsBashforth.C
SRC=avtIVPDopri5.C avtIVPSolver.C avtIVPVTKField.C avtIVPVTKTimeVaryingField.C avtStreamline.C MemStream.C avtIVPAdamsBashforth.C
CPPFLAGS=@COMPONENT_CPPFLAGS@ @CPPFLAGS@
......
This diff is collapsed.
......@@ -71,6 +71,9 @@
// Reworked the termination code. Added a type enum and value. Made num steps
// a termination criterion.
//
// Dave Pugmire, Tue Feb 24 10:49:33 EST 2009
// Replaced Euler step with RK4 step. Removed the Moulton corrector.
//
// ****************************************************************************
class IVP_API avtIVPAdamsBashforth: public avtIVPSolver
......@@ -86,7 +89,7 @@ class IVP_API avtIVPAdamsBashforth: public avtIVPSolver
// adaptive stepsize control retries until success or underflow
virtual Result Step(const avtIVPField* field,
const TerminateType &type,
const double &end,
const double &end,
avtIVPStep* ivpstep = NULL);
virtual void OnExitDomain();
......@@ -111,29 +114,10 @@ class IVP_API avtIVPAdamsBashforth: public avtIVPSolver
virtual void AcceptStateVisitor(avtIVPStateHelper &aiss);
void UpdateHistory( const avtVec &yNew );
avtIVPSolver::Result EulerStep(const avtIVPField* field,
avtVec &yNew);
avtIVPSolver::Result RK4Step(const avtIVPField* field,
avtVec &yNew);
avtIVPSolver::Result ABStep(const avtIVPField* field,
avtVec &yNew);
int AdamsMoulton4Steps(const avtIVPField* field,
avtVec x,
double t,
double h,
double tolerance,
int iterations);
avtVec AdamsBashforth5Steps(avtVec &y,
double h );
int Adams5Steps(const avtIVPField* field,
avtVec x0,
double t,
double h,
avtVec *y_bashforth,
double tolerance,
int iterations );
bool HasConverged( avtVec &y0,
avtVec &y1,
double epsilon );
private:
int numStep;
......@@ -145,6 +129,7 @@ class IVP_API avtIVPAdamsBashforth: public avtIVPSolver
avtVecArray history;
avtVec yCur;
avtVec ys[2];
int initialized;
};
#endif
/*****************************************************************************
*
* Copyright (c) 2000 - 2008, Lawrence Livermore National Security, LLC
* Produced at the Lawrence Livermore National Laboratory
* LLNL-CODE-400142
* 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.
*
*****************************************************************************/
// ************************************************************************* //
// avtIVPVTKTimeVaryingField.C //
// ************************************************************************* //
#include <avtIVPVTKTimeVaryingField.h>
#include <iostream>
#include <vtkCell.h>
#include <vtkDataSet.h>
#include <vtkInterpolatedVelocityField.h>
#include <vtkDoubleArray.h>
#include <vtkPointData.h>
// ****************************************************************************
// Method: avtIVPVTKTimeVaryingField constructor
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// ****************************************************************************
avtIVPVTKTimeVaryingField::avtIVPVTKTimeVaryingField( vtkInterpolatedVelocityField* velocity1,
vtkInterpolatedVelocityField *velocity2, double t1, double t2)
{
iv1 = velocity1;
iv1->Register( NULL );
iv2 = velocity2;
iv2->Register( NULL );
time1 = t1;
time2 = t2;
normalized = false;
}
// ****************************************************************************
// Method: avtIVPVTKTimeVaryingField destructor
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// ****************************************************************************
avtIVPVTKTimeVaryingField::~avtIVPVTKTimeVaryingField()
{
iv1->Delete();
iv2->Delete();
}
// ****************************************************************************
// Method: avtIVPVTKTimeVaryingField::operator
//
// Purpose:
// Evaluates a point location by consulting a VTK grid.
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// ****************************************************************************
avtVec
avtIVPVTKTimeVaryingField::operator()(const double& t, const avtVecRef& x) const
{
avtVec y1( x.dim() ), param( pad(x,t));
avtVec y2( x.dim() );
int result = iv1->FunctionValues( param.values(), y1.values() );
if( !result )
throw Undefined();
iv2->FunctionValues( param.values(), y2.values() );
cerr << "Times = " << time1 << ", " << time2 << endl;
cerr <<"Y1 = " << y1 << endl;
cerr <<"Y2 = " << y2 << endl;
double prop1 = 1. - (t - time1) / (time2 - time1);
avtVec y( x.dim() );
y = prop1*y1 + (1-prop1)*y2;
cerr << "Y = " << y << endl;
if ( normalized )
{
double len = y.length();
if ( len > 0.0 )
y /= len;
}
return y;
}
// ****************************************************************************
// Method: avtIVPVTKTimeVaryingField::ComputeVorticity
//
// Purpose:
// Computes the vorticity at a point.
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// Modifications:
//
// ****************************************************************************
double
avtIVPVTKTimeVaryingField::ComputeVorticity( const double& t, const avtVecRef& x ) const
{
EXCEPTION0(ImproperUseException); // didn't do this.
avtVec y( x.dim() );
avtVec param = pad(x,t);
int result = iv1->FunctionValues( param.values(), y.values() );
if( !result )
throw Undefined();
vtkDataSet *ds = iv1->GetLastDataSet();
vtkIdType cellID = iv1->GetLastCellId();
vtkCell *cell = ds->GetCell( cellID );
vtkDoubleArray *cellVectors;
cellVectors = vtkDoubleArray::New();
cellVectors->SetNumberOfComponents(3);
cellVectors->Allocate(3*VTK_CELL_SIZE);
vtkPointData *pd = ds->GetPointData();
vtkDataArray *inVectors = pd->GetVectors();
double derivs[9];
inVectors->GetTuples( cell->PointIds, cellVectors );
double *cellVel = cellVectors->GetPointer(0);
double pcoords[3], w[100];
iv1->GetLastWeights( w );
iv1->GetLastLocalCoordinates( pcoords );
cell->Derivatives( 0, pcoords, cellVel, 3, derivs);
//cout<<"pcoords= "<<pcoords[0]<<" "<<pcoords[1]<<" "<<pcoords[2]<<endl;
cellVectors->Delete();
double vort[3];
vort[0] = derivs[7] - derivs[5];
vort[1] = derivs[2] - derivs[6];
vort[2] = derivs[3] - derivs[1];
//cout<<"id= "<<cellID<<" p= "<<x<<" ";
//cout<<"y= "<<y<<" ";
//cout<<" vort["<<vort[0]<<" "<<vort[1]<<" "<<vort[2]<<"] ";
double omega = 0.0;
double len = y.length();
if ( len > 0.0 )
omega = (
vort[0] * y.values()[0] + vort[1] * y.values()[1]
+ vort[2] * y.values()[2]
) / len;
//cout<<"omega= "<<omega<<endl;
return omega;
}
// ****************************************************************************
// Method: avtIVPVTKTimeVaryingField::IsInsider
//
// Purpose:
// Determines if a point is inside a field.
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// ****************************************************************************
bool
avtIVPVTKTimeVaryingField::IsInside( const double& t, const avtVecRef& x ) const
{
avtVec y( x.dim() );
return iv1->FunctionValues( pad( x, t ).values(), y.values() );
}
// ****************************************************************************
// Method: avtIVPVTKTimeVaryingField::GetDimension
//
// Purpose:
// Gets the dimension.
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// ****************************************************************************
unsigned int
avtIVPVTKTimeVaryingField::GetDimension() const
{
return iv1->GetNumberOfFunctions();
}
// ****************************************************************************
// Method: avtIVPVTKTimeVaryingField::SetNormalized
//
// Purpose:
// Sets field normalization.
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// ****************************************************************************
void
avtIVPVTKTimeVaryingField::SetNormalized( bool v )
{
normalized = v;
}
/*****************************************************************************
*
* Copyright (c) 2000 - 2008, Lawrence Livermore National Security, LLC
* Produced at the Lawrence Livermore National Laboratory
* LLNL-CODE-400142
* 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.
*
*****************************************************************************/
// ************************************************************************* //
// avtIVPVTKTimeVaryingField.h //
// ************************************************************************* //
#ifndef AVT_IVPVTKTimeVaryingFIELD_H
#define AVT_IVPVTKTimeVaryingFIELD_H
#include <avtIVPField.h>
#include <vtkInterpolatedVelocityField.h>
#include <ivp_exports.h>
// ****************************************************************************
// Class: avtIVPVTKTimeVaryingField
//
// Purpose:
// A wrapper class to allow the use of vtkDataSets as IVP fields for
// streamline integration. Uses vtkInterpolatedVelocityField on top of
// the supplied vtkDataSet.
//
// Programmer: Dave Pugmire (on behalf of Hank Childs)
// Creation: Tue Feb 24 09:24:49 EST 2009
//
// Modifications:
//
// ****************************************************************************
class IVP_API avtIVPVTKTimeVaryingField: public avtIVPField
{
public:
avtIVPVTKTimeVaryingField(vtkInterpolatedVelocityField *velocity1,
vtkInterpolatedVelocityField *velocity2,
double time1, double time2);
~avtIVPVTKTimeVaryingField();
// avtIVPField interface
avtVec operator()(const double& t, const avtVecRef& x) const;
double ComputeVorticity(const double& t, const avtVecRef& x) const;
bool IsInside( const double& t, const avtVecRef& x ) const;
unsigned int GetDimension() const;
void SetNormalized( bool v );
protected:
vtkInterpolatedVelocityField *iv1;
vtkInterpolatedVelocityField *iv2;
double time1;
double time2;
bool normalized;
};
#endif
../../avt/IVP/avtIVPVTKTimeVaryingField.h
\ No newline at end of file
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