hydrodynamics_2d.hpp

Go to the documentation of this file.

#ifndef HYDRODYNAMICS_2D_HPP
#define HYDRODYNAMICS_2D_HPP 1

#include "spatial_distribution2d.hpp"
#include "../common/equation_of_state.hpp"
#include "point_motion.hpp"
#include "spatial_reconstruction.hpp"
#include "SourceTerm.hpp"
#include "../../misc/utils.hpp"
#include "../../misc/lazy_list.hpp"
#include "../common/hydrodynamics.hpp"
#include "../../misc/universal_error.hpp"
#include "../../tessellation/ConvexHull.hpp"
#include "../../tessellation/polygon_overlap_area.hpp"
#include <boost/scoped_ptr.hpp>
#include "../../tessellation/EdgeLengthCorrect.hpp"
#include "physical_geometry.hpp"
#include "time_step_function.hpp"
#include "cache_data.hpp"
#include "../common/riemann_solver.hpp"

Primitive RotatePrimitive(const Vector2D& normaldir,
                          const Vector2D& paraldir,
                          const Primitive& p);

Conserved RotateFluxBack(const Conserved& c,
        const Vector2D& n,
        const Vector2D& p);

int get_other_index(const Edge& edge,
        const int index);

vector<Primitive> InitialiseCells
(SpatialDistribution const& density,
        SpatialDistribution const& pressure,
        SpatialDistribution const& xvelocity,
        SpatialDistribution const& yvelocity,
        EquationOfState const& eos,
        Tessellation const& tess, bool CMvalue = true);

vector<Conserved> CalcConservedIntensive
(vector<Primitive> const& cells);

vector<Conserved> CalcConservedExtensive
(const vector<Conserved>& cons_int,
        const Tessellation& tess,
        const PhysicalGeometry& pg);

double TimeStepForCell(Primitive const& cell,
        double width, vector<Vector2D> const& face_velocites);

vector<int> MoveMeshPoints(vector<Vector2D> const& pointvelocity,
        double dt, Tessellation& tessellation, bool reorder,
        vector<Vector2D> oldpoints = vector<Vector2D>());
vector<int> MoveMeshPoints(vector<Vector2D> const& pointvelocity,
        double dt, Tessellation& tessellation, Tessellation const& vproc, bool reorder,
        vector<Vector2D> oldpoints = vector<Vector2D>());

vector<Conserved> calc_conserved_intensive
(const Tessellation& tess,
        const vector<Conserved>& extensive,
        const PhysicalGeometry& pg);

void UpdateConservedIntensive(Tessellation const& tessellation,
        vector<Conserved> const& conservedextensive,
        vector<Conserved>& conservedintensive);

Conserved FluxInBulk(Vector2D const& normaldir,
        Vector2D const& paraldir,
        Primitive const& left,
        Primitive const& right,
        Vector2D const& edge_velocity,
        RiemannSolver const& rs);

void ExternalForceContribution
(const Tessellation& tess,
        const PhysicalGeometry& pg,
        const CacheData& cd,
        const vector<ComputationalCell>& cells,
        const vector<Extensive>& fluxes,
        const vector<Vector2D>& point_velocities,
        const SourceTerm& source,
        double t,
        double dt,
        vector<Extensive>& extensives,
        TracerStickerNames const& tracerstickernames);

vector<Vector2D> get_all_mesh_points
(Tessellation const& tess);

vector<Primitive> make_eos_consistent
(vector<Primitive> const& vp,
        EquationOfState const& eos);

vector<double> GetForceEnergy(Tessellation const& tess,
        vector<double> const& g);

vector<vector<double> > calc_extensive_tracer
(const vector<vector<double> > & intensive_tracer,
        const Tessellation& tess,
        const vector<Primitive>& cells,
        const PhysicalGeometry& pg);

void MakeTracerExtensive
(vector<vector<double> > const&tracer,
        Tessellation const& tess, vector<Primitive> const& cells,
        vector<vector<double> > &result);

void GetPointToRemove(Tessellation const& tess, Vector2D const& point,
        double R, vector<int> & PointToRemove, int Inner);

void FixAdvection(vector<Conserved>& extensive,
        vector<Conserved> const& intensive,
        Tessellation const& tessold,
        Tessellation const& tessnew,
        vector<Vector2D> const& facevelocity,
        double dt, vector<Vector2D> const& pointvelocity);

double determine_time_step(double hydro_time_step,
        double external_dt,
        double current_time,
        double end_time);

#endif // HYDRODYNAMICS_2D_HPP