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

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


  Program:   Visualization Toolkit

  Module:    vtkTemporalStreamTracer.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 vtkTemporalStreamTracer_h

#define vtkTemporalStreamTracer_h


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

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

#include "vtkStreamTracer.h"


//BTX

#include <vector> // STL Header

#include <list>   // STL Header

//ETX


class vtkMultiProcessController;


class vtkMultiBlockDataSet;

class vtkDataArray;

class vtkDoubleArray;

class vtkGenericCell;

class vtkIntArray;

class vtkTemporalInterpolatedVelocityField;

class vtkPoints;

class vtkCellArray;

class vtkDoubleArray;

class vtkFloatArray;

class vtkIntArray;

class vtkCharArray;

class vtkAbstractParticleWriter;


//BTX

namespace vtkTemporalStreamTracerNamespace

{

  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;

    // 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;

  } ParticleInformation;


  typedef std::vector<ParticleInformation>  ParticleVector;

  typedef ParticleVector::iterator             ParticleIterator;

  typedef std::list<ParticleInformation>    ParticleDataList;

  typedef ParticleDataList::iterator           ParticleListIterator;

};

//ETX


class VTKFILTERSFLOWPATHS_EXPORT vtkTemporalStreamTracer : public vtkStreamTracer

{

public:


    vtkTypeMacro(vtkTemporalStreamTracer,vtkStreamTracer);

    void PrintSelf(ostream& os, vtkIndent indent);


    static vtkTemporalStreamTracer *New();


    vtkSetMacro(TimeStep,unsigned int);

    vtkGetMacro(TimeStep,unsigned int);


    vtkSetMacro(IgnorePipelineTime, int);

    vtkGetMacro(IgnorePipelineTime, int);

    vtkBooleanMacro(IgnorePipelineTime, int);


    vtkSetMacro(TimeStepResolution,double);

    vtkGetMacro(TimeStepResolution,double);


    vtkSetMacro(ForceReinjectionEveryNSteps,int);

    vtkGetMacro(ForceReinjectionEveryNSteps,int);


//BTX

  enum Units

  {

    TERMINATION_TIME_UNIT,

    TERMINATION_STEP_UNIT

  };

//ETX


    vtkSetMacro(TerminationTime,double);

    vtkGetMacro(TerminationTime,double);


    vtkSetMacro(TerminationTimeUnit,int);

    vtkGetMacro(TerminationTimeUnit,int);

    void SetTerminationTimeUnitToTimeUnit()

    {this->SetTerminationTimeUnit(TERMINATION_TIME_UNIT);};

    void SetTerminationTimeUnitToStepUnit()

    {this->SetTerminationTimeUnit(TERMINATION_STEP_UNIT);};


    vtkSetMacro(StaticSeeds,int);

    vtkGetMacro(StaticSeeds,int);

    vtkBooleanMacro(StaticSeeds,int);


    vtkSetMacro(StaticMesh,int);

    vtkGetMacro(StaticMesh,int);

    vtkBooleanMacro(StaticMesh,int);


    virtual void SetParticleWriter(vtkAbstractParticleWriter *pw);

    vtkGetObjectMacro(ParticleWriter, vtkAbstractParticleWriter);


    vtkSetStringMacro(ParticleFileName);

    vtkGetStringMacro(ParticleFileName);


    vtkSetMacro(EnableParticleWriting,int);

    vtkGetMacro(EnableParticleWriting,int);

    vtkBooleanMacro(EnableParticleWriting,int);


    void AddSourceConnection(vtkAlgorithmOutput* input);

    void RemoveAllSources();


  protected:


     vtkTemporalStreamTracer();

    ~vtkTemporalStreamTracer();


    //

    // 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);


    virtual int GenerateOutput(vtkInformationVector** inputVector,

                               vtkInformationVector* outputVector);


    //

    // Initialization of input (vector-field) geometry

    //

    int InitializeInterpolator();

    int SetTemporalInput(vtkDataObject *td, int index);


//BTX

//


    void TestParticles(

      vtkTemporalStreamTracerNamespace::ParticleVector &candidates,

      vtkTemporalStreamTracerNamespace::ParticleVector &passed,

      int &count);


