dox/Parallel/vtkTemporalStreamTracer.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkTemporalStreamTracer.h,v $

  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 "vtkSmartPointer.h" // For protected ivars.
#include "vtkStreamTracer.h"

//BTX
#include <vtkstd/vector> // I'll remove these soon.
#include <vtkstd/list> // I'll remove these soon.
//ETX

class vtkMultiProcessController;

class vtkCompositeDataSet;
class vtkDataArray;
class vtkDoubleArray;
class vtkGenericCell;
class vtkIntArray;
class vtkTemporalInterpolatedVelocityField;
class vtkPoints;
class vtkCellArray;
class vtkDoubleArray;
class vtkFloatArray;
class vtkIntArray;
class vtkAbstractParticleWriter;

//BTX
namespace vtkTemporalStreamTracerNamespace
{
  typedef struct { double x[4]; } Position;
  typedef struct {
    // These are used during iteration
    int           Counter;
    int           Index;
    bool          Wrap;
    Position      CurrentPosition;
    int           CachedDataSet[2];
    vtkIdType     CachedCellId[2];
    // These are computed scalars we might display
    int           SourceID;
    int           InjectedPointId;      
    float         UniqueParticleId;
    // these are needed across time steps to compute vorticity
    float         rotation;
    float         angularVel;
    float         time;
  } ParticleInformation;

  typedef vtkstd::vector<ParticleInformation>  ParticleList;
  typedef vtkstd::list<ParticleInformation>    ParticleDataList;
  typedef ParticleDataList::iterator           ParticleIterator;

  class vtkTemporalStreamTracerInternals {
  public:
  };
};

//ETX

class VTK_PARALLEL_EXPORT vtkTemporalStreamTracer : public vtkStreamTracer
{
public:

    vtkTypeRevisionMacro(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);


    void SetSource2(vtkDataSet *source);
    vtkDataSet *GetSource2();

    void SetSource2Connection(vtkAlgorithmOutput* algOutput);


    vtkSetMacro(EnableSource1,int);
    vtkGetMacro(EnableSource1,int);
    vtkBooleanMacro(EnableSource1,int);
    vtkSetMacro(EnableSource2,int);
    vtkGetMacro(EnableSource2,int);
    vtkBooleanMacro(EnableSource2,int);


    virtual void SetController(vtkMultiProcessController* controller);
    vtkGetObjectMacro(Controller, vtkMultiProcessController);


    virtual void SetParticleWriter(vtkAbstractParticleWriter *pw);
    vtkGetObjectMacro(ParticleWriter, vtkAbstractParticleWriter);


    vtkSetStringMacro(ParticleFileName);
    vtkGetStringMacro(ParticleFileName);


    vtkSetMacro(EnableParticleWriting,int);
    vtkGetMacro(EnableParticleWriting,int);
    vtkBooleanMacro(EnableParticleWriting,int);

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

    //
    // Generate output
    //
    virtual int RequestData(vtkInformation* request,
                            vtkInformationVector** inputVector,
                            vtkInformationVector* outputVector);


    int InitializeInterpolator();
    int SetupInputs(vtkInformation* inInfo, vtkInformation* outInfo);

//
//BTX
//

    void InjectSeeds(vtkDataSet *source, int sourceID, int injectionID, 
      vtkTemporalStreamTracerNamespace::ParticleList *inputlist,
      vtkTemporalStreamTracerNamespace::ParticleList &candidates, vtkTemporalStreamTracerNamespace::ParticleList *outofdomain);

    void UpdateSeeds(vtkTemporalStreamTracerNamespace::ParticleList &candidates);

    void TransmitReceiveParticles(
      vtkTemporalStreamTracerNamespace::ParticleList &outofdomain, vtkTemporalStreamTracerNamespace::ParticleList &received, bool removeself);

    void IntegrateParticle(
      vtkTemporalStreamTracerNamespace::ParticleIterator &it, 
      double currenttime, double terminationtime,
      vtkInitialValueProblemSolver* integrator);

