| CBaseNumericalTreatmemt | Base implementation according to Eric McNeil Eric McNeil original code use an approach based on Nujic but implement the numerical flux with a HLL algorithm. Re-use Nujic implementation of the source term and pressure terms, but provide also |
| Cdbpp::PhysicalSystem::BCNodeConstraint< Params > | Type to repesent the nodal constraint |
| Cdbpp::callCounter< CB > | Generic class that wraps and counts calls of an arbitrary callback |
| Cdbpp::Cell | Cell concept is at the heart of the finite volume discretization. Usage: Reconstruction procedure based on MUSCL (UL,UR at each face) MusclReconstruction w_muscl(); w_muscl.reconstr(GlobalDisretization aGDiscr); // based on cell face global Id retrieve a cell to perform some operation std::map<unsigned shortglobal cell face Id,fluxpairFL,FR> w_fluxFace; list<cell> w_listOfCell; for(Cell w_cell : w_listOfCell) { Create a flux algorithm FluxAlgorithm w_fluxAlgo; |
| Cdbpp::cellFace | Cell face in the finite volume discretization Usage: caculFF(const cellFace& aFace) compute the numerical flux with Godunov-type scheme for example F(UL,UR) with Approximate Riemann Solver (discontinuity or shock represented by cell face) |
| Cdbpp::cellFaceFlux | Face flux variables at cell face (aggregate). Physical flux is used to compute the face flux .. |
| CSfx::DamBreakData | Hold data for validation. Two type: EMcneil, Hudson (DamBreak config) |
| CSfx::DamBreakExSol | |
| CSfx::DamBreakInitialCnd | Sole responsibility is to provide wave profile at initial start up based on DamBreakData |
| Cdbpp::DamBreakProblem | The DAM-BREAK Problem class is a model of a well-posed problem |
| CTestvs19::DataStoreFactory | Data Store factory method |
| CSfx::EMcNeilBndCnd::DownstreamCelerity | Aggregate that hold celerity wave downstream (characteristic) |
| CSfx::EMcNeilBndCnd | Calculate the characteristic information to set boundary node values (A,Q,H) |
| Cdbpp::EMcNeilPhysBC | Physical boundary (characteristic equation solved) |
| Cstd::enable_shared_from_this | |
| CDamBreakSim | Base class for simulating the Dam Break Problem |
| CTestvs19::Wave1DSimulator | Wave simulator (simulate dam-break wave propagation) implementation |
| CTestvs19::WaveSimulator | Wave simulator (simulate dam-break wave propagation) |
| Cdbpp::VS19WaveSimulator | DamBreak simulator base class (Wave Simulator) |
| CSfx::ExplicitOperator | Some prototype |
| Cdbpp::FileDataStore | Specify the DataStore file (save simulation results) |
| CSfx::FiniteDifferenceDerivative | First derivative at second and fourth order. provide a stencil concept to evaluate derivative without spurious oscillations (ENO: Essentially Non-Oscillatory |
| Cdbpp::FiniteDifferenceModel | "Model of Explicit scheme with time integration algorithm. Finite difference model a numerical representation of the math equations |
| Cdbpp::FiniteVolumeDiscretization | Global discretized domain is defined as a set of all nodes and all elements. PHYSICAL ENTITIES include nodes and elements Node <-— Cell; i.e., element depends on node Omega = { all Node, all Cell }; global discretized domain is defined as a set of all nodes and all elements |
| Cdbpp::FirstDerivative | Compute first derivative at second-order (finite difference) |
| Cdbpp::FluxAlgorithm | Abstract base class for numerical flux algorithm |
| Cdbpp::HLLFluxAlgorithm | Numerical flux algorithm based on HLL (Harten-Lax_Levy) |
| Cdbpp::NujicFluxAlgorithm | Numerical flux algorithm based on Nujic (1995) paper. ENO type scheme (Roe simplified version) |
| Cdbpp::Ptr2FLegacyFluxAlgorithm | Numerical Face Flux Algorithm (Legacy code support Pointer-2-Function) |
| Cdbpp::FluxTensor | Flux tensor field (aggregate initialization) |
| Cdbpp::FluxTensorMap | Map cell face and flux values |
| Cdbpp::Gamma | Boundary condition |
| Cdbpp::HLLFlux1D | "Model of" F_j +/- 1/2 numerical scheme at the cell interface. This class represents the HLL (Harten-Lax-Leer) solving algorithm (based on Riemann approximate solver) |
| Cdbpp::HLLParameterStruct | Algorithm parameters HLL Algorithm |
| Cdbpp::HLLSolver1D::hllParams | Aggregate that hold hll algorithm parameters |
| Cdbpp::HLLPhysicalFlux | |
| Cdbpp::HLLSolver1D | Riemann solver that belongs to Approximate Riemann solver. Solve the Riemann problem at cell Face. Riemann problem u want to set which is made of discontinuity and state vector (left/right) Shall return a map with key = cellFaceID and value is flux face (FF1,FF2) |
| CSfx::HOperator | |
| CSfx::LDeltaOperator | Responsible to evaluate the spatial terms according to spatial discretization. The HOperator provides type and method to compute numerically the different terms of the right-hand-side of the equation. It also provide numerical container used for fast floating-point operation |
| CSfx::IFileDataStore | |
| CTestvs19::FileDataStore | File based implementation of the DataStore interface. This class makes use of the toString() method defined in the PhysicalMeasurement interface |
| CSfx::IFinalReport | |
| CTestvs19::FileFinalReport | Defines a simple way of reporting final statistics or calculations that occured in the simulation. To define the usage of a FinalReport implement the following in the Simulation.properties file in the following manner: FinalReportClass=Report DoFinalReport=true |
| CSfx::IListBase | |
| CTestvs19::ListSectionsFlow< dbpp::SectionFlow > | |
| CTestvs19::ListSectionsFlow< T > | List of physical objects under study |
| CSfx::ILogger | |
| CSfx::Logger | Class to output a message log file. Singleton base class manage the creation/deletion of the logger. That the instance function returns a pointer to a static variable and thus is declared static. Only the class function Instance can call the constructor. Public access to the constructor is denied. The constructor, copy constructor and assignment operator are all private to ensure that the programmer using the singleton class can only create a single instance of the class using only the Instance() function. The life of the singleton instantiation is for the duration of the application |
| CSfx::IPhysicalAlgorithm | |
| CTestvs19::EmcilAlgorithm | Algorithm that take care of the physics that we want to simulate. For example, Nujic in his article treat numerically pressure, source and flux depending on the physics |
| CTestvs19::ValidateAlgo | Implement the physical algorithm that we use to validate our prototype within the Dam-Break simulation. Solve the ODE system by an explicit model. Spatial operator (right-hand-side) U_t = L_x of the St-Venant equations |
| CSfx::IPhysicalConfiguration | |
| CTestvs19::DamBreakSetup | Set up initial condition for DamBreak problem |
| CSfx::IPhysicalMeasurement | |
| CTestvs19::DamBreakMeasureAQH | Physical measure taken in the Physical system We are still experimenting we our new API that is under construction |
| Cdbpp::isHomogeneous< T, TN > | Check if types are identical using fold expression |
| CSfx::ListIterator | |
| CTestvs19::ListSectionsIterator< T > | List iterator on list of sections flow |
| Cdbpp::ListSectionsFlow | List of cross-section flow (itereable) |
| Cdbpp::ManningFormula | Manning formula (friction law) Sf = g*n1*n1*V1*::fabs(V1)/A*A::pow(R1, 4./3.); |
| Cdbpp::MinMod19< T > | Minmod limiter function for slope limiting gradient evaluation |
| Cdbpp::MUSCLReconstr | |
| Cdbpp::NodalTpl< Params > | Implementation for nodal variable concept used in our application (use of variadic template) |
| Cdbpp::NujicIntegrator | Belongs two-step integrator Runge-Kutta family |
| Cdbpp::NumericalMethod | Mapping between continuum and discrete domain. Transformation of the differential or integral equations to discrete algebraic equations involving the values of the unknowns at the mesh points. The basis of all numerical methods consists of this transformation of the physical euations into an algebraic, linear or non-linear, systems of equations |
| CTestvs19::Numethod_f | This is a prototype!! just experimenting some implementation |
| Cdbpp::GodunovTypeScheme | Abstract base class for Godunov-type scheme (Model of). This is a model of an explicit scheme U_i = U_i - lambda*{F (UL_i+1/2,UR_i+1/2) - F(UL_i-1/2, UR_i-1/2) } Numerical representation of the mathematical model equivalent of conservation system law () |
| Cdbpp::Rk2HllScheme | Algorithm based on the Godunov-type Scheme (explicit). We use a two-time steps integrator belongs to Runge-Kutta family and the HLL algorithm for convective flux evaluation. Order is achieved by MUSCL reconstruction procedure to extrapolate state variables at cell face j+1/2 (piecewise-constant state variable on each cell). This algorithm solve at cell-face a Riemann problem (system of conservation law coupled with 2-state tied by a discontinuity define a Riemann Problem) |
| Cdbpp::SemiDiscreteMethod | MOL (Method-of-lines) spatial and time discretization done separetly. Model of the following equation (ODE) U_t = L_delta(U;t);
where L_delta (spatial operator) contains derivative of some variable and describe the evolution of this variable (time evolution). ODE: Ordinary Differential Equation |
| CSfx::Object | |
| CSfx::Logger | Class to output a message log file. Singleton base class manage the creation/deletion of the logger. That the instance function returns a pointer to a static variable and thus is declared static. Only the class function Instance can call the constructor. Public access to the constructor is denied. The constructor, copy constructor and assignment operator are all private to ensure that the programmer using the singleton class can only create a single instance of the class using only the Instance() function. The life of the singleton instantiation is for the duration of the application |
| CTestvs19::RetRhsType | Wrapper data type used as RHS (right-hand-side) return structure |
| CTestvs19::RhsType | |
| CSfx::Observable | |
| CTestvs19::DamBreakSystem | Physical system under study (physical object) |
| Cdbpp::PhysicalSystem | Physical system made of physical objects under study and described by the state variables. DamBreak physical system, physical objects are cross-sectional flow. Dynamic equations that describe the movement of the flow of water under gravity law, pressure and friction are described by the St-Venant set of equations. In conservative form mass and momentum are the quantity conserved across each section (state variables) |
| CSfx::Observer | |
| CTestvs19::Wave1DSimulator | Wave simulator (simulate dam-break wave propagation) implementation |
| CTestvs19::WaveSimulator | Wave simulator (simulate dam-break wave propagation) |
| Cdbpp::VS19WaveSimulator | DamBreak simulator base class (Wave Simulator) |
| Cdbpp::ODESolver1D | Base class ODE Solver (under construction) |
| Cdbpp::Omega | Global Domain (part of global discretization) list of elements and geomeric nodes used by numerical method |
| CSfx::PhysicalAlgorithm | Abstract class provide an interface with services to implement physical based algorithm to solve st-Venant equations in a conservative form (divergence). Numerical integrate the numerical model in time ... advance ... to be completed |
| CTestvs19::BaseRhsPhysicsAlgorithm | Base RHS terms algoritm (support legacy code) |
| CTestvs19::BaseTypesPhysicsAlgorithm | First implementation from the re-factoring VS15 to VS19 (C++20) |
| CTestvs19::EMcNeilAlgorithm | Concept of physical algoritm using components (set numerical method). This allow to program complex algorithms quickly by components. In project require to prototype according to physics assumptions. Each of these components are programmed or support a wide (large) implementation of discretization. For example, Nujic 1995 propose to use ENO techniques to compute flux and some source special treatment to take account ... Model of an explicit conservative scheme with source terms (energy and bed slope). Switch components to re-configure the algorithm (Nujic flux) but E. McNeil use HLL. This kind of flexibility must be supported particularly in industrial projects since ... to be completed |
| CTestvs19::NujicPhysicsAlgorithm | Nujic (1995) physics algorithm with assumptions ... . source treatment (slope bottom term) based on physics ... to be completed see prototype VS2015 for an imp |
| CTestvs19::ProtoPhysicalAlgorithm | Concept of physical algoritm using components (set numerical method). This allow to program complex algorithms quickly by components. In project require to prototype according to physics assumptions. Each of these components are programmed or support a wide (large) implementation of discretization. For example, Nujic 1995 propose to use ENO techniques to compute flux and some source special treatment to take account ... Model of an explicit conservative scheme with source terms (energy and bed slope). Switch components to re-configure the algorithm (Nujic flux) but E. McNeil use HLL. This kind of flexibility must be supported particularly in industrial projects since ... to be completed |
| Cdbpp::PhysicalBoundaryCnd | Physical boundary condition (computational domain) based on characteristic equation .. |
| CSfx::PhysicalConfigure | Responsible to set initial configuration of the physical system (e.g. initial condition) |
| CTestvs19::DamBreakSysConfigure | Class that profide a method to configure physical system. The configuration of a physical system is done before any operations or measurements are performed on the physical system. The class that will be used by the simulation should be defined in the Simulation.properties file in the following manner: PhysicalConfigurationClass=InitialSetup |
| Cdbpp::PhysicalMeasurement | Measure taken on the physical system (defines the required method for the Measurement bean). Still under development, physical state variables are the only measured quantities relevant for this simulation. we may be interested by energy slope, ... any other physics qty |
| CSfx::PhysicalMeasurement | Physical measuremt taken on physical system (e.g. energy, friction, ...) |
| CTestvs19::DamBreakSysMeasurement | This interface defines the required method for the Measurement bean. The user will define the necessary get and set methods for the bean on the quantities that are being measured as in the following example: ... public void setTotalEnergy(double E) { this.E = E; } |
| CSfx::PhysicalSystem | |
| CTestvs19::DamBreakSystem | Physical system under study (physical object) |
| CSfx::SectionGeometryHandler::ProprietesGeometriquesSection | |
| Cdbpp::RiemannProblem | System of conservation Law with an initial discontinuity in it. Two states connected by a left and right state which can be represented constant piecewise function over each cell where shock propagate (a cell face define a discontinuity) |
| CSfx::SCLEquation | |
| CSfx::StVenant1D | Shallow-water (one-dimension) is a system of conservation laws. Conserved quantities (state variables) are the mass and the momentum. It's the differential form of Newton law (f=ma) but for a mass of fluid in a movement under gravity. Forces that act on the mass of fluid are friction, gravity and pressure |
| Cdbpp::SectionFlow | Cross-sectional flow (2-dimensional) |
| CSfx::SectionGeometryHandler | |
| Cdbpp::SemiDiscreteScheme | Under construction .. |
| CSfx::SfxSingleton | |
| CSfx::Simulation | Bean that represents a simulation in the framework. Many of the attributes of the simulation bean are defined in the Simulation.properties file by the user of the framework. The Controller class uses the simulation bean to control the creation of the correct classes for the simulation |
| CSfx::SimulationMgr | Global instance of the simulation. Hold the different parameters of run (simulation parameters). Use the CRTP (Curious Recursive Template Pattern) known as static polymorphism) |
| CSfx::Simulation::SimProp | Property loaded at initialization (from file, user) Struct that hold parameters for the current simulation. At the end of the simulation these parameters will be saved (as a scenario) that could be retrieved later to run the scenario (it's not all clear in mind, but it will be part of the scenario concept) |
| CSfx::Simulator | |
| CDamBreakSim | Base class for simulating the Dam Break Problem |
| CTestvs19::Wave1DSimulator | Wave simulator (simulate dam-break wave propagation) implementation |
| CTestvs19::WaveSimulator | Wave simulator (simulate dam-break wave propagation) |
| Cdbpp::DamBreakWaveSimulator | Abstract class that serve as base class intending to implement dam break wave simulator |
| Cdbpp::VS19WaveSimulator | DamBreak simulator base class (Wave Simulator) |
| CSfx::Singleton | |
| CSfx::DbgLogger | Helper utility that save result to a file to be used for debugging and visualizing |
| CSfx::Logger | Class to output a message log file. Singleton base class manage the creation/deletion of the logger. That the instance function returns a pointer to a static variable and thus is declared static. Only the class function Instance can call the constructor. Public access to the constructor is denied. The constructor, copy constructor and assignment operator are all private to ensure that the programmer using the singleton class can only create a single instance of the class using only the Instance() function. The life of the singleton instantiation is for the duration of the application |
| Cdbpp::SrcNumericalTreatment | Basic algorithm to evaluate source terms (bed slope and energy slope) The Manning formula can be read as follow: |
| CTestvs19::NujicSrcTermAlgorithm | "Model of" function object (called functor). Calculate the "S0" .... slope term |
| CTestvs19::SbSfTermsEvaluation | Wrapper of legacy code. Usage: SbSfTermsEvaluation w_S0Sf{listSections,bc1,bc2}; auto w_SfS0 = w_S0Sf.TraitementTermeS2(aField1,aField2); auto& w_rhs = m_rhsAlgo.getRHS(); w_rhs.m_swerhs.S = std::move(w_SfS0); |
| Cdbpp::SrcTreatmentS2 | Implementation using a different formula for Manning coefficient |
| CSfx::FiniteDifferenceDerivative::stencil | |
| CSfx::StVenant1DTerms | One-dimensional St-Venant equation spatial terms |
| CSfx::LDeltaOperator::SWE_RHS | Data structure RHS terms |
| Cdbpp::SweLDeltaOperator | To be completed ... see Swe_LDeltaOperator as base implementation U1n12 = w_LdeltaOp->applyTo(arr U1. arr U2).massEq(); // n+1/2 time step U1n12 = w_LdeltaOp->applyTo(arr U1. arr U2).momentumEq(); // ditto |
| Cdbpp::SweRhsAlgorithm | Abstract class. "Model" of the right-hand-side terms discretization. Hold discretization scheme or algorithm to be applied on each of them |
| Cdbpp::RhsHLLFluxSrc | Physics algorithm based on Nujic paper (1995), but use HLL (Harten-Lax-van Leer) for convective flux solver (E. McNeil) |
| Cdbpp::RhsPtr2FuncFlux | Wrappper class to support legacy code (C-functions) |
| Cdbpp::SweRhsData< T, CONT > | Aggregate (must support operator[]) |
| Cdbpp::SweRhsDataP | Inherited aggregate (extended), add pressure term data |
| CSfx::TwoStepIntegrator | |
| CTestvs19::Nujic2StepsIntegrator | Numerical integration by two-steps Rungde-Kutta (second-order) |
| Cdbpp::Uh | Container of nodal variables |
| CSfx::EMcNeilBndCnd::UpstreamCelerity | Aggregate that hold celerity wave upstream (characteristic) |
| CSfx::FiniteDifferenceDerivative::vector | |
1.14.0