v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

/*=========================================================================


  Program:   Visualization Toolkit

  Module:    vtkParticleTracerBase.h


  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen

  All rights reserved.

  See Copyright.txt or http://www.kitware.com/Copyright.htm 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.


=========================================================================*/

#ifndef vtkParticleTracerBase_h

#define vtkParticleTracerBase_h


#include "vtkFiltersFlowPathsModule.h" // For export macro

#include "vtkSmartPointer.h" // For protected ivars.

#include "vtkPolyDataAlgorithm.h"

//BTX

#include <vector> // STL Header

#include <list>   // STL Header

//ETX


class vtkAbstractInterpolatedVelocityField;

class vtkAbstractParticleWriter;

class vtkCellArray;

class vtkCharArray;

class vtkCompositeDataSet;

class vtkDataArray;

class vtkDataSet;

class vtkDoubleArray;

class vtkFloatArray;

class vtkGenericCell;

class vtkInitialValueProblemSolver;

class vtkIntArray;

class vtkMultiBlockDataSet;

class vtkMultiProcessController;

class vtkPointData;

class vtkPoints;

class vtkPolyData;

class vtkTemporalInterpolatedVelocityField;


//BTX

namespace vtkParticleTracerBaseNamespace

{

  typedef struct { double x[4]; } Position;

  typedef struct {

    // These are used during iteration

    Position      CurrentPosition;

    int           CachedDataSetId[2];

    vtkIdType     CachedCellId[2];

    int           LocationState;

    // These are computed scalars we might display

    int           SourceID;

    int           TimeStepAge;

    int           InjectedPointId;

    int           InjectedStepId;

    int           UniqueParticleId;

    double        SimulationTime;

    // These are useful to track for debugging etc

    int           ErrorCode;

    float         age;

    // these are needed across time steps to compute vorticity

    float         rotation;

    float         angularVel;

    float         time;

    float         speed;

    // once the partice is added, PointId is valid and is the tuple location

    // in ProtoPD.

    vtkIdType     PointId;

    // if PointId is negative then in parallel this particle was just

    // received and we need to get the tuple value from vtkPParticleTracerBase::Tail.

    vtkIdType     TailPointId;

  } ParticleInformation;


  typedef std::vector<ParticleInformation>  ParticleVector;

  typedef ParticleVector::iterator             ParticleIterator;

  typedef std::list<ParticleInformation>    ParticleDataList;

  typedef ParticleDataList::iterator           ParticleListIterator;

};

//ETX


class VTKFILTERSFLOWPATHS_EXPORT vtkParticleTracerBase : public vtkPolyDataAlgorithm

{

public:

  enum Solvers

  {

    RUNGE_KUTTA2,

    RUNGE_KUTTA4,

    RUNGE_KUTTA45,

    NONE,

    UNKNOWN

  };


  vtkTypeMacro(vtkParticleTracerBase,vtkPolyDataAlgorithm)

  void PrintSelf(ostream& os, vtkIndent indent);

  void PrintParticleHistories();


  vtkGetMacro(ComputeVorticity, bool);

  void SetComputeVorticity(bool);


  vtkGetMacro(TerminalSpeed, double);

  void SetTerminalSpeed(double);


  vtkGetMacro(RotationScale, double);

  void SetRotationScale(double);


  vtkSetMacro(IgnorePipelineTime, int);

  vtkGetMacro(IgnorePipelineTime, int);

  vtkBooleanMacro(IgnorePipelineTime, int);


  vtkGetMacro(ForceReinjectionEveryNSteps,int);

  void SetForceReinjectionEveryNSteps(int);


  void SetTerminationTime(double t);

  vtkGetMacro(TerminationTime,double);


  void SetIntegrator(vtkInitialValueProblemSolver *);

  vtkGetObjectMacro ( Integrator, vtkInitialValueProblemSolver );


  void SetIntegratorType(int type);

  int GetIntegratorType();


  vtkGetMacro(StartTime, double);

  void SetStartTime(double t);


  vtkSetMacro(StaticSeeds,int);

  vtkGetMacro(StaticSeeds,int);


  vtkSetMacro(StaticMesh,int);

  vtkGetMacro(StaticMesh,int);


  virtual void SetParticleWriter(vtkAbstractParticleWriter *pw);

  vtkGetObjectMacro(ParticleWriter, vtkAbstractParticleWriter);


  vtkSetStringMacro(ParticleFileName);

  vtkGetStringMacro(ParticleFileName);


  vtkSetMacro(EnableParticleWriting,int);

  vtkGetMacro(EnableParticleWriting,int);

  vtkBooleanMacro(EnableParticleWriting,int);


  vtkSetMacro(DisableResetCache,int);

  vtkGetMacro(DisableResetCache,int);

  vtkBooleanMacro(DisableResetCache,int);