    void GenerateOutputLines(vtkPolyData *output);
    bool DoParticleSendTasks(vtkTemporalStreamTracerNamespace::ParticleInformation &info, double point1[4], double velocity[3], double delT);
    bool DoParticleSendTasks(vtkTemporalStreamTracerNamespace::ParticleInformation &info, double point1[4], double delT);
    bool ComputeDomainExitLocation(
      double pos[4], double p2[4], double intersection[4],
      vtkGenericCell *cell);
    void AddParticleToMPISendList(vtkTemporalStreamTracerNamespace::ParticleInformation &info);
//
//ETX
//

    // Mostly useful for debugging parallel operation
    int           UpdatePiece;
    int           UpdateNumPieces;

    // Turn on/off sources
    int           EnableSource1;      
    int           EnableSource2;

    // Important for Caching of Cells/Ids/Weights etc
    int           AllFixedGeometry;
    int           NoFixedGeometry;

    // internal data variables
    int           MaxCellSize;

    // Support pipeline time 
    unsigned int  TimeStep;
    unsigned int  ActualTimeStep;
    unsigned int  NumberOfInputTimeSteps;
//BTX
    vtkstd::vector<double>  InputTimeValues;
    vtkstd::vector<double>  OutputTimeValues;
//ETX

    double        EarliestTime;
    double        CurrentTimeSteps[2];
    double        TimeStepResolution;
    int           ForceReinjectionEveryNSteps;
    bool          ReinjectionFlag;  
    int           ReinjectionCounter;
    int           IgnorePipelineTime;
    //
    vtkAbstractParticleWriter *ParticleWriter;
    char                      *ParticleFileName; 
    int                        EnableParticleWriting;
    //
    vtkTimeStamp  ParticleInjectionTime;
    vtkTimeStamp  SeedInjectionTime;

//BTX
    unsigned int                                        NumberOfParticles;
    vtkTemporalStreamTracerNamespace::ParticleDataList  ParticleHistories;
//ETX

//BTX
    vtkSmartPointer<vtkPoints>        OutputCoordinates;
    vtkSmartPointer<vtkCellArray>     ParticleCells;
    //
    // Scalar arrays that are generated as each particle is updated
    //
    vtkSmartPointer<vtkIntArray>      ParticleIds;
    vtkSmartPointer<vtkIntArray>      ParticleSourceIds;
    vtkSmartPointer<vtkIntArray>      InjectedPointIds;
    vtkSmartPointer<vtkDoubleArray>   cellVectors;
    vtkSmartPointer<vtkFloatArray>    ParticleTime;
    vtkSmartPointer<vtkFloatArray>    ParticleVorticity;
    vtkSmartPointer<vtkFloatArray>    ParticleRotation;
    vtkSmartPointer<vtkFloatArray>    ParticleAngularVel;
    vtkSmartPointer<vtkPointData>     OutputPointData;
    vtkSmartPointer<vtkPointData>     OutputPointDataT1;
    vtkSmartPointer<vtkPointData>     OutputPointDataT2;
    //
    vtkTemporalStreamTracerNamespace::ParticleList MPISendList;
    //
    vtkSmartPointer<vtkTemporalInterpolatedVelocityField>  Interpolator;
    vtkCompositeDataSet                                   *InputDataT[2];
    vtkDataSet                                            *DataReferenceT[2];

    // info about each dataset we will use repeatedly
    typedef struct {
      double b[6];
    } bounds;
    vtkstd::vector<bounds> CachedBounds[2];
    vtkstd::vector<bool>   GeometryFixed[2];

    bool InsideBounds(double point[]);

    //
//ETX

  vtkMultiProcessController* Controller;
  static vtkIdType UniqueIdCounter;

private:
  void SetInterpolatorPrototype(vtkInterpolatedVelocityField*) {};

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


#endif

---