conservative_compressible

type, public, extends(conservative_object) :: conservative_compressible

Help

Convervative compressible object class.

Inherited By

Help

Variables

density energy momentum

Constructor

conservative_compressible

Source Code

conservative_compressible

Components

Type	Visibility		Name		Initial
real(kind=R8P),	public	::	density	=	0._R8P	Density, `rho`.
real(kind=R8P),	public	::	energy	=	0._R8P	Energy, `rho * E`, `rho` being the density and `E` the specific energy.
type(vector),	public	::	momentum			Momentum, `rho * v`, `rho` being the density and `v` the velocity vector.

Constructor

public interface conservative_compressible

Overload conservative_compressible name with its constructor.

private elemental function conservative_compressible_instance(density, momentum, energy) result(instance)

Return and instance of conservative_compressible.

Arguments

Type	Intent	Optional		Name
real(kind=R8P),	intent(in),	optional	::	density	Density, `rho`.
type(vector),	intent(in),	optional	::	momentum	Momentum, `rho * v`, `rho` being the density and `v` the velocity vector.
real(kind=R8P),	intent(in),	optional	::	energy	Energy, `rho * E`, `rho` being the density and `E` the specific energy.

Return Value type(conservative_compressible)

Instance of conservative_compressible.

Type-Bound Procedures

procedure, public, pass(lhs) :: add

Operator +.

private function add(lhs, rhs) result(operator_result)

Operator +.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(self) :: array

Return serialized array of conservative.

private pure function array(self) result(array_)

Return serialized array of conservative.

Arguments

Type Intent Optional Attributes Name

class(conservative_compressible), intent(in) :: self
Conservative.

Return Value real(kind=R8P), allocatable, (:)

Serialized array of conservative.

generic, public :: assignment(=) => cons_assign_cons

Overload =.

private pure subroutine cons_assign_cons(lhs, rhs)

Operator =.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(inout)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

procedure, public, pass(self) :: compute_fluxes

Compute conservative fluxes.

private subroutine compute_fluxes(self, eos, normal, fluxes)

Compute conservative fluxes.

Arguments

Type	Intent		Name
class(conservative_compressible),	intent(in)	::	self	Conservative.
class(eos_object),	intent(in)	::	eos	Equation of state.
type(vector),	intent(in)	::	normal	Normal (versor) of face where fluxes are given.
class(conservative_object),	intent(out)	::	fluxes	Conservative fluxes.

procedure, public, pass(self) :: compute_fluxes_from_primitive

Compute conservative fluxes from primitives at interface.

private elemental subroutine compute_fluxes_from_primitive(self, eos, p, r, u, normal)

Compute conservative fluxes from primitives at interface.

Arguments

Type	Intent		Name
class(conservative_compressible),	intent(inout)	::	self	Conservative.
class(eos_object),	intent(in)	::	eos	Equation of state.
real(kind=R8P),	intent(in)	::	p	Pressure at interface.
real(kind=R8P),	intent(in)	::	r	Density at interface.
real(kind=R8P),	intent(in)	::	u	Velocity (normal component) at interface.
type(vector),	intent(in)	::	normal	Normal (versor) of face where fluxes are given.

procedure, public, pass(lhs) :: cons_assign_cons

Operator =.

private pure subroutine cons_assign_cons(lhs, rhs)

Operator =.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(inout)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

procedure, public, pass(lhs) :: cons_divide_real

Operator cons / real.

private function cons_divide_real(lhs, rhs) result(operator_result)

Operator cons / real.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
real(kind=R8P),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(lhs) :: cons_multiply_cons

Operator *.

private function cons_multiply_cons(lhs, rhs) result(operator_result)

Operator *.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(lhs) :: cons_multiply_real

Operator cons * real.

private function cons_multiply_real(lhs, rhs) result(operator_result)

Operator cons * real.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
real(kind=R8P),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(self) :: description

Return pretty-printed object description.

private pure function description(self, prefix) result(desc)