  void AddSourceConnection(vtkAlgorithmOutput* input);

  void RemoveAllSources();


 protected:

  vtkSmartPointer<vtkPolyData> Output; //managed by child classes


  vtkSmartPointer<vtkPointData> ProtoPD;

  vtkIdType UniqueIdCounter;// global Id counter used to give particles a stamp

  vtkParticleTracerBaseNamespace::ParticleDataList  ParticleHistories;

  vtkSmartPointer<vtkPointData>     ParticlePointData; //the current particle point data consistent

                                                       //with particle history

  //Everything related to time

  int IgnorePipelineTime; //whether to use the pipeline time for termination

  int DisableResetCache; //whether to enable ResetCache() method


  vtkParticleTracerBase();

  virtual ~vtkParticleTracerBase();


  //

  // Make sure the pipeline knows what type we expect as input

  //

  virtual int FillInputPortInformation(int port, vtkInformation* info);


  //

  // The usual suspects

  //

  virtual int ProcessRequest(vtkInformation* request,

                             vtkInformationVector** inputVector,

                             vtkInformationVector* outputVector);


  //

  // Store any information we need in the output and fetch what we can

  // from the input

  //

  virtual int RequestInformation(vtkInformation* request,

                                 vtkInformationVector** inputVector,

                                 vtkInformationVector* outputVector);


  //

  // Compute input time steps given the output step

  //

  virtual int RequestUpdateExtent(vtkInformation* request,

                                  vtkInformationVector** inputVector,

                                  vtkInformationVector* outputVector);


  //

  // what the pipeline calls for each time step

  //

  virtual int RequestData(vtkInformation* request,

                          vtkInformationVector** inputVector,

                          vtkInformationVector* outputVector);


  //

  // these routines are internally called to actually generate the output

  //

  virtual int ProcessInput(vtkInformationVector** inputVector);


  // This is the main part of the algorithm:

  //  * move all the particles one step

  //  * Reinject particles (by adding them to this->ParticleHistories)

  //    either at the beginning or at the end of each step (modulo this->ForceReinjectionEveryNSteps)

  //  * Output a polydata representing the moved particles

  // Note that if the starting and the ending time coincide, the polydata is still valid.

  virtual vtkPolyData* Execute(vtkInformationVector** inputVector);


  // the RequestData will call these methods in turn

  virtual void Initialize(){} //the first iteration

  virtual int OutputParticles(vtkPolyData* poly)=0; //every iteration

  virtual void Finalize(){} //the last iteration


  //

  // Initialization of input (vector-field) geometry

  //

  int InitializeInterpolator();

  int UpdateDataCache(vtkDataObject *td);


  void TestParticles(

    vtkParticleTracerBaseNamespace::ParticleVector &candidates,

    vtkParticleTracerBaseNamespace::ParticleVector &passed,

    int &count);


  void TestParticles(

    vtkParticleTracerBaseNamespace::ParticleVector &candidates, std::vector<int> &passed);


  virtual void AssignSeedsToProcessors(double time,

    vtkDataSet *source, int sourceID, int ptId,

    vtkParticleTracerBaseNamespace::ParticleVector &localSeedPoints,

    int &localAssignedCount);


  virtual void AssignUniqueIds(

    vtkParticleTracerBaseNamespace::ParticleVector &localSeedPoints);


  void UpdateParticleList(

    vtkParticleTracerBaseNamespace::ParticleVector &candidates);


  virtual bool UpdateParticleListFromOtherProcesses(){return false;}


  void IntegrateParticle(

    vtkParticleTracerBaseNamespace::ParticleListIterator &it,

    double currenttime, double terminationtime,

    vtkInitialValueProblemSolver* integrator);


  // if the particle is added to send list, then returns value is 1,

  // if it is kept on this process after a retry return value is 0

  virtual bool SendParticleToAnotherProcess(

    vtkParticleTracerBaseNamespace::ParticleInformation &,

    vtkParticleTracerBaseNamespace::ParticleInformation &, vtkPointData*)

  {

    return true;

  }


  bool ComputeDomainExitLocation(

    double pos[4], double p2[4], double intersection[4],

    vtkGenericCell *cell);


  //

  // Scalar arrays that are generated as each particle is updated

  //

  void CreateProtoPD(vtkDataObject* input);


  vtkFloatArray*    GetParticleAge(vtkPointData*);

  vtkIntArray*      GetParticleIds(vtkPointData*);

  vtkCharArray*     GetParticleSourceIds(vtkPointData*);

  vtkIntArray*      GetInjectedPointIds(vtkPointData*);

  vtkIntArray*      GetInjectedStepIds(vtkPointData*);

  vtkIntArray*      GetErrorCodeArr(vtkPointData*);

  vtkFloatArray*    GetParticleVorticity(vtkPointData*);

  vtkFloatArray*    GetParticleRotation(vtkPointData*);

