vtkLagrangianBasicIntegrationModel.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkLagrangianBasicIntegrationModel.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 vtkLagrangianBasicIntegrationModel_h
#define vtkLagrangianBasicIntegrationModel_h

#include "vtkFiltersFlowPathsModule.h" // For export macro
#include "vtkNew.h" // For arrays
#include "vtkWeakPointer.h" // For weak pointer
#include "vtkFunctionSet.h"

#include <queue> // for new particles
#include <map> // for array indexes

class vtkAbstractArray;
class vtkAbstractCellLocator;
class vtkCell;
class vtkCellData;
class vtkDataArray;
class vtkDataObject;
class vtkDataSet;
class vtkDataSetsType;
class vtkDoubleArray;
class vtkFieldData;
class vtkGenericCell;
class vtkIntArray;
class vtkLagrangianParticle;
class vtkLagrangianParticleTracker;
class vtkLocatorsType;
class vtkPointData;
class vtkPolyData;
class vtkStringArray;
class vtkSurfaceType;

class VTKFILTERSFLOWPATHS_EXPORT vtkLagrangianBasicIntegrationModel :
  public vtkFunctionSet
{
public:
  vtkTypeMacro(vtkLagrangianBasicIntegrationModel, vtkFunctionSet);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  typedef enum SurfaceType
  {
    SURFACE_TYPE_MODEL = 0,
    SURFACE_TYPE_TERM = 1,
    SURFACE_TYPE_BOUNCE = 2,
    SURFACE_TYPE_BREAK = 3,
    SURFACE_TYPE_PASS = 4
  } SurfaceType;

  typedef enum VariableStep
  {
    VARIABLE_STEP_PREV = -1,
    VARIABLE_STEP_CURRENT = 0,
    VARIABLE_STEP_NEXT = 1,
  } VariableStep;

  typedef std::pair< unsigned int, vtkLagrangianParticle*> PassThroughParticlesItem;
  typedef std::queue< PassThroughParticlesItem > PassThroughParticlesType;

  int FunctionValues(double* x, double* f) override;


  virtual void SetLocator(vtkAbstractCellLocator* locator);
  vtkGetObjectMacro(Locator, vtkAbstractCellLocator);


  vtkGetMacro(LocatorsBuilt, bool);
  vtkSetMacro(LocatorsBuilt, bool);

  virtual void SetTracker(vtkLagrangianParticleTracker* Tracker);


  virtual void AddDataSet(vtkDataSet* dataset, bool surface = false,
    unsigned int surfaceFlatIndex = 0);
  virtual void ClearDataSets(bool surface = false);


  vtkSetMacro(UseInitialIntegrationTime, bool);
  vtkGetMacro(UseInitialIntegrationTime, bool);
  vtkBooleanMacro(UseInitialIntegrationTime, bool);


  vtkSetMacro(CurrentParticle, vtkLagrangianParticle*);


  vtkGetMacro(Tolerance, double);

  virtual vtkLagrangianParticle* ComputeSurfaceInteraction(vtkLagrangianParticle* particle,
    std::queue<vtkLagrangianParticle*>& particles,
    unsigned int& interactedSurfaceFlatIndex, PassThroughParticlesType& passThroughParticles);

  virtual void SetInputArrayToProcess(int idx, int port, int connection,
    int fieldAssociation, const char* name);


  virtual bool FindInLocators(double* x, vtkDataSet*& dataset, vtkIdType& cellId,
    vtkAbstractCellLocator*& loc, double*& weights);
  virtual bool FindInLocators(double* x, vtkDataSet*& dataset, vtkIdType& cellId);
  virtual bool FindInLocators(double* x);

  virtual void InitializeVariablesParticleData(
    vtkPointData* vtkNotUsed(particleData), int vtkNotUsed(maxTuples) = 0) {}

  virtual void InsertVariablesParticleData(vtkLagrangianParticle* vtkNotUsed(particle),
    vtkPointData* vtkNotUsed(particleData), int vtkNotUsed(stepEnum)) {}

  virtual void InitializeParticle(vtkLagrangianParticle* vtkNotUsed(particle)){}

  virtual bool CheckAdaptiveStepReintegration(
    vtkLagrangianParticle* vtkNotUsed(particle)){return true;}

  virtual bool CheckFreeFlightTermination(
    vtkLagrangianParticle* vtkNotUsed(particle)){return false;}


  vtkSetMacro(NonPlanarQuadSupport, bool);
  vtkGetMacro(NonPlanarQuadSupport, bool);
  vtkBooleanMacro(NonPlanarQuadSupport, bool);

  virtual vtkStringArray* GetSeedArrayNames();

  virtual vtkIntArray* GetSeedArrayComps();

  virtual vtkIntArray* GetSeedArrayTypes();

  virtual vtkStringArray* GetSurfaceArrayNames();

  virtual vtkIntArray* GetSurfaceArrayTypes();

  virtual vtkStringArray* GetSurfaceArrayEnumValues();

  virtual vtkDoubleArray* GetSurfaceArrayDefaultValues();

  virtual vtkIntArray* GetSurfaceArrayComps();


  vtkGetMacro(WeightsSize, int);

  virtual bool ManualIntegration(double* xcur, double* xnext,
    double t, double& delT, double& delTActual,
    double minStep, double maxStep,
    double maxError, double& error, int& integrationResult);

  virtual void ParallelManualShift(vtkLagrangianParticle* vtkNotUsed(particle)){}

  virtual bool FinalizeOutputs(vtkPolyData* vtkNotUsed(particlePathsOutput),
    vtkDataObject* vtkNotUsed(interractionOutput)){return true;}

  virtual void PreIntegrate(std::queue<vtkLagrangianParticle*>& vtkNotUsed(particles)){}

  virtual vtkAbstractArray* GetSeedArray(int idx, vtkPointData* pointData);

protected:
  vtkLagrangianBasicIntegrationModel();
  ~vtkLagrangianBasicIntegrationModel() override;

  virtual int FunctionValues(vtkDataSet* detaSet, vtkIdType cellId, double* weights,
    double * x, double * f) = 0;

  virtual vtkIdType FindInLocator(vtkDataSet* dataSet, vtkAbstractCellLocator* locator,
    double* x, vtkGenericCell* cell, double* weights);

  virtual bool TerminateParticle(vtkLagrangianParticle* particle);

  virtual bool BounceParticle(vtkLagrangianParticle* particle,
    vtkDataSet*  surface, vtkIdType cellId);

  virtual bool BreakParticle(vtkLagrangianParticle* particle,
    vtkDataSet*  surface, vtkIdType cellId, std::queue<vtkLagrangianParticle*>& particles);

  virtual bool InteractWithSurface(int surfaceType, vtkLagrangianParticle* particle,
    vtkDataSet* surface, vtkIdType cellId, std::queue<vtkLagrangianParticle*>& particles);

  virtual bool IntersectWithLine(vtkCell* cell, double p1[3], double p2[3],
    double tol, double& t, double x[3]);

  virtual void InterpolateNextParticleVariables(vtkLagrangianParticle* particle,
    double interpolationFactor, bool forceInside = false);

  virtual bool CheckSurfacePerforation(vtkLagrangianParticle* particle,
    vtkDataSet*  surface, vtkIdType cellId);

  virtual vtkAbstractArray* GetSeedArray(int idx, vtkLagrangianParticle* particle);

  virtual bool GetFlowOrSurfaceData(int idx, vtkDataSet* flowDataSet,
    vtkIdType tupleId, double* weights, double*& data, int& nComponents);

  virtual int GetFlowOrSurfaceDataFieldAssociation(int idx);

  virtual void ComputeSurfaceDefaultValues(const char* arrayName, vtkDataSet* dataset,
                                             int nComponent, double* defaultValues);

  vtkAbstractCellLocator* Locator;
  bool LocatorsBuilt;
  vtkAbstractCellLocator* LastLocator;
  vtkLocatorsType* Locators;

  vtkDataSet* LastDataSet;
  vtkDataSetsType* DataSets;
  vtkGenericCell* Cell;
  double* LastWeights;
  int WeightsSize;

  struct ArrayVal
  {
    int val[3];
  };
  typedef std::pair<ArrayVal, std::string> ArrayMapVal;
  std::map<int, ArrayMapVal> InputArrays;

  typedef struct SurfaceArrayDescription
  {
    int nComp;
    int type;
    std::vector< std::pair< int, std::string > > enumValues;
  } SurfaceArrayDescription;
  std::map<std::string, SurfaceArrayDescription> SurfaceArrayDescriptions;

  vtkLagrangianParticle* CurrentParticle;
  vtkLagrangianParticle* TmpParticle;

  vtkSurfaceType* Surfaces;
  vtkLocatorsType* SurfaceLocators;

  vtkDataArray* TmpArray;

  double Tolerance;
  bool NonPlanarQuadSupport;
  bool UseInitialIntegrationTime;

  vtkNew<vtkStringArray> SeedArrayNames;
  vtkNew<vtkIntArray> SeedArrayComps;
  vtkNew<vtkIntArray> SeedArrayTypes;
  vtkNew<vtkStringArray> SurfaceArrayNames;
  vtkNew<vtkIntArray> SurfaceArrayComps;
  vtkNew<vtkIntArray> SurfaceArrayTypes;
  vtkNew<vtkStringArray> SurfaceArrayEnumValues;
  vtkNew<vtkDoubleArray> SurfaceArrayDefaultValues;

  vtkWeakPointer<vtkLagrangianParticleTracker> Tracker;

private:
  vtkLagrangianBasicIntegrationModel(const vtkLagrangianBasicIntegrationModel&) = delete;
  void operator=(const vtkLagrangianBasicIntegrationModel&) = delete;
};

#endif