diff --git a/Documentation/release/dev/improve-particlertracerbase-filters.md b/Documentation/release/dev/improve-particlertracerbase-filters.md new file mode 100644 index 0000000000000000000000000000000000000000..be036123b55c38ea44574ec0a46cde4dd35b88be --- /dev/null +++ b/Documentation/release/dev/improve-particlertracerbase-filters.md @@ -0,0 +1,21 @@ +## Improve vtkParticleTracerBase filters + +The ParticleTracer/ParticlePath/StreakLine filters which are subclasses of vtkParticleTracerBase have the following +improvements: + +1) Multithreaded using vtkSMPTools. Multithreading is used when there is only one MPI process, + and the number of particles is greater than 100. +3) Now have _InterpolatorType_ which can either use a cell locator (default) or a point locator for interpolation. +4) Instead of the _StaticMesh_ flag, it now has the _MeshOverTime_ flag which has the following values: + 1) **Different**: The mesh is different over time. + 2) **Static**: The mesh is the same over time. + 3) **Linear Transformation**: The mesh is different over time, but it is a linear transformation of the first + time-step's mesh. + 1) For cell locators, this flag internally makes use of the new vtkLinearTransformCellLocator. This way the + locator is only built once in the first time-step. + 2) For point locators, this flag internally re-uses the same cell links, but rebuilds the point locator since + there is no vtkLinearTransformPointLocator yet. + 4) **Same Topology**: The mesh is different over time, but it preserves the same topology (same number of + points/cells, same connectivity). + 1) For cell locators, this is equivalent to _MeshOverTime_ == **Different**. + 2) For point locators, this flag internally re-uses the same cell links. diff --git a/Remoting/Application/Resources/filters_filtersflowpaths.xml b/Remoting/Application/Resources/filters_filtersflowpaths.xml index a8e3f686f735219d7a7d49f443098723c604008b..325d63cf685a95d86760591fe58b77235160161d 100644 --- a/Remoting/Application/Resources/filters_filtersflowpaths.xml +++ b/Remoting/Application/Resources/filters_filtersflowpaths.xml @@ -1,8 +1,8 @@ - + @@ -11,37 +11,39 @@ name="EvenlySpacedStreamlines2D"> - This filter generates evenly spaced streamlines in a 2D - vector field from a start position. Production of - streamlines terminates if a streamline crosses the - exterior boundary of the input dataset - (ReasonForTermination=1), an initialization issue (ReasonForTermination=2), - computing an unexpected value (ReasonForTermination=3), - reached the Maximum Streamline Length input value - (ReasonForTermination=4), reached the Maximum Steps - input value (ReasonForTermination=5), velocity was - lower than the Terminal Speed input value - (ReasonForTermination=6), a streamline formed a loop - (ReasonForTermination=7), and the streamline was too close to - other streamlines (ReasonForTermination=8). This filter - operates on a 2D dataset aligned with plane XY with - point-centered vectors aligned with plane XY. - The output is polygonal data containing polylines. + This filter generates evenly spaced streamlines in a 2D + vector field from a start position. Production of + streamlines terminates if a streamline crosses the + exterior boundary of the input dataset + (ReasonForTermination=1), an initialization issue (ReasonForTermination=2), + computing an unexpected value (ReasonForTermination=3), + reached the Maximum Streamline Length input value + (ReasonForTermination=4), reached the Maximum Steps + input value (ReasonForTermination=5), velocity was + lower than the Terminal Speed input value + (ReasonForTermination=6), a streamline formed a loop + (ReasonForTermination=7), and the streamline was too close to + other streamlines (ReasonForTermination=8). This filter + operates on a 2D dataset aligned with plane XY with + point-centered vectors aligned with plane XY. + The output is polygonal data containing polylines. - - + + - + - This property specifies the input to the filter. + number_of_components="3"/> + + This property specifies the input to the filter. + + name="Input"/> - This property contains the name of the vector array from - which to generate streamlines. + + This property contains the name of the vector array from which to generate streamlines. + + panel_visibility="advanced"> + value="0"/> + value="1"/> - This property determines which interpolator to use for - evaluating the velocity vector field. The first is faster though the - second is more robust in locating cells during streamline - integration. + + This property determines which interpolator to use for + evaluating the velocity vector field. The first is faster though the + second is more robust in locating cells during streamline integration. + + value="0"/> + value="1"/> - This property determines which integrator (with - increasing accuracy) to use for creating streamlines. + + This property determines which integrator (with increasing accuracy) to use for creating streamlines. + + value="1"/> + value="2"/> - This property specifies the unit for - Initial integration step size. The Length unit refers - to the arc length that a particle travels/advects within a single step. - The Cell Length unit represents the step size as a number of - cells. + + This property specifies the unit for + Initial integration step size. The Length unit refers + to the arc length that a particle travels/advects within a single step. + The Cell Length unit represents the step size as a number of cells. + - - This property specifies the initial integration step - size. For non-adaptive integrators (Runge-Kutta 2 and Runge-Kutta 4), - it is fixed (always equal to this initial value) throughout the - integration. + panel_visibility="advanced"> + + + This property specifies the initial integration step + size. For non-adaptive integrators (Runge-Kutta 2 and Runge-Kutta 4), + it is fixed (always equal to this initial value) throughout the integration. + - - This property specifies the maximum number of steps, - beyond which streamline integration is terminated. + + + This property specifies the maximum number of steps, beyond which streamline integration is terminated. + - - Specify the separating distance between - streamlines expressed in IntegrationStepUnit. + panel_visibility="default"> + + + Specify the separating distance between streamlines expressed in IntegrationStepUnit. + - - Specifies SeparatingDistanceRatio. If streamlines - get closer than SeparatingDistance * SeparatingDistanceRatio to - other streamlines integration stops. + panel_visibility="default"> + + + Specifies SeparatingDistanceRatio. If streamlines get closer than + SeparatingDistance * SeparatingDistanceRatio to other streamlines integration stops. + - - Loops are considered closed if the have two points at - distance less than this. This is expressed in IntegrationStepUnit. + panel_visibility="default"> + + + Loops are considered closed if the have two points at + distance less than this. This is expressed in IntegrationStepUnit. + + panel_visibility="default"> - + - Specify the starting point (seed) of the first streamline - in the global coordinate system. + + Specify the starting point (seed) of the first streamline in the global coordinate system. + - - This property specifies the terminal speed, below which - particle advection/integration is terminated. + panel_visibility="advanced"> + + + This property specifies the terminal speed, below which particle advection/integration is terminated. + - - Specify whether or not to compute - vorticity. + panel_visibility="advanced"> + + + Specify whether to compute vorticity. + - - - - - - - - - + + + + + + + + + - + @@ -216,39 +231,41 @@ name="ParticlePath"> - The Particle Trace filter generates pathlines in a vector - field from a collection of seed points. The vector field - used is selected from the Vectors menu, so the input data - set is required to have point-centered vectors. The Seed - portion of the interface allows you to select whether the - seed points for this integration lie in a point cloud or - along a line. Depending on which is selected, the - appropriate 3D widget (point or line widget) is displayed - along with traditional user interface controls for - positioning the point cloud or line within the data set. - Instructions for using the 3D widgets and the - corresponding manual controls can be found in section 7.4. - This filter operates on any type of data set, provided it - has point-centered vectors. The output is polygonal data - containing polylines. This filter is available on the - Toolbar. + The Particle Trace filter generates pathlines in a vector + field from a collection of seed points. The vector field + used is selected from the Vectors menu, so the input data + set is required to have point-centered vectors. The Seed + portion of the interface allows you to select whether the + seed points for this integration lie in a point cloud or + along a line. Depending on which is selected, the + appropriate 3D widget (point or line widget) is displayed + along with traditional user interface controls for + positioning the point cloud or line within the data set. + Instructions for using the 3D widgets and the + corresponding manual controls can be found in section 7.4. + This filter operates on any type of data set, provided it + has point-centered vectors. The output is polygonal data + containing polylines. This filter is available on the + Toolbar. + - - + + - + - Specify which is the Input of the StreamTracer - filter. + number_of_components="3"/> + + Specify which is the Input of the StreamTracer filter. + - - + + - + - Specify the seed dataset. Typically from where the - vector field integration should begin. Usually a point/radius or a line - with a given resolution. + + Specify the seed dataset. Typically, from where the vector field integration should begin. + Usually a point/radius or a line with a given resolution. + - - Setting TerminationTime to a positive value will cause - particles to terminate when the time is reached. The units of time - should be consistent with the primary time variable. + + + Setting TerminationTime to a positive value will cause particles to terminate when the time is reached. + The units of time should be consistent with the primary time variable. + - + - - When animating particles, it is nice to inject new ones - every Nth step to produce a continuous flow. Setting - ForceReinjectionEveryNSteps to a non zero value will cause the particle - source to reinject particles every Nth step even if it is otherwise - unchanged. Note that if the particle source is also animated, this flag - will be redundant as the particles will be reinjected whenever the - source changes anyway + + + When animating particles, it is nice to inject new ones every Nth step to produce a continuous flow. + Setting ForceReinjectionEveryNSteps to a non zero value will cause the particle source to reinject + particles every Nth step even if it is otherwise unchanged. Note that if the particle source is also animated, + this flag will be redundant as the particles will be reinjected whenever the source changes anyway. + - - If the input seeds are not changing, then this - can be set to 1 to avoid having to do a repeated grid search - that would return the exact same result. + + + If the input seeds are not changing, then this can be set to 1 to avoid having to do a repeated grid search + that would return the exact same result. - - - If the input grid is not changing, then this - can be set to 1 to avoid having to create cell locators for - each update. + + + + + + + + The input mesh can either be 1) different over time, or 2) static over time, + or 3) a linear transformation of the first time step over time, or 4) have the same topology over time. + If a value other than Different are used, then performance can be improved significantly because certain + data structures, such as locators or cell links are not rebuilt for each timestep. + + + + + + + + + This property determines which interpolator to use for evaluating the velocity vector field. The first is + faster though the second is more robust in locating cells during streamline integration. + name="Input"/> - Specify which vector array should be used for the - integration through that filter. + + Specify which vector array should be used for the integration through that filter. + - - Compute vorticity and angular rotation of particles as - they progress + + + Compute vorticity and angular rotation of particles as they progress + - - This property specifies the terminal speed, below which - particle advection/integration is terminated. + panel_visibility="advanced"> + + + This property specifies the terminal speed, below which particle advection/integration is terminated. + @@ -354,39 +398,41 @@ name="ParticleTracer"> - The Particle Trace filter generates pathlines in a vector - field from a collection of seed points. The vector field - used is selected from the Vectors menu, so the input data - set is required to have point-centered vectors. The Seed - portion of the interface allows you to select whether the - seed points for this integration lie in a point cloud or - along a line. Depending on which is selected, the - appropriate 3D widget (point or line widget) is displayed - along with traditional user interface controls for - positioning the point cloud or line within the data set. - Instructions for using the 3D widgets and the - corresponding manual controls can be found in section 7.4. - This filter operates on any type of data set, provided it - has point-centered vectors. The output is polygonal data - containing polylines. This filter is available on the - Toolbar. + The Particle Trace filter generates pathlines in a vector + field from a collection of seed points. The vector field + used is selected from the Vectors menu, so the input data + set is required to have point-centered vectors. The Seed + portion of the interface allows you to select whether the + seed points for this integration lie in a point cloud or + along a line. Depending on which is selected, the + appropriate 3D widget (point or line widget) is displayed + along with traditional user interface controls for + positioning the point cloud or line within the data set. + Instructions for using the 3D widgets and the + corresponding manual controls can be found in section 7.4. + This filter operates on any type of data set, provided it + has point-centered vectors. The output is polygonal data + containing polylines. This filter is available on the + Toolbar. + - - + + - + - Specify which is the Input of the StreamTracer - filter. + number_of_components="3"/> + + Specify which is the Input of the StreamTracer filter. + - - + + - + - Specify the seed dataset. Typically from where the - vector field integration should begin. Usually a point/radius or a line - with a given resolution. + + Specify the seed dataset. Typically, from where the vector field integration should begin. + Usually a point/radius or a line with a given resolution. + - - If the input seeds are not changing, then this - can be set to 1 to avoid having to do a repeated grid search - that would return the exact same result. + + + If the input seeds are not changing, then this can be set to 1 to avoid having to do a repeated grid search + that would return the exact same result. - - - If the input grid is not changing, then this - can be set to 1 to avoid having to create cell locators for - each update. + + + + + + + + The input mesh can either be 1) different over time, or 2) static over time, + or 3) a linear transformation of the first time step over time, or 4) have the same topology over time. + If a value other than Different are used, then performance can be improved significantly because certain + data structures, such as locators or cell links are not rebuilt for each timestep. + + + + + + + + + This property determines which interpolator to use for evaluating the velocity vector field. The first is + faster though the second is more robust in locating cells during streamline integration. - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - When animating particles, it is nice to inject new ones - every Nth step to produce a continuous flow. Setting - ForceReinjectionEveryNSteps to a non zero value will cause the particle - source to reinject particles every Nth step even if it is otherwise - unchanged. Note that if the particle source is also animated, this flag - will be redundant as the particles will be reinjected whenever the - source changes anyway + + + When animating particles, it is nice to inject new ones every Nth step to produce a continuous flow. + Setting ForceReinjectionEveryNSteps to a non zero value will cause the particle source to reinject particles + every Nth step even if it is otherwise unchanged. Note that if the particle source is also animated, this flag + will be redundant as the particles will be reinjected whenever the source changes anyway. + + name="Input"/> - Specify which vector array should be used for the - integration through that filter. + + Specify which vector array should be used for the integration through that filter. + - - Compute vorticity and angular rotation of particles as - they progress + + + Compute vorticity and angular rotation of particles as they progress. + @@ -516,58 +545,83 @@ name="StreakLine"> - The Particle Trace filter generates pathlines in a vector - field from a collection of seed points. The vector field - used is selected from the Vectors menu, so the input data - set is required to have point-centered vectors. The Seed - portion of the interface allows you to select whether the - seed points for this integration lie in a point cloud or - along a line. Depending on which is selected, the - appropriate 3D widget (point or line widget) is displayed - along with traditional user interface controls for - positioning the point cloud or line within the data set. - Instructions for using the 3D widgets and the - corresponding manual controls can be found in section 7.4. - This filter operates on any type of data set, provided it - has point-centered vectors. The output is polygonal data - containing polylines. This filter is available on the - Toolbar. + The Particle Trace filter generates pathlines in a vector + field from a collection of seed points. The vector field + used is selected from the Vectors menu, so the input data + set is required to have point-centered vectors. The Seed + portion of the interface allows you to select whether the + seed points for this integration lie in a point cloud or + along a line. Depending on which is selected, the + appropriate 3D widget (point or line widget) is displayed + along with traditional user interface controls for + positioning the point cloud or line within the data set. + Instructions for using the 3D widgets and the + corresponding manual controls can be found in section 7.4. + This filter operates on any type of data set, provided it + has point-centered vectors. The output is polygonal data + containing polylines. This filter is available on the + Toolbar. + - - + + - + - Specify which is the Input of the StreamTracer - filter. + number_of_components="3"/> + + Specify which is the Input of the StreamTracer filter. + - - If the input seeds are not changing, then this - can be set to 1 to avoid having to do a repeated grid search - that would return the exact same result. + + + If the input seeds are not changing, then this can be set to 1 to avoid having to do a repeated grid search + that would return the exact same result. - - - If the input grid is not changing, then this - can be set to 1 to avoid having to create cell locators for - each update. + + + + + + + + The input mesh can either be 1) different over time, or 2) static over time, + or 3) a linear transformation of the first time step over time, or 4) have the same topology over time. + If a value other than Different are used, then performance can be improved significantly because certain + data structures, such as locators or cell links are not rebuilt for each timestep. + + + + + + + + + This property determines which interpolator to use for evaluating the velocity vector field. The first is + faster though the second is more robust in locating cells during streamline integration. - - + + - + - Specify the seed dataset. Typically from where the - vector field integration should begin. Usually a point/radius or a line - with a given resolution. + + Specify the seed dataset. Typically, from where the vector field integration should begin. Usually a + point/radius or a line with a given resolution. + - - Setting TerminationTime to a positive value will cause - particles to terminate when the time is reached. The units of time - should be consistent with the primary time variable. + + + Setting TerminationTime to a positive value will cause particles to terminate when the time is reached. + The units of time should be consistent with the primary time variable. + - + - - When animating particles, it is nice to inject new ones - every Nth step to produce a continuous flow. Setting - ForceReinjectionEveryNSteps to a non zero value will cause the particle - source to reinject particles every Nth step even if it is otherwise - unchanged. Note that if the particle source is also animated, this flag - will be redundant as the particles will be reinjected whenever the - source changes anyway + + + When animating particles, it is nice to inject new ones every Nth step to produce a continuous flow. + Setting ForceReinjectionEveryNSteps to a non zero value will cause the particle source to reinject particles + every Nth step even if it is otherwise unchanged. Note that if the particle source is also animated, this flag + will be redundant as the particles will be reinjected whenever the source changes anyway. + + name="Input"/> - Specify which vector array should be used for the - integration through that filter. + + Specify which vector array should be used for the integration through that filter. + - - Compute vorticity and angular rotation of particles as - they progress + + + Compute vorticity and angular rotation of particles as they progress + - - Prevents cache from getting reset so that new computation - always start from previous results. + + + Prevents cache from getting reset so that new computation always start from previous results. + @@ -654,36 +712,37 @@ name="StreamTracer"> The - Stream Tracer filter generates streamlines in a vector - field from a collection of seed points. Production of - streamlines terminates if a streamline crosses the - exterior boundary of the input dataset - (ReasonForTermination=1). Other reasons for termination - include an initialization issue (ReasonForTermination=2), - computing an unexpected value (ReasonForTermination=3), - reached the Maximum Streamline Length input value - (ReasonForTermination=4), reached the Maximum Steps - input value (ReasonForTermination=5), and velocity was - lower than the Terminal Speed input value - (ReasonForTermination=6). This filter operates on any - type of dataset, provided it has point-centered vectors. - The output is polygonal data containing polylines. + Stream Tracer filter generates streamlines in a vector + field from a collection of seed points. Production of + streamlines terminates if a streamline crosses the + exterior boundary of the input dataset + (ReasonForTermination=1). Other reasons for termination + include an initialization issue (ReasonForTermination=2), + computing an unexpected value (ReasonForTermination=3), + reached the Maximum Streamline Length input value + (ReasonForTermination=4), reached the Maximum Steps + input value (ReasonForTermination=5), and velocity was + lower than the Terminal Speed input value + (ReasonForTermination=6). This filter operates on any + type of dataset, provided it has point-centered vectors. + The output is polygonal data containing polylines. - - + + - + - This property specifies the input to the Stream Tracer - filter. + number_of_components="3"/> + + This property specifies the input to the Stream Tracer filter. + + name="Input"/> - This property contains the name of the vector array from - which to generate streamlines. + + This property contains the name of the vector array from which to generate streamlines. + + panel_visibility="advanced"> + value="0"/> + value="1"/> - This property determines which interpolator to use for - evaluating the velocity vector field. The first is faster though the - second is more robust in locating cells during streamline - integration. + + This property determines which interpolator to use for evaluating the velocity vector field. The first is + faster though the second is more robust in locating cells during streamline integration. + - - Specify whether or not to compute surface - streamlines. + panel_visibility="advanced"> + + + Specify whether to compute surface streamlines. + + value="0"/> + value="1"/> + value="2"/> - This property determines in which direction(s) a - streamline is generated. + + This property determines in which direction(s) a streamline is generated. + + value="0"/> + value="1"/> + value="2"/> - This property determines which integrator (with - increasing accuracy) to use for creating streamlines. + + This property determines which integrator (with increasing accuracy) to use for creating streamlines. + + value="1"/> + value="2"/> - This property specifies the unit for - Minimum/Initial/Maximum integration step size. The Length unit refers - to the arc length that a particle travels/advects within a single step. - The Cell Length unit represents the step size as a number of - cells. + + This property specifies the unit for + Minimum/Initial/Maximum integration step size. The Length unit refers + to the arc length that a particle travels/advects within a single step. + The Cell Length unit represents the step size as a number of cells. + - - This property specifies the initial integration step - size. For non-adaptive integrators (Runge-Kutta 2 and Runge-Kutta 4), - it is fixed (always equal to this initial value) throughout the - integration. For an adaptive integrator (Runge-Kutta 4-5), the actual - step size varies such that the numerical error is less than a specified - threshold. + panel_visibility="advanced"> + + + This property specifies the initial integration step + size. For non-adaptive integrators (Runge-Kutta 2 and Runge-Kutta 4), + it is fixed (always equal to this initial value) throughout the + integration. For an adaptive integrator (Runge-Kutta 4-5), the actual + step size varies such that the numerical error is less than a specified threshold. + - - When using the Runge-Kutta 4-5 integrator, this property - specifies the minimum integration step size. + panel_visibility="advanced"> + + + When using the Runge-Kutta 4-5 integrator, this property specifies the minimum integration step size. + - - When using the Runge-Kutta 4-5 integrator, this property - specifies the maximum integration step size. + + + When using the Runge-Kutta 4-5 integrator, this property specifies the maximum integration step size. + - - This property specifies the maximum number of steps, - beyond which streamline integration is terminated. + + + This property specifies the maximum number of steps, beyond which streamline integration is terminated. + + name="Input"/> - This property specifies the maximum streamline length - (i.e., physical arc length), beyond which line integration is - terminated. + + This property specifies the maximum streamline length (i.e., physical arc length), beyond which line + integration is terminated. + - - This property specifies the terminal speed, below which - particle advection/integration is terminated. + panel_visibility="advanced"> + + + This property specifies the terminal speed, below which particle advection/integration is terminated. + - - This property specifies the maximum error (for - Runge-Kutta 4-5) tolerated throughout streamline integration. The - Runge-Kutta 4-5 integrator tries to adjust the step size such that the - estimated error is less than this threshold. + panel_visibility="advanced"> + + + This property specifies the maximum error (for + Runge-Kutta 4-5) tolerated throughout streamline integration. The + Runge-Kutta 4-5 integrator tries to adjust the step size such that the + estimated error is less than this threshold. + - - Specify whether or not to compute - vorticity. + panel_visibility="advanced"> + + + Specify whether to compute vorticity. + - + - The value of this property determines how the seeds for - the streamlines will be generated. + + The value of this property determines how the seeds for the streamlines will be generated. + - + If true the filter considers that the whole seed source is available on all ranks. Else the filter will aggregate all seed sources from all ranks and merge their points. @@ -895,27 +969,27 @@ - + - - - - - - - + + + + + + + - - - - + + + + - + @@ -926,38 +1000,40 @@ name="ArbitrarySourceStreamTracer"> The - Stream Tracer With Custom Source filter generates streamlines - in a vector field from a collection of seed points. Production - of streamlines terminates if a streamline crosses the - exterior boundary of the input dataset - (ReasonForTermination=1). Other reasons for termination - include an initialization issue (ReasonForTermination=2), - computing an unexpected value (ReasonForTermination=3), - reached the Maximum Streamline Length input value - (ReasonForTermination=4), reached the Maximum Steps - input value (ReasonForTermination=5), and velocity was - lower than the Terminal Speed input value - (ReasonForTermination=6). This filter operates on any - type of dataset, provided it has point-centered vectors. - The output is polygonal data containing polylines. - This filter takes a Source input - that provides the seed points. + Stream Tracer With Custom Source filter generates streamlines + in a vector field from a collection of seed points. Production + of streamlines terminates if a streamline crosses the + exterior boundary of the input dataset + (ReasonForTermination=1). Other reasons for termination + include an initialization issue (ReasonForTermination=2), + computing an unexpected value (ReasonForTermination=3), + reached the Maximum Streamline Length input value + (ReasonForTermination=4), reached the Maximum Steps + input value (ReasonForTermination=5), and velocity was + lower than the Terminal Speed input value + (ReasonForTermination=6). This filter operates on any + type of dataset, provided it has point-centered vectors. + The output is polygonal data containing polylines. + This filter takes a Source input + that provides the seed points. + - - + + - + - This property specifies the input to the Stream Tracer - filter. + number_of_components="3"/> + + This property specifies the input to the Stream Tracer filter. + + name="Input"/> - This property contains the name of the vector array from - which to generate streamlines. + + This property contains the name of the vector array from which to generate streamlines. + + panel_visibility="advanced"> + value="0"/> + value="1"/> - This property determines which interpolator to use for - evaluating the velocity vector field. The first is faster though the - second is more robust in locating cells during streamline - integration. + + This property determines which interpolator to use for + evaluating the velocity vector field. The first is faster though the + second is more robust in locating cells during streamline integration. + - - Specify whether or not to compute surface - streamlines. + panel_visibility="advanced"> + + + Specify whether to compute surface streamlines. + + value="0"/> + value="1"/> + value="2"/> - This property determines in which direction(s) a - streamline is generated. + + This property determines in which direction(s) a streamline is generated. + + value="0"/> + value="1"/> + value="2"/> - This property determines which integrator (with - increasing accuracy) to use for creating streamlines. + + This property determines which integrator (with increasing accuracy) to use for creating streamlines. + + value="1"/> + value="2"/> - This property specifies the unit for - Minimum/Initial/Maximum integration step size. The Length unit refers - to the arc length that a particle travels/advects within a single step. - The Cell Length unit represents the step size as a number of - cells. + + This property specifies the unit for + Minimum/Initial/Maximum integration step size. The Length unit refers + to the arc length that a particle travels/advects within a single step. + The Cell Length unit represents the step size as a number of cells. + - - This property specifies the initial integration step - size. For non-adaptive integrators (Runge-Kutta 2 and Runge-Kutta 4), - it is fixed (always equal to this initial value) throughout the - integration. For an adaptive integrator (Runge-Kutta 4-5), the actual - step size varies such that the numerical error is less than a specified - threshold. + + + This property specifies the initial integration step + size. For non-adaptive integrators (Runge-Kutta 2 and Runge-Kutta 4), + it is fixed (always equal to this initial value) throughout the + integration. For an adaptive integrator (Runge-Kutta 4-5), the actual + step size varies such that the numerical error is less than a specified threshold. + - - When using the Runge-Kutta 4-5 integrator, this property - specifies the minimum integration step size. + + + When using the Runge-Kutta 4-5 integrator, this property specifies the minimum integration step size. + - - When using the Runge-Kutta 4-5 integrator, this property - specifies the maximum integration step size. + + + When using the Runge-Kutta 4-5 integrator, this property specifies the maximum integration step size. + - - This property specifies the maximum number of steps, - beyond which streamline integration is terminated. + + + This property specifies the maximum number of steps, beyond which streamline integration is terminated. + + name="Input"/> - This property specifies the maximum streamline length - (i.e., physical arc length), beyond which line integration is - terminated. + + This property specifies the maximum streamline length + (i.e., physical arc length), beyond which line integration is terminated. + - - This property specifies the terminal speed, below which - particle advection/integration is terminated. + + + This property specifies the terminal speed, below which particle advection/integration is terminated. + - - This property specifies the maximum error (for - Runge-Kutta 4-5) tolerated throughout streamline integration. The - Runge-Kutta 4-5 integrator tries to adjust the step size such that the - estimated error is less than this threshold. + + + This property specifies the maximum error (for Runge-Kutta 4-5) tolerated throughout streamline integration. + The Runge-Kutta 4-5 integrator tries to adjust the step size such that the + estimated error is less than this threshold. + - - Specify whether or not to compute - vorticity. + + + Specify whether to compute vorticity. + - + If true the filter considers that the whole seed source is available on all ranks. Else the filter will aggregate all seed sources from all ranks and merge their points. @@ -1156,23 +1246,24 @@ label="Seed Source" name="Source"> - + - This property specifies the input used to obtain the - seed points. + + This property specifies the input used to obtain the seed points. + - + + class="vtkVortexCore" + label="Vortex Cores"> + short_help="Compute vortex cores of a vector field"> Compute vortex core lines using the parallel vectors method. By default, the "Higher-Order" approach of computing the parallel vector lines between the flow field's velocity and jerk is disabled in favor of computing the parallel vector lines between the velocity and @@ -1183,41 +1274,43 @@ + name="Input"> - - + + - + - The input. + optional="0"/> + + The input. + - - - - - - - This property indicates the name of the vector array from which to compute vortex cores. - - + command="SetInputArrayToProcess" + number_of_elements="5" + element_types="0 0 0 0 2" + label="Vector Field"> + + + + + + + This property indicates the name of the vector array from which to compute vortex cores. + + - + name="UseHigherOrderMethod" + default_values="0" + number_of_elements="1"> + Use the flow field's jerk instead of acceleration as the second vector field during the parallel vector operation. Disabled by default. @@ -1225,10 +1318,10 @@ - + name="FasterApproximation" + default_values="0" + number_of_elements="1"> + When this option is enabled, the gradient filter used to compute vortex cores will provide a less accurate algorithm that performs fewer derivative calculations and is therefore faster. @@ -1236,6 +1329,6 @@ - + diff --git a/VTK b/VTK index 95f8e1da0da768e08cd40de410f48c101c45a45d..afe7bb782bac721bf9b94c142af5f4a5b8144992 160000 --- a/VTK +++ b/VTK @@ -1 +1 @@ -Subproject commit 95f8e1da0da768e08cd40de410f48c101c45a45d +Subproject commit afe7bb782bac721bf9b94c142af5f4a5b8144992 diff --git a/VTKExtensions/FiltersGeneralMPI/vtkInSituPParticlePathFilter.cxx b/VTKExtensions/FiltersGeneralMPI/vtkInSituPParticlePathFilter.cxx index 8b98ca514e30fd136e7decbd5e500d22b123f55b..3a45522d981ba1c27cb519812dcdf9697c817eb4 100644 --- a/VTKExtensions/FiltersGeneralMPI/vtkInSituPParticlePathFilter.cxx +++ b/VTKExtensions/FiltersGeneralMPI/vtkInSituPParticlePathFilter.cxx @@ -29,6 +29,7 @@ #include "vtkTemporalInterpolatedVelocityField.h" using namespace vtkParticleTracerBaseNamespace; +using IDStates = vtkTemporalInterpolatedVelocityField::IDStates; vtkStandardNewMacro(vtkInSituPParticlePathFilter); @@ -198,7 +199,7 @@ void vtkInSituPParticlePathFilter::AssignSeedsToProcessors(double t, vtkDataSet* // since this is first test, avoid bad cache tests this->GetInterpolator()->ClearCache(); int searchResult = this->GetInterpolator()->TestPoint(pos); - if (searchResult == ID_INSIDE_ALL || searchResult == ID_OUTSIDE_T0) + if (searchResult == IDStates::INSIDE_ALL || searchResult == IDStates::OUTSIDE_T0) { // this particle is in this process's domain for the latest time step owningProcess[i] = myRank; diff --git a/Wrapping/Python/paraview/_backwardscompatibilityhelper.py b/Wrapping/Python/paraview/_backwardscompatibilityhelper.py index db2bb4a48dc37f24ae189d667ccaa7c13f5682dc..86f34a7eaef6c40ed411b5cedeb0cdc7dc3dd120 100644 --- a/Wrapping/Python/paraview/_backwardscompatibilityhelper.py +++ b/Wrapping/Python/paraview/_backwardscompatibilityhelper.py @@ -397,6 +397,16 @@ def setattr(proxy, pname, value): "properties, then set the 'ThresholdMethod' property to " "'Between' to threshold between the lower and upper thresholds.") + # In 5.11, we changed the ParticleTracer/ParticlePath/StreakLine's the StaticMesh + # property to be called MeshOverTime since more capabilities were added. + if pname == "StaticMesh" and proxy.SMProxy.GetXMLName() in ["ParticleTracer, ParticlePath, StreakLine"]: + if paraview.compatibility.GetVersion() <= 5.10: + proxy.GetProperty("MeshOverTime").SetData(value) + raise Continue() + else: + raise NotSupportedException("'StaticMesh' is obsolete. Use 'MeshOverTime' property of " + + proxy.SMProxy.GetXMLName() + " filter instead.") + if not hasattr(proxy, pname): raise AttributeError() proxy.__dict__[pname] = value @@ -819,6 +829,14 @@ def getattr(proxy, pname): "If you are wishing to use this property, please use 'SPHDataSetInterpolator' " "instead. The 'CutoffArray' needs to be provided by the data set source.") + if pname == "StaticMesh" and proxy.SMProxy.GetXMLName() in ["ParticleTracer, ParticlePath, StreakLine"]: + if paraview.compatibility.GetVersion() <= 5.10: + return proxy.GetProperty("MeshOverTime").GetData() + else: + raise NotSupportedException( + "The " + proxy.SMProxy.GetXMLName() + ".StaticMesh property has been changed in ParaView 5.11. " \ + "Please set the MeshOverTime property instead.") + raise Continue() # Depending on the compatibility version that has been set, older functionalities @@ -877,6 +895,13 @@ def GetProxy(module, key, **kwargs): # into a unique 'Gradient" filter. gradient = builtins.getattr(module, "GradientLegacy")(**kwargs) return gradient + if version <= 5.10: + if key in ["ParticleTracer, ParticlePath, StreakLine"]: + # in 5.11, we changed the StaticMesh flag of ParticleTracer, ParticlePath and StreakLine + # This restores the previous StaticMesh. + particleTracerBase = builtins.getattr(module, key)(**kwargs) + particleTracerBase.MeshOverTime = 0 + return particleTracerBase return builtins.getattr(module, key)(**kwargs)