Return a pretty-formatted object description.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	self	Conservative.
character(len=*),	intent(in),	optional		::	prefix	Prefixing string.

Return Value character(len=:), allocatable

Description.

procedure, public, pass(self) :: destroy

Destroy conservative.

private elemental subroutine destroy(self)

Destroy conservative.

Arguments

Type Intent Optional Attributes Name

class(conservative_compressible), intent(inout) :: self
Conservative.

procedure, public, pass(self) :: initialize

Initialize conservative.

private subroutine initialize(self, initial_state)

Initialize conservative.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(inout)			::	self	Conservative.
class(conservative_object),	intent(in),	optional		::	initial_state	Initial state.

procedure, public, pass(self) :: negative

Unary operator - cons.

private function negative(self) result(operator_result)

Unary operator - cons.

Arguments

Type Intent Optional Attributes Name

class(conservative_compressible), intent(in) :: self
Conservative.

Return Value class(conservative_object), allocatable

Operator result.

generic, public :: **operator(*)** => cons_multiply_cons, cons_multiply_real, real_multiply_cons

Overload *.

private function cons_multiply_cons(lhs, rhs) result(operator_result)

Operator *.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

private function cons_multiply_real(lhs, rhs) result(operator_result)

Operator cons * real.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
real(kind=R8P),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

private function real_multiply_cons(lhs, rhs) result(operator_result)

Operator real * cons.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=R8P),	intent(in)			::	lhs	Left hand side.
class(conservative_compressible),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

generic, public :: operator(+) => add, positive

Overload +.

private function add(lhs, rhs) result(operator_result)

Operator +.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

private function positive(self) result(operator_result)

Unary operator + cons.

Arguments

Type Intent Optional Attributes Name

class(conservative_compressible), intent(in) :: self
Conservative.

Return Value class(conservative_object), allocatable

Operator result.

generic, public :: operator(-) => sub, negative

Overload -.

private function sub(lhs, rhs) result(operator_result)

Operator +.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

private function negative(self) result(operator_result)

Unary operator - cons.

Arguments

Type Intent Optional Attributes Name

class(conservative_compressible), intent(in) :: self
Conservative.

Return Value class(conservative_object), allocatable

Operator result.

generic, public :: operator(/) => cons_divide_real

Overload /.

private function cons_divide_real(lhs, rhs) result(operator_result)

Operator cons / real.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
real(kind=R8P),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(self) :: positive

Unary operator + cons.

private function positive(self) result(operator_result)

Unary operator + cons.

Arguments

Type Intent Optional Attributes Name

class(conservative_compressible), intent(in) :: self
Conservative.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(self) :: pressure

Return pressure value.

private elemental function pressure(self, eos) result(pressure_)

Return pressure value.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	self	Conservative.
class(eos_object),	intent(in)			::	eos	Equation of state.

Return Value real(kind=R8P)

Pressure value.

procedure, public, pass(rhs) :: real_multiply_cons

Operator real * cons.

private function real_multiply_cons(lhs, rhs) result(operator_result)

Operator real * cons.

Arguments

Type	Intent	Optional	Attributes		Name
real(kind=R8P),	intent(in)			::	lhs	Left hand side.
class(conservative_compressible),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(lhs) :: sub

Operator -.

private function sub(lhs, rhs) result(operator_result)

Operator +.

Arguments

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	lhs	Left hand side.
class(conservative_object),	intent(in)			::	rhs	Right hand side.

Return Value class(conservative_object), allocatable

Operator result.

procedure, public, pass(self) :: velocity

Return velocity vector.

private elemental function velocity(self) result(velocity_)

Return velocity vector.

Arguments

Type Intent Optional Attributes Name

class(conservative_compressible), intent(in) :: self
Conservative.

Return Value type(vector)

Velocity vector.

Source Code

