conservative_object

type, public, abstract :: conservative_object

Convervative object class.

Inherited By

Help

Type-Bound Procedures

procedure(symmetric_operator), public, deferred, pass(lhs) :: add

Operator +.

function symmetric_operator(lhs, rhs) result(operator_result) Prototype

Symmetric operator cons.op.cons.

Arguments

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

Return Value class(conservative_object), allocatable

Operator result.

procedure(array_interface), public, deferred, pass(self) :: array

Return serialized array of conservative.

pure function array_interface(self) result(array_) Prototype

Return serialized array of conservative.

Arguments

Type Intent Optional Attributes Name

class(conservative_object), 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(compute_fluxes_interface), public, deferred, pass(self) :: compute_fluxes

Compute conservative fluxes.

subroutine compute_fluxes_interface(self, eos, normal, fluxes) Prototype

Compute conservative fluxes.

Arguments

Type	Intent		Name
class(conservative_object),	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(assignment_interface), public, deferred, pass(lhs) :: cons_assign_cons

Operator =.

pure subroutine assignment_interface(lhs, rhs) Prototype

Operator =.

Arguments

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

procedure(cons_operator_real), public, deferred, pass(lhs) :: cons_divide_real

Operator cons / real.

function cons_operator_real(lhs, rhs) result(operator_result) Prototype

Operator cons.op.real.

Arguments

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

Return Value class(conservative_object), allocatable

Operator result.

procedure(symmetric_operator), public, deferred, pass(lhs) :: cons_multiply_cons

Operator *.

function symmetric_operator(lhs, rhs) result(operator_result) Prototype

Symmetric operator cons.op.cons.

Arguments

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

Return Value class(conservative_object), allocatable

Operator result.

procedure(cons_operator_real), public, deferred, pass(lhs) :: cons_multiply_real

Operator cons * real.

function cons_operator_real(lhs, rhs) result(operator_result) Prototype

Operator cons.op.real.

Arguments

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

Return Value class(conservative_object), allocatable

Operator result.

procedure(description_interface), public, deferred, pass(self) :: description

Return pretty-printed object description.

pure function description_interface(self, prefix) result(desc) Prototype

Return a pretty-formatted object description.

Arguments

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

Return Value character(len=:), allocatable

Description.

procedure(destroy_interface), public, deferred, pass(self) :: destroy

Destroy conservative.

elemental subroutine destroy_interface(self) Prototype

Destroy conservative.

Arguments

Type Intent Optional Attributes Name

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

procedure(initialize_interface), public, deferred, pass(self) :: initialize

Initialize conservative.

subroutine initialize_interface(self, initial_state) Prototype

Initialize conservative.

Arguments

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

procedure(unary_operator), public, deferred, pass(self) :: negative

Unary operator - cons.

function unary_operator(self) result(operator_result) Prototype

Unary operator .op.cons.

Arguments

Type Intent Optional Attributes Name

class(conservative_object), 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.

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	self	Conservative.

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.

Type	Intent	Optional	Attributes		Name
class(conservative_compressible),	intent(in)			::	self	Conservative.

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(unary_operator), public, deferred, pass(self) :: positive

Unary operator + cons.

function unary_operator(self) result(operator_result) Prototype

Unary operator .op.cons.

Arguments

Type Intent Optional Attributes Name

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

Return Value class(conservative_object), allocatable

Operator result.

procedure(pressure_interface), public, deferred, pass(self) :: pressure

Return pressure value.

elemental function pressure_interface(self, eos) result(pressure_) Prototype

Return pressure value.

Arguments

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

Return Value real(kind=R8P)

Pressure value.

procedure(real_operator_cons), public, deferred, pass(rhs) :: real_multiply_cons

Operator real * cons.

function real_operator_cons(lhs, rhs) result(operator_result) Prototype

Operator real.op.cons.

Arguments

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

Return Value class(conservative_object), allocatable

Operator result.

procedure(symmetric_operator), public, deferred, pass(lhs) :: sub

Operator -.

function symmetric_operator(lhs, rhs) result(operator_result) Prototype

Symmetric operator cons.op.cons.

Arguments

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

Return Value class(conservative_object), allocatable

Operator result.

procedure(velocity_interface), public, deferred, pass(self) :: velocity

Return velocity vector.

elemental function velocity_interface(self) result(velocity_) Prototype

Return velocity vector.

Arguments

Type Intent Optional Attributes Name

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

Return Value type(vector)

Velocity vector.

Source Code

