basis – B-spline Basis Function Library

type, public :: basis

Spline basis function class

Procedures assume basis with open knot vector

Components

Type	Visibility	Attributes		Name
integer,	public		::	p	Polynomial degree $p$
integer,	public		::	nk	Number of the knots
integer,	public		::	m	The highest index of the knots `( nk-1 )`
integer,	public		::	nb	Number of basis functions
integer,	public		::	n	The highest index of the basis functions `( nb-1 )`
real(kind=wp),	public,	allocatable	::	kv(:)	Open knot vector `kv(0:m)` $= \left\{u_{0},..., u_{m}\right\}$
real(kind=wp),	public,	allocatable	::	unik(:)	Unique knot values
integer,	public,	allocatable	::	mult(:)	Multiplicity of each unique knot value
integer,	public		::	minreg	Minimum reqularity of the basis functions,`= me%p-max(me%mult(2:ubound(me%mult)-1)`
integer,	public		::	maxreg	Maximum reqularity of the basis functions,`= me%p-min(me%mult(2:ubound(me%mult)-1)`
integer,	public		::	nbez	Number of elements with nonzero measure, i.e., number of Bezier segments

Constructor

public interface basis

Spline basis constructor

private pure function basisConstructor(nk, p, k) result(me)

Arguments

Type	Intent		Name
integer,	intent(in)	::	nk	Number of the knots
integer,	intent(in)	::	p	Polynomial degree $p$
real(kind=wp),	intent(in)	::	k(nk)	Open knot vector `kv(0:m)` $= \left\{u_{0},..., u_{m}\right\}$

Return Value type(basis)

Spline basis object

Type-Bound Procedures

procedure, public :: FindSpan

Knot span index search

private pure elemental function FindSpan(me, u) result(span)

This procedure is an elemental function and does a binary search and return the integer :: span value, where $u$ lies on. Note that, indexing starts with zero. If $u=u_{m}$ , the index is $n (= m - p - 1)$ , i.e., $u \in {(u_{n}, u_{nb}]}$ , where "nb $(= n+1)$ " is number of control points of the univariate spline basis object.
Read more…
Arguments

Type Intent Optional Attributes Name

class(basis), intent(in) :: me

real(kind=wp), intent(in) :: u
Given $u$ value

Return Value integer

Knot span index of $u$ value

procedure, public :: FindMult

Knot multiplicity computation

private pure elemental function FindMult(me, i, u) result(mult)

Computes the multiplicity of a knot

Arguments

Type	Intent		Name
class(basis),	intent(in)	::	me
integer,	intent(in)	::	i	Starting index for search
real(kind=wp),	intent(in)	::	u	Given $u$ value

Return Value integer

Multiplicity of $u$ value

procedure, public :: FindSpanMult

Knot span and multiplicity computation

private pure elemental subroutine FindSpanMult(me, u, k, s)

Computes the span and multiplicity of a knot

Arguments

Type	Intent		Name
class(basis),	intent(in)	::	me
real(kind=wp),	intent(in)	::	u	Given $u$ value
integer,	intent(out)	::	k	Knot span index of $u$ value
integer,	intent(out)	::	s	Multiplicity of $u$ value

procedure, public :: BasisFuns

Computation of the non-vanishing basis functions

private pure subroutine BasisFuns(me, u, N, span)

Computes the nonvanishing basis functions based on Algorithm A2.2 in the NURBS Book ¹.

Arguments

Type	Intent	Optional		Name
class(basis),	intent(in)		::	me
real(kind=wp),	intent(in)		::	u	Given $u$ value
real(kind=wp),	intent(out)		::	N(0:me%p)	$= \{ N_{i-p,p}(u) \ldots N_{i,p}(u)\}$
integer,	intent(in),	optional	::	span	Knot span where $u$ lies on

procedure, public :: OneBasisFun

Computation of a single basis function

private pure elemental function OneBasisFun(me, i, u) result(Nip)

Computes a single basis function, $N_{i,p}(u)$ .

Arguments

Type	Intent		Name
class(basis),	intent(in)	::	me
integer,	intent(in)	::	i	Basis function index
real(kind=wp),	intent(in)	::	u	Given $u$ value