type, extends(conservative_object) :: conservative_compressible
   !< Convervative compressible object class.
   real(R8P)    :: density=0._R8P !< Density, `rho`.
   type(vector) :: momentum       !< Momentum, `rho * v`, `rho` being the density and `v` the velocity vector.
   real(R8P)    :: energy=0._R8P  !< Energy, `rho * E`, `rho` being the density and `E` the specific energy.
   contains
      ! public methods
      procedure, pass(self) :: compute_fluxes_from_primitive !< Compute conservative fluxes from primitives at interface.
      ! deferred methods
      procedure, pass(self) :: array              !< Return serialized array of conservative.
      procedure, pass(self) :: compute_fluxes     !< Compute conservative fluxes.
      procedure, pass(self) :: description        !< Return pretty-printed object description.
      procedure, pass(self) :: destroy            !< Destroy conservative.
      procedure, pass(self) :: initialize         !< Initialize conservative.
      procedure, pass(self) :: pressure           !< Return pressure value.
      procedure, pass(self) :: velocity           !< Return velocity vector.
      procedure, pass(lhs)  :: cons_assign_cons   !< Operator `=`.
      procedure, pass(lhs)  :: cons_divide_real   !< Operator `cons / real`.
      procedure, pass(lhs)  :: cons_multiply_real !< Operator `cons * real`.
      procedure, pass(lhs)  :: cons_multiply_cons !< Operator `*`.
      procedure, pass(rhs)  :: real_multiply_cons !< Operator `real * cons`.
      procedure, pass(lhs)  :: add                !< Operator `+`.
      procedure, pass(self) :: positive           !< Unary operator `+ cons`.
      procedure, pass(lhs)  :: sub                !< Operator `-`.
      procedure, pass(self) :: negative           !< Unary operator `- cons`.
endtype conservative_compressible

conservative_compressible Derived Type

Source Code

type, public, extends(conservative_object) :: conservative_compressible

Inherited By

Source Code

Components

Constructor

public interface conservative_compressible

private elemental function conservative_compressible_instance(density, momentum, energy) result(instance)

Arguments

Return Value type(conservative_compressible)

Type-Bound Procedures

procedure, public, pass(lhs) :: add

private function add(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

procedure, public, pass(self) :: array

private pure function array(self) result(array_)

Arguments

Return Value real(kind=R8P), allocatable, (:)

generic, public :: assignment(=) => cons_assign_cons

private pure subroutine cons_assign_cons(lhs, rhs)

Arguments

procedure, public, pass(self) :: compute_fluxes

private subroutine compute_fluxes(self, eos, normal, fluxes)

Arguments

procedure, public, pass(self) :: compute_fluxes_from_primitive

private elemental subroutine compute_fluxes_from_primitive(self, eos, p, r, u, normal)

Arguments

procedure, public, pass(lhs) :: cons_assign_cons

private pure subroutine cons_assign_cons(lhs, rhs)

Arguments

procedure, public, pass(lhs) :: cons_divide_real

private function cons_divide_real(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

procedure, public, pass(lhs) :: cons_multiply_cons

private function cons_multiply_cons(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

procedure, public, pass(lhs) :: cons_multiply_real

private function cons_multiply_real(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

procedure, public, pass(self) :: description

private pure function description(self, prefix) result(desc)

Arguments

Return Value character(len=:), allocatable

procedure, public, pass(self) :: destroy

private elemental subroutine destroy(self)

Arguments

procedure, public, pass(self) :: initialize

private subroutine initialize(self, initial_state)

Arguments

procedure, public, pass(self) :: negative

private function negative(self) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

generic, public :: operator(*) => cons_multiply_cons, cons_multiply_real, real_multiply_cons

private function cons_multiply_cons(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

private function cons_multiply_real(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

private function real_multiply_cons(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

generic, public :: operator(+) => add, positive

private function add(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

private function positive(self) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

generic, public :: operator(-) => sub, negative

private function sub(lhs, rhs) result(operator_result)

Arguments

Return Value class(conservative_object), allocatable

private function negative(self) result(operator_result)

generic, public :: **operator(*)** => cons_multiply_cons, cons_multiply_real, real_multiply_cons