    virtual void AssignSeedsToProcessors(

      vtkDataSet *source, int sourceID, int ptId,

      vtkTemporalStreamTracerNamespace::ParticleVector &LocalSeedPoints,

      int &LocalAssignedCount);


    virtual void AssignUniqueIds(

      vtkTemporalStreamTracerNamespace::ParticleVector &LocalSeedPoints);


    void UpdateParticleList(

      vtkTemporalStreamTracerNamespace::ParticleVector &candidates);


    virtual void TransmitReceiveParticles(

      vtkTemporalStreamTracerNamespace::ParticleVector &outofdomain,

      vtkTemporalStreamTracerNamespace::ParticleVector &received,

      bool removeself);


    void IntegrateParticle(

      vtkTemporalStreamTracerNamespace::ParticleListIterator &it,

      double currenttime, double terminationtime,

      vtkInitialValueProblemSolver* integrator);


    bool RetryWithPush(

      vtkTemporalStreamTracerNamespace::ParticleInformation &info,

      double velocity[3], double delT);


    // 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

    bool SendParticleToAnotherProcess(

      vtkTemporalStreamTracerNamespace::ParticleInformation &info,

      double point1[4], double delT);


    void AddParticleToMPISendList(

      vtkTemporalStreamTracerNamespace::ParticleInformation &info);


    bool ComputeDomainExitLocation(

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

      vtkGenericCell *cell);


//

//ETX

//

    //Track internally which round of RequestData it is--between 0 and 2

    int           RequestIndex;


    // Track which process we are

    int           UpdatePiece;

    int           UpdateNumPieces;


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

    int           AllFixedGeometry;

    int           StaticMesh;

    int           StaticSeeds;


    // Support 'pipeline' time or manual SetTimeStep

    unsigned int  TimeStep;

    unsigned int  ActualTimeStep;

    int           IgnorePipelineTime;

    unsigned int  NumberOfInputTimeSteps;

//BTX

    std::vector<double>  InputTimeValues;

    std::vector<double>  OutputTimeValues;

//ETX


    // more time management

    double        EarliestTime;

    double        CurrentTimeSteps[2];

    double        TimeStepResolution;


    // Particle termination after time

    double        TerminationTime;

    int           TerminationTimeUnit;


    // Particle injection+Reinjection

    int           ForceReinjectionEveryNSteps;

    bool          ReinjectionFlag;

    int           ReinjectionCounter;

    vtkTimeStamp  ParticleInjectionTime;


    // Particle writing to disk

    vtkAbstractParticleWriter *ParticleWriter;

    char                      *ParticleFileName;

    int                        EnableParticleWriting;


//BTX

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

    unsigned int                                        NumberOfParticles;

    vtkTemporalStreamTracerNamespace::ParticleDataList  ParticleHistories;

    vtkTemporalStreamTracerNamespace::ParticleVector    LocalSeeds;

//ETX


//BTX

    //

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

    //

    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;

    int                               InterpolationCount;


    // The output geometry

    vtkSmartPointer<vtkCellArray>     ParticleCells;

    vtkSmartPointer<vtkPoints>        OutputCoordinates;


    // List used for transmitting between processors during parallel operation

    vtkTemporalStreamTracerNamespace::ParticleVector MPISendList;


    // The velocity interpolator

    vtkSmartPointer<vtkTemporalInterpolatedVelocityField>  Interpolator;


    // The input datasets which are stored by time step 0 and 1

    vtkSmartPointer<vtkMultiBlockDataSet> InputDataT[2];

    vtkSmartPointer<vtkDataSet>           DataReferenceT[2];


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

    typedef struct {

      double b[6];

    } bounds;

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


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

    bool InsideBounds(double point[]);


//ETX


  // global Id counter used to give particles a stamp

  vtkIdType UniqueIdCounter;

  vtkIdType UniqueIdCounterMPI;

  // for debugging only;

  int substeps;


private:

  void SetInterpolatorPrototype(vtkAbstractInterpolatedVelocityField*) {}


private:

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

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

};


#endif