Return Value real(kind=wp)

$N_{i,p}(u)$

procedure, public :: AllBasisFuns

Computation of a all non-zero basis function of all degrees from $0$ up to $p$

private pure subroutine AllBasisFuns(me, u, N, span)

Computes all non-zero basis function of all degrees from $0$ up to $p$ .

Arguments

Type	Intent	Optional		Name
class(basis),	intent(in)		::	me
real(kind=wp),	intent(in)		::	u	Given $u$ value
real(kind=wp),	intent(out)		::	N(0:me%p,0:me%p)	$= \begin{bmatrix} {N_{i - p,0}(u)} & \cdots &{N_{i - p,p}(u)}\\ \vdots & \ddots & \vdots \\ {N_{i,0}(u)} & \cdots &{N_{i,p}(u)} \end{bmatrix}$
integer,	intent(in),	optional	::	span	Knot span where $u$ lies on

procedure, public :: DersBasisFuns

Computation of the derivatives of the non-vanishing basis functions

private pure subroutine DersBasisFuns(me, u, n, ders, span)

Computes all nonzero basis functions and their derivatives based on Algorithm A2.3 in the NURBS Book [^1].

Arguments

Type	Intent	Optional		Name
class(basis),	intent(in)		::	me
real(kind=wp),	intent(in)		::	u	Given $u$ value
integer,	intent(in)		::	n	Number of derivatives ( $n \leq p$ )
real(kind=wp),	intent(out)		::	ders(0:me%p,0:n)	$= \begin{bmatrix} {N_{i - p,p}^{(0)}(u)} & \cdots &{N_{i - p,p}^{(k)}(u)}\\ \vdots & \ddots & \vdots \\ {N_{i,p}^{(0)}(u)} & \cdots &{N_{i,p}^{(k)}(u)} \end{bmatrix}$
integer,	intent(in),	optional	::	span	Knot span where $u$ lies on

procedure, public :: DersOneBasisFun

Computation of the the derivatives of a single basis function

private pure subroutine DersOneBasisFun(me, i, u, n, ders)

Computes a single basis function and its derivatives based on Algorithm A2.5 in the NURBS Book [^1].

Arguments

Type	Intent		Name
class(basis),	intent(in)	::	me
integer,	intent(in)	::	i	Basis function index
real(kind=wp),	intent(in)	::	u	Given $u$ value
integer,	intent(in)	::	n	Number of derivatives ( $n \leq p$ )
real(kind=wp),	intent(out)	::	ders(0:n)	$= \{ N_{i,p}^{(0)}(u), \ldots, N_{i,p}^{(k)}(u) \}$

procedure, public :: InsertKnot

Knot insertion of a given knot into the knot vector

private pure subroutine InsertKnot(me, u, r, span)

Insert knot $\bar{u}$ into ${[u_{k}, u_{k+1})}$ $r$ times.

Arguments

Type	Intent	Optional		Name
class(basis),	intent(inout)		::	me
real(kind=wp),	intent(in)		::	u	knot value $\bar{u}$
integer,	intent(in)		::	r	multiplicity of new knot value
integer,	intent(in),	optional	::	span	knot span

procedure, public :: UpdateBasis

Updating the basis (the same contents with constructor)

private pure subroutine UpdateBasis(me, nk, k, p)

Updates all component of the basis according to input knot vector.

Arguments

Type	Intent	Optional		Name
class(basis),	intent(inout)		::	me
integer,	intent(in)		::	nk	Number of the knots
real(kind=wp),	intent(in)		::	k(nk)	New knot vector
integer,	intent(in),	optional	::	p	New basis degree

procedure, public :: BSegments

Computation of the segments' data of the basis

private pure subroutine BSegments(me, nb, knots)

Returns the number of Bezier segments, integer :: nb, of the basis and the real(wp) :: knots(:) array containing the unique values of the knot vector.

Arguments

Type	Intent	Optional	Attributes		Name
class(basis),	intent(in)			::	me
integer,	intent(out)			::	nb	Number of Bezier segments
real(kind=wp),	intent(out),	optional	allocatable	::	knots(:)	The unique knot values

