proteus.PostProcessingTools module

Collect classes and routines for postprocessing solution to get

quantities like conservative velocities, higher accuracy, etc

proteus.PostProcessingTools.VelocityPostProcessingChooser(transport)

pick acceptable velocity postprocessing based on input

class proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase(postProcessingType=None, vectorTransport=None, vtComponents=[0])

Bases: object

Base class for velocity post processing algorithms

Applies same algorithm to all components in vtComponents

TODO make velocity representation type an enum

Variables

• q[('velocity',ci)] (array type) – Stores the velocity values on element quadrature points.

• ebq[('velocity',ci)] (array type) – Stores the velocity values on element boundary quadrature points. Designed to reference the element number first.

• ebq_global[('velocity',ci)] (array) – Stores the velocity values on the boundary. Designed to reference the global edge number first.

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

computeGeometricInfo()

postprocess(verbose=0)

generate post-processed velocity field for attached VectorTransport object and store them in local dictionaries

postprocess_component(ci, verbose=0)

main functionality generate post-processed velocity field component ci

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

removeBoundaryFluxesFromResidual(ci, flag_elementBoundaries=None)

addBoundaryFluxesBackToResidual(ci, flag_elementBoundaries=None)

archiveVelocityValues(archive, t, tCount, initialPhase=False, meshChanged=False)

write out post processed velocity values as a finite element space

getElementwiseFlux(ci)

Calculates elementwise fluxes given the boundary velocities.

Parameters

ci (int) – The component number

Notes

This function has not been extensively tested and it does not account for the source terms.