  vtkFloatArray*    GetParticleAngularVel(vtkPointData*);


  // utility function we use to test if a point is inside any of our local datasets

  bool InsideBounds(double point[]);


  void CalculateVorticity( vtkGenericCell* cell, double pcoords[3],

                           vtkDoubleArray* cellVectors, double vorticity[3] );


  //------------------------------------------------------


  double GetCacheDataTime(int i);

  double GetCacheDataTime();


  virtual void ResetCache();

  void AddParticle(vtkParticleTracerBaseNamespace::ParticleInformation &info, double* velocity);


  virtual bool IsPointDataValid(vtkDataObject* input);

  bool IsPointDataValid(vtkCompositeDataSet* input, std::vector<std::string>& arrayNames);

  void GetPointDataArrayNames(vtkDataSet* input, std::vector<std::string>& names);


  vtkGetMacro(ReinjectionCounter, int);

  vtkGetMacro(CurrentTimeValue, double);


  virtual void InitializeExtraPointDataArrays(vtkPointData* vtkNotUsed(outputPD)) {}


  virtual void AppendToExtraPointDataArrays(vtkParticleTracerBaseNamespace::ParticleInformation &) {}


  vtkTemporalInterpolatedVelocityField* GetInterpolator();

private:

  void SetInterpolatorPrototype(vtkAbstractInterpolatedVelocityField*) {}


  bool RetryWithPush(

    vtkParticleTracerBaseNamespace::ParticleInformation &info, double* point1,double delT, int subSteps);


  bool SetTerminationTimeNoModify(double t);


  //Parameters of tracing

  vtkInitialValueProblemSolver* Integrator;

  double IntegrationStep;

  double MaximumError;

  bool ComputeVorticity;

  double RotationScale;

  double TerminalSpeed;


  // A counter to keep track of how many times we reinjected

  int ReinjectionCounter;


  // Important for Caching of Cells/Ids/Weights etc

  int           AllFixedGeometry;

  int           StaticMesh;

  int           StaticSeeds;


  std::vector<double>  InputTimeValues;

  double StartTime;

  double TerminationTime;

  double CurrentTimeValue;


  int  StartTimeStep; //InputTimeValues[StartTimeStep] <= StartTime <= InputTimeValues[StartTimeStep+1]

  int  CurrentTimeStep;

  int  TerminationTimeStep; //computed from start time

  bool FirstIteration;


  //Innjection parameters

  int           ForceReinjectionEveryNSteps;

  vtkTimeStamp  ParticleInjectionTime;

  bool          HasCache;


  // Particle writing to disk

  vtkAbstractParticleWriter *ParticleWriter;

  char                      *ParticleFileName;

  int                        EnableParticleWriting;


  // The main lists which are held during operation- between time step updates

  vtkParticleTracerBaseNamespace::ParticleVector    LocalSeeds;


  // The velocity interpolator

  vtkSmartPointer<vtkTemporalInterpolatedVelocityField>  Interpolator;

  vtkAbstractInterpolatedVelocityField * InterpolatorPrototype;


  // Data for time step CurrentTimeStep-1 and CurrentTimeStep

  vtkSmartPointer<vtkMultiBlockDataSet> CachedData[2];


  // Cache bounds info for each dataset we will use repeatedly

  typedef struct {

    double b[6];

  } bounds;

  std::vector<bounds> CachedBounds[2];


  // temporary variables used by Exeucte(), for convenience only


  vtkSmartPointer<vtkPoints> OutputCoordinates;

  vtkSmartPointer<vtkFloatArray>    ParticleAge;

  vtkSmartPointer<vtkIntArray>      ParticleIds;

  vtkSmartPointer<vtkCharArray>     ParticleSourceIds;

  vtkSmartPointer<vtkIntArray>      InjectedPointIds;

  vtkSmartPointer<vtkIntArray>      InjectedStepIds;

  vtkSmartPointer<vtkIntArray>      ErrorCode;

  vtkSmartPointer<vtkFloatArray>    ParticleVorticity;

  vtkSmartPointer<vtkFloatArray>    ParticleRotation;

  vtkSmartPointer<vtkFloatArray>    ParticleAngularVel;

  vtkSmartPointer<vtkDoubleArray>   CellVectors;

  vtkSmartPointer<vtkPointData>     OutputPointData;

  vtkSmartPointer<vtkDataSet>       DataReferenceT[2];

  vtkSmartPointer<vtkCellArray>     ParticleCells;


  vtkParticleTracerBase(const vtkParticleTracerBase&);  // Not implemented.

  void operator=(const vtkParticleTracerBase&);  // Not implemented.

  vtkTimeStamp ExecuteTime;


  unsigned int NumberOfParticles();


  friend class ParticlePathFilterInternal;

  friend class StreaklineFilterInternal;


  static const double Epsilon;


};


#endif