procedure, public :: ParLen

Get the length of parameter space

private pure function ParLen(me) result(len)

Return the length of the parameter space, i.e., $u_{m}-u_{0}$ , where $m$ is the highest index of the knot vector.

Arguments

Type Intent Optional Attributes Name

class(basis), intent(in) :: me

Return Value real(kind=wp)

Length of the parameter space

procedure, public :: GrevilleAbscissae

Computation of the Greville abscissae

private pure function GrevilleAbscissae(me, dsc) result(pt)

Return the Greville abscissae, $\{u_i\}$ , of the knot vector,

Arguments

Type	Intent	Optional	Attributes		Name
class(basis),	intent(in)			::	me
logical,	intent(in),	optional		::	dsc	If true, then the Greville abscissae are modified by shifting the boundary points into the domain

Return Value real(kind=wp) (0:me%n)

The array containing Greville abscissae

procedure, public :: Plot => PlotBasisFunc

Plot basis functions

private subroutine PlotBasisFunc(me, first, last, d, plotRes, title, work, fname, terminal, showPlot)

This subroutine plots the basis functions or their $d$ th order derivatives having index from first to last by computing at interpolation points defined by plotRes, and print the image file into "|cwd|/data/work/fname.ext" if the workspace work is presented, "|cwd|/data/img/fname.ext" if else. Plotting requires GNUPlot installed on your computer. The input parameter terminal set the output terminal of GNUPlot.

Arguments

Type	Intent	Optional		Name
class(basis),	intent(in)		::	me
integer,	intent(in),	optional	::	first	First index to be plotted
integer,	intent(in),	optional	::	last	Last index to be plotted
integer,	intent(in),	optional	::	d	Derivatives degree
integer,	intent(in),	optional	::	plotRes	Resolution of the calculation, Default = 100
character(len=*),	intent(in),	optional	::	title	Title of the graph, Default = "Basis functions"
character(len=*),	intent(in),	optional	::	work	Current work name to create folder
character(len=*),	intent(in),	optional	::	fname	Filename of the .png output, if GNUPlot* terminal is `png`. Default = "BasisFunctions"
character(len=*),	intent(in),	optional	::	terminal	GNUPlot terminal, Default = `wxt`
logical,	intent(in),	optional	::	showPlot	Key to open created `png` files

procedure, public :: get_nquad

Get the number of quadrature points

private pure elemental function get_nquad(me, key, reduced_int, pdeq) result(ngp)

Return the number of quadrature points for a successive integration

Arguments

Type	Intent	Optional		Name
class(basis),	intent(in)		::	me
character(len=*),	intent(in),	optional	::	key	The key defining whether the quadrature is over the Bezier segments or over whole patch Valid inputs: - `"elementwise"` - `"patchwise"`
logical,	intent(in),	optional	::	reduced_int	Reduced integration flag, if true, the routine will return the number of quadrature points for reduced integration
character(len=*),	intent(in),	optional	::	pdeq	Internal name of the relevant partial differential equation Valid inputs: - `"Timoshenko"` - `"Mindlin"` - `"Shell"`

Return Value integer