class proteus.PostProcessingTools.VPP_P1nc_RT0(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

P1-nonconforming velocity postprocessing

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postProcessRT0potentialFromP1nc()

postProcessRT0potentialFromP1nc_sd()

postProcessRT0velocityFromP1nc()

postProcessRT0velocityFromP1nc_sd()

updateRT0velocityWithAveragedPotentialP1nc()

updateRT0velocityWithAveragedPotentialP1nc_sd()

getElementRT0velocityValues()

getElementBoundaryRT0velocityValues()

getGlobalElementBoundaryRT0velocityValues()

postprocess_component(ci, verbose=0)

compute velocity field in RT_0 assuming a potential field in \(P^1_{nc}\) has already been solved for

Uses Chou and Tang approach for now, so averaged pressure is not correct

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_PWL_RT0(vectorTransport=None, vtComponents=[0], omitFluxBoundaryNodes=True)

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Local Larson-Niklasson method with RT_0 representation for element

velocities This is not the correct postprocessing for optimized NS codes

uses RT_0 representation in terms of local basis

ec N_i = rac{1}{d|E|}( ec x - p_i)

where \(p_i\) is the vertex across from face i, \(|E|\) is the volume of the element, and d is the space dimension the degrees of freedom are :math:`V^i = int_{e_i}

ec vdot n_{i}ds`

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

compute mass conservative velocity field following Larson and Niklasson assuming a \(P^k C_0\) Galerkin solution has already been found

getConservationResidualPWL(ci, correctFlux=False)

compute conservation resiudal using current guess for element boundary flux

getConservationJacobianPWL(ci)

Build local systems for post-processing solve

evaluateLocalVelocityRepresentation(ci)

project to \(RT_0\) velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_PWL_RT1(vectorTransport=None, vtComponents=[0], omitFluxBoundaryNodes=True)

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Base class for higher order RT elements.

Variables

• globalDOF2globalElementList (list of lists) – Lists the global element numbers associated with each degree of freedom.

• globalDOFGlobalElement2StarElement (list of dicts) – Dictionaries of maps of local element numbers to global element numbers for each degree of freedom.

• dofStarElementsArray (list of lists) – For every element DOF, this array lists the element’s local mapping number.

• dofStarElementsNeighborsArray (list of lists of lists) – Provides local neighboring elements for each DOF on an element.

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

compute mass conservative velocity field following Larson and Niklasson assuming a P^k C0 Galerkin solution has already been found

getConservationResidualPWL(ci, correctFlux=False)

compute conservation resiudal using current guess for element boundary flux

getConservationJacobianPWL(ci)

Build local systems for post-processing solve

evaluateLocalVelocityRepresentation(ci)

project to RT_0 velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_PWL_BDM(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VPP_PWL_RT0

Local Larson-Niklasson method with BDM1 representation for element

velocities This is not the correct postprocessing for optimized NS codes

Only difference from VPP_PWL_RT0 should be steps for local velocity representation This one uses BDM_1 space which is \([P^1]^d\) locally with continuous linear fluxes on each face use standard basis

\[\]

ec N_i = lambda_{i/d} ec e_{i%d}

That is the dofs are locally (say in 2d) \([v^x_0,v^y_0,v^x_1,v^y_1,v^x_2,v^y_2]\)

Have to use BDM projection to get degrees of freedom

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

buildLocalBDM1projectionMatrices()

factorLocalBDM1projectionMatrices()

solveLocalBDM1projection()

getElementBDM1velocityValuesLagrangeRep()

computeBDM1projectionMatrices()

computeGeometricInfo()

evaluateLocalVelocityRepresentation(ci)

project to BDM velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3 .. todo:: put python loops in c

class proteus.PostProcessingTools.VPP_PWL_BDM2(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VPP_PWL_RT0

This class is intended to implement BDM2 elements in proteus

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

buildLocalBDM2projectionMatrices()

factorLocalBDM2projectionMatrices()

solveLocalBDM2projection()

getElementBDM2velocityValuesLagrangeRep()

buildBDM2rhs()

setInteriorVelocityValues(ci)

This function sets the interior velocity values based on the solution to the vt-problem.

set_BDM_dimensions(degree)

Calculate and set the BDM polynomial dimension input - degree

get_num_sigmaBasisElements()

setInteriorTestSpace(degree)

This function sets the interior test space corresponding to the dimension of the BDM space

setEdgeFlags()

This function sets the edge flags for the bdm2 loops

getInteriorTestGradients()

Calculate and return the gradient values for polynomials of degree 1

sigmaBasisElement(dim, component, point, i=0)

getInteriorDivFreeElement()

Calculate and return the values of the divergence free interior test function. Note - calculating this integral requires the use of the Piola transformation.

computeBDM2projectionMatrices()

flagNeumannBoundaryEdges()

This function flags neumann boundaries.

TODO - WIP - part of some experimental functions designed for LN approximations. NOTE - Currently this function is not operational and it returns a dictionary which suggests all edges are Dirichlet.

conservativeVelocityCalculation()

Serial implimentation of LN algorithm.

TODO - This function is experimental and should be refactor once completed.

getAverageFlux(ci)

Helper function to cacluate the average flux along the mesh boundaries.

computeGeometricInfo()

evaluateLocalVelocityRepresentation(ci, velocity_field_set=False)

This function projects the solution of the vt transport problem into the BDM2 space.

Parameters

• ci (int) – The solution component being projected.

• velocity_field_set (boolean) – Set to true when the quadrature values for the velocity function are already defined (this is typically used for testing).

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3 .. todo:: put python loops in c

class proteus.PostProcessingTools.VPP_PWL_RT0_OPT(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VPP_PWL_RT0

Version of local Larson-Niklasson scheme to use with optimized codes Assumes that all exterior boundaries are either flux or weak dirichlet boundaries and that exterior velocity has been calculated correctly (i.e., it’s consistent with either flux or weak dirichlet approximation)

Assumes layout the same across components

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

compute mass conservative velocity field following Larson and Niklasson assuming a P^k C0 Galerkin solution has already been found Setup for optimized parallel codes

getConservationJacobianPWL(ci)

Build local systems for post-processing solve

getConservationResidualPWL(ci, correctFlux=False)

compute conservation resiudal using current guess for element boundary flux

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_PWL_BDM_OPT(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VPP_PWL_RT0_OPT

Local Larson-Niklasson method with BDM1 representation for element

velocities for optimized parallel codes

Only difference from VPP_PWL_RT0_OPT should be steps for local velocity representation This one uses BDM_1 space which is \([P^1]^d\) locally with continuous linear fluxes on each face use standard basis

\[\]

ec N_i = lambda_{i%(d+1)} ec e_{i/(d+1)}

Have to use BDM projection to get degrees of freedom

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

buildLocalBDM1projectionMatrices()

factorLocalBDM1projectionMatrices()

solveLocalBDM1projection()

getElementBDM1velocityValuesLagrangeRep()

computeBDM1projectionMatrices()

updateWeights()

computeGeometricInfo()

evaluateLocalVelocityRepresentation(ci)

project to BDM velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_PWC_RT0(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Global piecewise constant Larson-Niklasson method with \(RT_0\)

representation for element velocities

uses RT_0 representation in terms of local basis

\[\]

ec N_i = rac{1}{d|E|}( ec x - p_i)

where \(p_i\) is the vertex across from face \(i\), \(|E|\) is the volume of the element, and \(d\) is the space dimension the degrees of freedom are :math:`V^i = int_{e_i}

ec vdot n_{i}ds`

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

compute mass conservative velocity field following Larson and Niklasson Global piecewise constant correcction

evaluateLocalVelocityRepresentation(ci)

project to \(RT_0\) velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_SUN_RT0(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Global piecewise constant Sun-Wheeler method with \(RT_0\)

representation for element velocities

uses RT_0 representation in terms of local basis

\[\]

ec N_i = rac{1}{d|E|}( ec x - p_i)

where \(p_i\) is the vertex across from face i, \(|E|\) is the volume of the element, and d is the space dimension the degrees of freedom are :math:`V^i = int_{e_i}

ec vdot n_{i}ds`

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

compute mass conservative velocity field following Sun and Wheeler Global piecewise constant correcction

evaluateLocalVelocityRepresentation(ci)

project to \(RT_0\) velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_SUN_GS_RT0(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Local Sun-Wheeler “Gauss-Seidel” method with \(RT_0\) representation

for element velocities

uses \(RT_0\) representation in terms of local basis

\[\]

ec N_i = rac{1}{d|E|}( ec x - p_i)

where p_i is the vertex across from face i, \(|E|\) is the volume of the element, and d is the space dimension the degrees of freedom are :math:`V^i = int_{e_i}

ec vdot n_{i}ds`

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

compute mass conservative velocity field following Sun and Wheeler local Gauss-Seidel

evaluateLocalVelocityRepresentation(ci)

project to \(RT_0\) velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_DG_RT0(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Post process DG solution velocity by projecting boundary fluxes onto local \(RT_0\) space

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

evaluateLocalVelocityRepresentation(ci)

project to \(RT_0\) velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_DG_BDM(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VPP_DG_RT0

Project DG solution onto BDM1 local representation which is

\([P^1]^d\) locally with continuous linear fluxes on each face

use standard basis

\[\]

ec N_i = lambda_{i%(d+1)} ec e_{i/(d+1)}

Have to use BDM projection to get degrees of freedom

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

buildLocalBDM1projectionMatrices()

factorLocalBDM1projectionMatrices()

solveLocalBDM1projectionFromFlux()

getElementBDM1velocityValuesLagrangeRep()

computeBDM1projectionMatrices()

computeGeometricInfo()

evaluateLocalVelocityRepresentation(ci)

project to BDM velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.VPP_POINT_EVAL(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Velocity calculation from just directly evaluating flux formula at intergration points using trial solution

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

postprocess_component(ci, verbose=0)

compute velocity field by just using point evaluation of trial

solution and coefficients

\[v = - en{a}_h\grad \phi_h +\]

ec f_h

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

TODO

Decide if should fail or throw exception here

class proteus.PostProcessingTools.VPP_POINT_EVAL_GWVD(vectorTransport=None, vtComponents=[0])

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Velocity calculation for evaluating coarse grid velocity solution at fine grid quadrature points; assumes that the coarse velocity degrees of freedom from the LDG solution are known

Currently only working for P=1 and P=2

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

getElementLDGvelocityValuesLagrangeRep()

postprocess_component(ci, verbose=0)

may need to compute velocity field at the desired velocity dofs if this step is not included in the getResidual step of the solution

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3 .. todo:: put python loops in c

archiveVelocityValues(archive, t, tCount, initialPhase=False, meshChanged=False)

write out post processed velocity values as a finite element space

class proteus.PostProcessingTools.VPP_LOW_K_IB_PWL_RT0(vectorTransport=None, vtComponents=[0], jump_tol=10000.0, min_tol=1e-05)

Bases: proteus.PostProcessingTools.VelocityPostProcessingAlgorithmBase

Local Larson-Niklasson method with RT_0 representation for element velocities This version tries to address flux through low permeability interfaces by manually setting boundaries with a ‘large’ jump in permeability and one of these boundaries being ‘small’ to no flux

VelocityPostProcessingAlgorithmBase Base Class Constructor

Parameters

• postProcessingType (str) – String value of the post-processing type to be applied

• vectorTransport (proteus.Transport.OneLevelTransport) – Vector Transport class object describing the problem.

• vtComponents (list) – List of indices for different vector transport components.

setInteriorFluxBoundaries(ci)

Flag interior flux boundaries

this version flags boundaries where \(|max(|a|_L)-max(|a|_R)|_{ebN} > jump_{tol}\) and \(min(max(|a|_L),max(|a|_R)) < min_{tol}\)

setInteriorFluxBoundaryValues(ci, ebq_global_velocity)

set interior flux boundary values this version sets interior flux boundaries to no flux

postprocess_component(ci, verbose=0)

compute mass conservative velocity field following Larson and Niklasson assuming a \(P^k C_0\) Galerkin solution has already been found

getConservationResidualPWL(ci, correctFlux=False)

compute conservation resiudal using current guess for element boundary flux

getConservationJacobianPWL(ci)

Build local systems for post-processing solve

evaluateLocalVelocityRepresentation(ci)

project to RT_0 velocity from element boundary fluxes

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

class proteus.PostProcessingTools.AggregateVelocityPostProcessor(postProcessingTypes=None, transport=None)

Bases: object

collect different velocity postprocessing algorithms for a (possibly) multicomponent system

vpp_types = {'dg': <class 'proteus.PostProcessingTools.VPP_DG_RT0'>, 'dg-bdm': <class 'proteus.PostProcessingTools.VPP_DG_BDM'>, 'dg-point-eval': <class 'proteus.PostProcessingTools.VPP_POINT_EVAL'>, 'p1-nc': <class 'proteus.PostProcessingTools.VPP_P1nc_RT0'>, 'point-eval': <class 'proteus.PostProcessingTools.VPP_POINT_EVAL'>, 'point-eval-gwvd': <class 'proteus.PostProcessingTools.VPP_POINT_EVAL_GWVD'>, 'pwc': <class 'proteus.PostProcessingTools.VPP_PWC_RT0'>, 'pwl': <class 'proteus.PostProcessingTools.VPP_PWL_RT0'>, 'pwl-bdm': <class 'proteus.PostProcessingTools.VPP_PWL_BDM'>, 'pwl-bdm-opt': <class 'proteus.PostProcessingTools.VPP_PWL_BDM_OPT'>, 'pwl-bdm2': <class 'proteus.PostProcessingTools.VPP_PWL_BDM2'>, 'pwl-ib-fix-0': <class 'proteus.PostProcessingTools.VPP_LOW_K_IB_PWL_RT0'>, 'pwl-opt': <class 'proteus.PostProcessingTools.VPP_PWL_RT0_OPT'>, 'sun-gs-rt0': <class 'proteus.PostProcessingTools.VPP_SUN_GS_RT0'>, 'sun-rt0': <class 'proteus.PostProcessingTools.VPP_SUN_RT0'>}

postprocess(verbose=0)

main functionality generate post-processed velocity field for attached VectorTransport object and store them in local dictionaries

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

archiveVelocityValues(archive, t, tCount, initialPhase=False, meshChanged=False)

write out post processed velocity values as a finite element space

class proteus.PostProcessingTools.VelocityPostProcessor_Original(postProcessingTypes=None, vectorTransport=None, vtComponents=[0], mlMesh=None, thisLevel=None)

Bases: object

accumulate basic functionality for post-processing velocity vields from scalar potentials

stores values in quadrature dictonary corresponding to vt.q and vt.ebq_global

Allowed types p1-nc pwl (default is rt0 local representation) pwl-bdm pwc (with rt0) point-eval sun-rt0 sun-gs-rt0

postProcessRT0potentialFromP1nc()

postProcessRT0potentialFromP1nc_sd()

postProcessRT0velocityFromP1nc()

postProcessRT0velocityFromP1nc_sd()

getElementRT0velocityValues()

getGlobalElementBoundaryRT0velocityValues()

buildLocalBDM1projectionMatrices()

factorLocalBDM1projectionMatrices()

solveLocalBDM1projection()

getElementBDM1velocityValuesLagrangeRep()

getElementBoundaryRT0velocityValues()

updateRT0velocityWithAveragedPotentialP1nc()

updateRT0velocityWithAveragedPotentialP1nc_sd()

calculateConservationResidual()

computeBDM1projectionMatrices()

computeGeometricInfo()

postprocess(verbose=0)

generate post-processed velocity field for attached VectorTransport object and store them in local dictionaries could split this up into postprocess element and postprocess element boundary

postprocessP1nc(ci, verbose=0)

compute velocity field in RT_0 assuming a potential field in P^1_{nc} has already been solved for

postprocessPWL(ci, verbose=0)

compute mass conservative velocity field following swedish way assuming a P^1 C0 Galerkin solution has already been found this is supposed to be the same as getConservationFluxPWL(ci)

postprocessPWL_opt(ci, verbose=0)

postprocessDG(ci, verbose=0)

getConservationResidualPWL(ci, correctFlux=False)

getConservationJacobianPWL(ci)

getConservationResidualPWL_opt(ci, correctFlux=False)

getConservationJacobianPWL_opt(ci)

postprocessPointEval(ci, verbose=0)

compute velocity field by just using point evaluation of trial solution and coefficients

\[v = - en{a}_h\grad \phi_h +\]

ec f_h

postprocessPWC(ci, verbose=0)

try to implement Larson and Niklasson piecewise-constant algorithm

TODO:

postprocessSunWheeler(ci, verbose=0)

try to implement Sun and Wheeler Gauss-Seidel postprocessing algorithm

evaluateElementVelocityField(x, ci)

evaluate velocity field assuming velocity_dofs already calculated for now assumes x shaped like nE x nq x 3

removeBoundaryFluxesFromResidual(ci, flag_elementBoundaries=None)

remove boundary fluxes from element residuals

addBoundaryFluxesBackToResidual(ci, flag_elementBoundaries=None)

remove boundary fluxes from element residuals