type, abstract :: conservative_object
   !< Convervative object class.
   contains
      ! deferred methods
      procedure(array_interface),          pass(self), deferred :: array              !< Return serialized array of conservative.
      procedure(compute_fluxes_interface), pass(self), deferred :: compute_fluxes     !< Compute conservative fluxes.
      procedure(description_interface),    pass(self), deferred :: description        !< Return pretty-printed object description.
      procedure(destroy_interface),        pass(self), deferred :: destroy            !< Destroy conservative.
      procedure(initialize_interface),     pass(self), deferred :: initialize         !< Initialize conservative.
      procedure(pressure_interface),       pass(self), deferred :: pressure           !< Return pressure value.
      procedure(velocity_interface),       pass(self), deferred :: velocity           !< Return velocity vector.
      procedure(assignment_interface),     pass(lhs),  deferred :: cons_assign_cons   !< Operator `=`.
      procedure(cons_operator_real),       pass(lhs),  deferred :: cons_divide_real   !< Operator `cons / real`.
      procedure(symmetric_operator),       pass(lhs),  deferred :: cons_multiply_cons !< Operator `*`.
      procedure(cons_operator_real),       pass(lhs),  deferred :: cons_multiply_real !< Operator `cons * real`.
      procedure(real_operator_cons),       pass(rhs),  deferred :: real_multiply_cons !< Operator `real * cons`.
      procedure(symmetric_operator),       pass(lhs),  deferred :: add                !< Operator `+`.
      procedure(unary_operator),           pass(self), deferred :: positive           !< Unary operator `+ cons`.
      procedure(symmetric_operator),       pass(lhs),  deferred :: sub                !< Operator `-`.
      procedure(unary_operator),           pass(self), deferred :: negative           !< Unary operator `- cons`.
      ! operators
      generic :: assignment(=) => cons_assign_cons                                         !< Overload `=`.
      generic :: operator(+) => add, positive                                              !< Overload `+`.
      generic :: operator(-) => sub, negative                                              !< Overload `-`.
      generic :: operator(*) => cons_multiply_cons, cons_multiply_real, real_multiply_cons !< Overload `*`.
      generic :: operator(/) => cons_divide_real                                           !< Overload `/`.
endtype conservative_object

conservative_object Derived Type

Type-Bound Procedures

Source Code

All Derived Types

type, public, abstract :: conservative_object

Inherited By

Type-Bound Procedures

Source Code

Type-Bound Procedures

procedure(symmetric_operator), public, deferred, pass(lhs) :: add

function symmetric_operator(lhs, rhs) result(operator_result) Prototype

Arguments

Return Value class(conservative_object), allocatable

procedure(array_interface), public, deferred, pass(self) :: array

pure function array_interface(self) result(array_) Prototype

Arguments

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

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

private pure subroutine cons_assign_cons(lhs, rhs)

Arguments

procedure(compute_fluxes_interface), public, deferred, pass(self) :: compute_fluxes

subroutine compute_fluxes_interface(self, eos, normal, fluxes) Prototype

Arguments

procedure(assignment_interface), public, deferred, pass(lhs) :: cons_assign_cons

pure subroutine assignment_interface(lhs, rhs) Prototype

Arguments

procedure(cons_operator_real), public, deferred, pass(lhs) :: cons_divide_real

function cons_operator_real(lhs, rhs) result(operator_result) Prototype

Arguments

Return Value class(conservative_object), allocatable

procedure(symmetric_operator), public, deferred, pass(lhs) :: cons_multiply_cons

function symmetric_operator(lhs, rhs) result(operator_result) Prototype

Arguments

Return Value class(conservative_object), allocatable

procedure(cons_operator_real), public, deferred, pass(lhs) :: cons_multiply_real

function cons_operator_real(lhs, rhs) result(operator_result) Prototype

Arguments

Return Value class(conservative_object), allocatable

procedure(description_interface), public, deferred, pass(self) :: description

pure function description_interface(self, prefix) result(desc) Prototype

Arguments

Return Value character(len=:), allocatable

procedure(destroy_interface), public, deferred, pass(self) :: destroy

elemental subroutine destroy_interface(self) Prototype

Arguments

procedure(initialize_interface), public, deferred, pass(self) :: initialize

subroutine initialize_interface(self, initial_state) Prototype

Arguments

procedure(unary_operator), public, deferred, pass(self) :: negative

function unary_operator(self) result(operator_result) Prototype

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)

Arguments

Return Value class(conservative_object), allocatable

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

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

Arguments

Return Value class(conservative_object), allocatable

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