Source Code

    type :: basis
        !<  
        integer                 ::  p       !< Polynomial degree \(p\)
        integer                 ::  nk      !< Number of the knots
        integer                 ::  m       !< The highest index of the knots ` ( nk-1 ) `
        integer                 ::  nb      !< Number of basis functions
        integer                 ::  n       !< The highest index of the basis functions ` ( nb-1 ) `
        real(wp),   allocatable ::  kv(:)   !< [Open knot vector](../page/01.fooiga/eqns.html#openvec)  
                                            !< ` kv(0:m) ` \( = \left\{u_{0},..., u_{m}\right\} \)
        real(wp),   allocatable ::  unik(:) !< Unique knot values
        integer,    allocatable ::  mult(:) !< Multiplicity of each unique knot value
        integer                 ::  minreg  !< Minimum reqularity of the basis functions,` = me%p-max(me%mult(2:ubound(me%mult)-1)  `
        integer                 ::  maxreg  !< Maximum reqularity of the basis functions,` = me%p-min(me%mult(2:ubound(me%mult)-1)  `
        integer                 ::  nbez    !< Number of elements with nonzero measure, i.e., number of Bezier segments
    contains
        !< Procedures assume basis with **open knot vector**  
        procedure, public   :: FindSpan                 !< **Knot span index search                                                                     **
        procedure, public   :: FindMult                 !< **Knot multiplicity computation                                                              **
        procedure, public   :: FindSpanMult             !< **Knot span and multiplicity computation                                                     **
        procedure, public   :: BasisFuns                !< **Computation of the non-vanishing basis functions                                           **
        procedure, public   :: OneBasisFun              !< **Computation of a single basis function                                                     **
        procedure, public   :: AllBasisFuns             !< **Computation of a all non-zero basis function of all degrees from \(0\) up to \(p\)         **
        procedure, public   :: DersBasisFuns            !< **Computation of the derivatives of the non-vanishing basis functions                        **
        procedure, public   :: DersOneBasisFun          !< **Computation of the the derivatives of a single basis function                              **
        procedure, public   :: InsertKnot               !< **Knot insertion of a given knot into the knot vector                                        **
        procedure, public   :: UpdateBasis              !< **Updating the basis (the same contents with constructor)                                    **
        procedure, public   :: BSegments                !< **Computation of the segments' data of the basis                                             **
        procedure, public   :: ParLen                   !< **Get the length of parameter space                                                          **
        procedure, public   :: GrevilleAbscissae        !< **Computation of the Greville abscissae                                                      **  
        procedure, public   :: Plot => PlotBasisFunc    !< **Plot basis functions                                                                       **
        procedure, public   :: get_nquad                !< **Get the number of quadrature points                                                        **
    end type basis

basis Derived Type

Contents

Variables

Constructor

Type-Bound Procedures

Source Code

type, public :: basis

Contents

Variables

Constructor

Type-Bound Procedures

Source Code

Components

Constructor

public interface basis

private pure function basisConstructor(nk, p, k) result(me)

Arguments

Return Value type(basis)

Type-Bound Procedures

procedure, public :: FindSpan

private pure elemental function FindSpan(me, u) result(span)

Arguments

Return Value integer

procedure, public :: FindMult

private pure elemental function FindMult(me, i, u) result(mult)

Arguments

Return Value integer

procedure, public :: FindSpanMult

private pure elemental subroutine FindSpanMult(me, u, k, s)

Arguments

procedure, public :: BasisFuns

private pure subroutine BasisFuns(me, u, N, span)

Arguments

procedure, public :: OneBasisFun

private pure elemental function OneBasisFun(me, i, u) result(Nip)

Arguments

Return Value real(kind=wp)

procedure, public :: AllBasisFuns

private pure subroutine AllBasisFuns(me, u, N, span)

Arguments

procedure, public :: DersBasisFuns

private pure subroutine DersBasisFuns(me, u, n, ders, span)

Arguments

procedure, public :: DersOneBasisFun

private pure subroutine DersOneBasisFun(me, i, u, n, ders)

Arguments

procedure, public :: InsertKnot

private pure subroutine InsertKnot(me, u, r, span)

Arguments

procedure, public :: UpdateBasis

private pure subroutine UpdateBasis(me, nk, k, p)

Arguments

procedure, public :: BSegments

private pure subroutine BSegments(me, nb, knots)

Arguments

procedure, public :: ParLen

private pure function ParLen(me) result(len)

Arguments

Return Value real(kind=wp)

procedure, public :: GrevilleAbscissae

private pure function GrevilleAbscissae(me, dsc) result(pt)

Arguments

Return Value real(kind=wp) (0:me%n)

procedure, public :: Plot => PlotBasisFunc

private subroutine PlotBasisFunc(me, first, last, d, plotRes, title, work, fname, terminal, showPlot)

Arguments

procedure, public :: get_nquad

private pure elemental function get_nquad(me, key, reduced_int, pdeq) result(ngp)

Arguments

Return Value integer

Source Code