esys.modellib.input Package¶

Classes¶

GaussianProfile
InterpolateOverBox
InterpolatedTimeProfile
LinearCombination
LinearPDE
MergeConstraints
Model
ParameterSet
ScalarDistributionFromTags
Sequencer
SmoothScalarDistributionFromTags

class esys.modellib.input.GaussianProfile(**kwargs)¶

Generates a Gaussian profile at center x_c, width width and height A over a domain

Note: Instance variable domain - domain
Note: Instance variable x_c - center of the Gaussian profile (default [0.,0.,0.])
Note: Instance variable A - (in) height of the profile. A maybe a vector. (default 1.)
Note: Instance variable width - (in) width of the profile (default 0.1)
Note: Instance variable r - (in) radius of the circle (default = 0)

In the case that the spatial dimension is two, The third component of x_c is dropped.

__init__(**kwargs)¶: Creates a ParameterSet with given parameters.

out()¶

Generate the Gaussian profile

Link against this method to get the output of this model.

class esys.modellib.input.InterpolateOverBox(**kwargs)¶

Returns values at each time. The values are defined through given values at time node. For two dimensional domains back values are ignored.

Note: Instance variable domain - domain
Note: Instance variable value_left_bottom_front - (in) value at left,bottom,front corner
Note: Instance variable value_right_bottom_front - (in) value at right, bottom, front corner
Note: Instance variable value_left_top_front - (in) value at left,top,front corner
Note: Instance variable value_right_top_front - (in) value at right,top,front corner
Note: Instance variable value_left_bottom_back - (in) value at left,bottom,back corner
Note: Instance variable value_right_bottom_back - (in) value at right,bottom,back corner
Note: Instance variable value_left_top_back - (in) value at left,top,back corner
Note: Instance variable value_right_top_back - (in) value at right,top,back corner

__init__(**kwargs)¶: Creates a ParameterSet with given parameters.

out()¶

values at domain locations by bilinear interpolation of the given values.

Link against this method to get the output of this model.

class esys.modellib.input.InterpolatedTimeProfile(**kwargs)¶

Returns values at each time. The values are defined through given values at time node.

value[i] defines the value at time nodes[i]. Between nodes linear interpolation is used.

For time t<nodes[0], value[0] is used and for t>nodes[l], values[l] is used where l=len(nodes)-1.

Note: Instance variable t - (in) current time
Note: Instance variable node - (in) list of time nodes
Note: Instance variable values - (in) list of values at time nodes

__init__(**kwargs)¶: Creates a ParameterSet with given parameters.

out()¶

current value

Link against this method to get the output of this model.

class esys.modellib.input.LinearCombination(**kwargs)¶

Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4

Variables

f0 – numerical object or None, default=None (in)
v0 – numerical object or None, default=None (in)
f1 – numerical object or None, default=None (in)
v1 – numerical object or None, default=None (in)
f2 – numerical object or None, default=None (in)
v2 – numerical object or None, default=None (in)
f3 – numerical object or None, default=None (in)
v3 – numerical object or None, default=None (in)
f4 – numerical object or None, default=None (in)
v4 – numerical object or None, default=None (in)

__init__(**kwargs)¶: Creates a ParameterSet with given parameters.

out()¶: returns f0*v0+f1*v1+f2*v2+f3*v3+f4*v4. Link against this method to get the output of this model.

class esys.modellib.input.LinearPDE(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)¶

This class is used to define a general linear, steady, second order PDE for an unknown function u on a given domain defined through a Domain object.

For a single PDE having a solution with a single component the linear PDE is defined in the following form:

-(grad(A[j,l]+A_reduced[j,l])*grad(u)[l]+(B[j]+B_reduced[j])u)[j]+(C[l]+C_reduced[l])*grad(u)[l]+(D+D_reduced)=-grad(X+X_reduced)[j,j]+(Y+Y_reduced)

where grad(F) denotes the spatial derivative of F. Einstein’s summation convention, ie. summation over indexes appearing twice in a term of a sum performed, is used. The coefficients A, B, C, D, X and Y have to be specified through Data objects in Function and the coefficients A_reduced, B_reduced, C_reduced, D_reduced, X_reduced and Y_reduced have to be specified through Data objects in ReducedFunction. It is also allowed to use objects that can be converted into such Data objects. A and A_reduced are rank two, B, C, X, B_reduced, C_reduced and X_reduced are rank one and D, D_reduced, Y and Y_reduced are scalar.

The following natural boundary conditions are considered:

n[j]*((A[i,j]+A_reduced[i,j])*grad(u)[l]+(B+B_reduced)[j]*u)+(d+d_reduced)*u=n[j]*(X[j]+X_reduced[j])+y

where n is the outer normal field. Notice that the coefficients A, A_reduced, B, B_reduced, X and X_reduced are defined in the PDE. The coefficients d and y are each a scalar in FunctionOnBoundary and the coefficients d_reduced and y_reduced are each a scalar in ReducedFunctionOnBoundary.

Constraints for the solution prescribe the value of the solution at certain locations in the domain. They have the form

u=r where q>0

r and q are each scalar where q is the characteristic function defining where the constraint is applied. The constraints override any other condition set by the PDE or the boundary condition.

The PDE is symmetrical if

A[i,j]=A[j,i] and B[j]=C[j] and A_reduced[i,j]=A_reduced[j,i] and B_reduced[j]=C_reduced[j]

For a system of PDEs and a solution with several components the PDE has the form

-grad((A[i,j,k,l]+A_reduced[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k])[j]+(C[i,k,l]+C_reduced[i,k,l])*grad(u[k])[l]+(D[i,k]+D_reduced[i,k]*u[k] =-grad(X[i,j]+X_reduced[i,j])[j]+Y[i]+Y_reduced[i]

A and A_reduced are of rank four, B, B_reduced, C and C_reduced are each of rank three, D, D_reduced, X_reduced and X are each of rank two and Y and Y_reduced are of rank one. The natural boundary conditions take the form:

n[j]*((A[i,j,k,l]+A_reduced[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k])+(d[i,k]+d_reduced[i,k])*u[k]=n[j]*(X[i,j]+X_reduced[i,j])+y[i]+y_reduced[i]

The coefficient d is of rank two and y is of rank one both in FunctionOnBoundary. The coefficients d_reduced is of rank two and y_reduced is of rank one both in ReducedFunctionOnBoundary.

Constraints take the form

u[i]=r[i] where q[i]>0

r and q are each rank one. Notice that at some locations not necessarily all components must have a constraint.

The system of PDEs is symmetrical if

A[i,j,k,l]=A[k,l,i,j]

A_reduced[i,j,k,l]=A_reduced[k,l,i,j]

B[i,j,k]=C[k,i,j]

B_reduced[i,j,k]=C_reduced[k,i,j]

D[i,k]=D[i,k]

D_reduced[i,k]=D_reduced[i,k]

d[i,k]=d[k,i]

d_reduced[i,k]=d_reduced[k,i]

LinearPDE also supports solution discontinuities over a contact region in the domain. To specify the conditions across the discontinuity we are using the generalised flux J which, in the case of a system of PDEs and several components of the solution, is defined as

J[i,j]=(A[i,j,k,l]+A_reduced[[i,j,k,l])*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])*u[k]-X[i,j]-X_reduced[i,j]

For the case of single solution component and single PDE J is defined as

J[j]=(A[i,j]+A_reduced[i,j])*grad(u)[j]+(B[i]+B_reduced[i])*u-X[i]-X_reduced[i]

In the context of discontinuities n denotes the normal on the discontinuity pointing from side 0 towards side 1 calculated from FunctionSpace.getNormal of FunctionOnContactZero. For a system of PDEs the contact condition takes the form

n[j]*J0[i,j]=n[j]*J1[i,j]=(y_contact[i]+y_contact_reduced[i])- (d_contact[i,k]+d_contact_reduced[i,k])*jump(u)[k]

where J0 and J1 are the fluxes on side 0 and side 1 of the discontinuity, respectively. jump(u), which is the difference of the solution at side 1 and at side 0, denotes the jump of u across discontinuity along the normal calculated by jump. The coefficient d_contact is of rank two and y_contact is of rank one both in FunctionOnContactZero or FunctionOnContactOne. The coefficient d_contact_reduced is of rank two and y_contact_reduced is of rank one both in ReducedFunctionOnContactZero or ReducedFunctionOnContactOne. In case of a single PDE and a single component solution the contact condition takes the form

n[j]*J0_{j}=n[j]*J1_{j}=(y_contact+y_contact_reduced)-(d_contact+y_contact_reduced)*jump(u)

In this case the coefficient d_contact and y_contact are each scalar both in FunctionOnContactZero or FunctionOnContactOne and the coefficient d_contact_reduced and y_contact_reduced are each scalar both in ReducedFunctionOnContactZero or ReducedFunctionOnContactOne.

Typical usage:

p = LinearPDE(dom)
p.setValue(A=kronecker(dom), D=1, Y=0.5)
u = p.getSolution()

__init__(domain, numEquations=None, numSolutions=None, isComplex=False, debug=False)¶

Initializes a new linear PDE.

Parameters

domain (Domain) – domain of the PDE
numEquations – number of equations. If None the number of equations is extracted from the PDE coefficients.
numSolutions – number of solution components. If None the number of solution components is extracted from the PDE coefficients.
debug – if True debug information is printed

checkSymmetry(verbose=True)¶

Tests the PDE for symmetry.

Parameters: verbose (bool) – if set to True or not present a report on coefficients which break the symmetry is printed.
Returns: True if the PDE is symmetric
Return type: bool
Note: This is a very expensive operation. It should be used for degugging only! The symmetry flag is not altered.

createOperator()¶: Returns an instance of a new operator.

getFlux(u=None)¶

Returns the flux J for a given u.

J[i,j]=(A[i,j,k,l]+A_reduced[A[i,j,k,l]]*grad(u[k])[l]+(B[i,j,k]+B_reduced[i,j,k])u[k]-X[i,j]-X_reduced[i,j]

or

J[j]=(A[i,j]+A_reduced[i,j])*grad(u)[l]+(B[j]+B_reduced[j])u-X[j]-X_reduced[j]

Parameters: u (Data or None) – argument in the flux. If u is not present or equals None the current solution is used.
Returns: flux
Return type: Data

getRequiredOperatorType()¶: Returns the system type which needs to be used by the current set up.

getResidual(u=None)¶

Returns the residual of u or the current solution if u is not present.

Parameters: u (Data or None) – argument in the residual calculation. It must be representable in self.getFunctionSpaceForSolution(). If u is not present or equals None the current solution is used.
Returns: residual of u
Return type: Data

getSolution()¶

Returns the solution of the PDE.

Returns: the solution
Return type: Data

getSystem()¶

Returns the operator and right hand side of the PDE.

Returns: the discrete version of the PDE
Return type: tuple of Operator and Data

insertConstraint(rhs_only=False)¶

Applies the constraints defined by q and r to the PDE.

Parameters: rhs_only (bool) – if True only the right hand side is altered by the constraint

setValue(**coefficients)¶

Sets new values to coefficients.

Parameters

coefficients – new values assigned to coefficients
A (any type that can be cast to a Data object on Function) – value for coefficient A
A_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient A_reduced
B (any type that can be cast to a Data object on Function) – value for coefficient B
B_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient B_reduced
C (any type that can be cast to a Data object on Function) – value for coefficient C
C_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient C_reduced
D (any type that can be cast to a Data object on Function) – value for coefficient D
D_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient D_reduced
X (any type that can be cast to a Data object on Function) – value for coefficient X
X_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient X_reduced
Y (any type that can be cast to a Data object on Function) – value for coefficient Y
Y_reduced (any type that can be cast to a Data object on ReducedFunction) – value for coefficient Y_reduced
d (any type that can be cast to a Data object on FunctionOnBoundary) – value for coefficient d
d_reduced (any type that can be cast to a Data object on ReducedFunctionOnBoundary) – value for coefficient d_reduced
y (any type that can be cast to a Data object on FunctionOnBoundary) – value for coefficient y
d_contact (any type that can be cast to a Data object on FunctionOnContactOne or FunctionOnContactZero) – value for coefficient d_contact
d_contact_reduced (any type that can be cast to a Data object on ReducedFunctionOnContactOne or ReducedFunctionOnContactZero) – value for coefficient d_contact_reduced
y_contact (any type that can be cast to a Data object on FunctionOnContactOne or FunctionOnContactZero) – value for coefficient y_contact
y_contact_reduced (any type that can be cast to a Data object on ReducedFunctionOnContactOne or ReducedFunctionOnContactZero) – value for coefficient y_contact_reduced
d_dirac (any type that can be cast to a Data object on DiracDeltaFunctions) – value for coefficient d_dirac
y_dirac (any type that can be cast to a Data object on DiracDeltaFunctions) – value for coefficient y_dirac
r (any type that can be cast to a Data object on Solution or ReducedSolution depending on whether reduced order is used for the solution) – values prescribed to the solution at the locations of constraints
q (any type that can be cast to a Data object on Solution or ReducedSolution depending on whether reduced order is used for the representation of the equation) – mask for location of constraints

Raises

IllegalCoefficient – if an unknown coefficient keyword is used

class esys.modellib.input.MergeConstraints(**kwargs)¶

Returns a linear combination of the f0*v0+f1*v1+f2*v2+f3*v3+f4*v4

__init__(**kwargs)¶: Creates a ParameterSet with given parameters.

location_of_constraint()¶

return the values used to constrain a solution

Returns: the mask marking the locations of the constraints
Return type: escript.Scalar

value_of_constraint()¶

return the values used to constrain a solution

Returns: values to be used at the locations of the constraints. If value is not given None is rerturned.
Return type: escript.Scalar

class esys.modellib.input.Model(parameters=[], **kwargs)¶

A Model object represents a process marching over time until a finalizing condition is fulfilled. At each time step an iterative process can be performed and the time step size can be controlled. A Model has the following work flow:

doInitialization()
while not terminateInitialIteration(): doInitialStep()
doInitialPostprocessing()
while not finalize():
    dt=getSafeTimeStepSize(dt)
    doStepPreprocessing(dt)
    while not terminateIteration(): doStep(dt)
    doStepPostprocessing(dt)
doFinalization()

where doInitialization, finalize, getSafeTimeStepSize, doStepPreprocessing, terminateIteration, doStepPostprocessing, doFinalization are methods of the particular instance of a Model. The default implementations of these methods have to be overwritten by the subclass implementing a Model.

__init__(parameters=[], **kwargs)¶

Creates a model.

Just calls the parent constructor.

UNDEF_DT = 1e+300¶

doFinalization()¶

Finalizes the time stepping.

This function may be overwritten.

doInitialPostprocessing()¶

Finalises the initialization iteration process. This method is not called in case of a restart.

This function may be overwritten.

doInitialStep()¶

Performs an iteration step in the initialization phase. This method is not called in case of a restart.

This function may be overwritten.

doInitialization()¶

Initializes the time stepping scheme. This method is not called in case of a restart.

This function may be overwritten.

doStep(dt)¶

Executes an iteration step at a time step.

dt is the currently used time step size.

This function may be overwritten.

doStepPostprocessing(dt)¶

Finalises the time step.

dt is the currently used time step size.

This function may be overwritten.

doStepPreprocessing(dt)¶

Sets up a time step of step size dt.

This function may be overwritten.

finalize()¶

Returns False if the time stepping is finalized.

This function may be overwritten.

getSafeTimeStepSize(dt)¶

Returns a time step size which can be safely used.

dt gives the previously used step size.

This function may be overwritten.

setUp()¶

Sets up the model.

This function may be overwritten.

terminateInitialIteration()¶: Returns True if iteration at the inital phase is terminated.

terminateIteration()¶: Returns True if iteration on a time step is terminated.

toDom(esysxml, node)¶: toDom method of Model class.

class esys.modellib.input.ParameterSet(parameters=[], **kwargs)¶

A class which allows to emphasize attributes to be written and read to XML.

Leaves of an ESySParameters object can be:

a real number

an integer number

a string

a boolean value

a ParameterSet object

a Simulation object

a Model object

a numpy object

a list of booleans

any other object (not considered by writeESySXML and writeXML)

Example for how to create an ESySParameters object:

p11=ParameterSet(gamma1=1.,gamma2=2.,gamma3=3.)
p1=ParameterSet(dim=2,tol_v=0.001,output_file="/tmp/u.%3.3d.dx",runFlag=True,parm11=p11)
parm=ParameterSet(parm1=p1,parm2=ParameterSet(alpha=Link(p11,"gamma1")))

This can be accessed as:

parm.parm1.gamma=0.
parm.parm1.dim=2
parm.parm1.tol_v=0.001
parm.parm1.output_file="/tmp/u.%3.3d.dx"
parm.parm1.runFlag=True
parm.parm1.parm11.gamma1=1.
parm.parm1.parm11.gamma2=2.
parm.parm1.parm11.gamma3=3.
parm.parm2.alpha=1. (value of parm.parm1.parm11.gamma1)

__init__(parameters=[], **kwargs)¶: Creates a ParameterSet with given parameters.

checkLinkTargets(models, hash)¶: Returns a set of tuples (“<self>(<name>)”, <target model>) if the parameter <name> is linked to model <target model> but <target model> is not in the list of models. If a parameter is linked to another parameter set which is not in the hash list the parameter set is checked for its models. hash gives the call history.

declareParameter(**parameters)¶: Declares one or more new parameters and their initial value.

declareParameters(parameters)¶: Declares a set of parameters. parameters can be a list, a dictionary or a ParameterSet.

classmethod fromDom(esysxml, node)¶

releaseParameters(name)¶: Removes parameter name from the parameters.

showParameters()¶: Returns a description of the parameters.

toDom(esysxml, node)¶: toDom method of Model class.

writeXML(ostream=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)¶: Writes the object as an XML object into an output stream.

class esys.modellib.input.ScalarDistributionFromTags(**kwargs)¶

creates a scalar distribution on a domain from tags, If tag_map is given the tags can be given a names and tag_map is used to map it into domain tags.

Variables

domain – domain
default – default value
tag0 – tag 0
value0 – value for tag 0
tag1 – tag 1
value1 – value for tag 1
tag2 – tag 2
value2 – value for tag 2
tag3 – tag 3
value3 – value for tag 3
tag4 – tag 4
value4 – value for tag 4
tag5 – tag 5
value5 – value for tag 5
tag6 – tag 6
value6 – value for tag 6
tag7 – tag 7
value7 – value for tag 7
tag8 – tag 8
value8 – value for tag 8
tag9 – tag 9
value9 – value for tag 9

__init__(**kwargs)¶: Creates a ParameterSet with given parameters.

out()¶: returns a esys.escript.Data object Link against this method to get the output of this model.

class esys.modellib.input.Sequencer(**kwargs)¶

Runs through time until t_end is reached.

Variables

t_end – model is terminated when t_end is passed, default 1 (in).
dt_max – maximum time step size, default Model.UNDEF_DT (in)
t – current time stamp (in/out). By default it is initialized with zero.

__init__(**kwargs)¶

doInitialization()¶: initialize time integration

doStepPostprocessing(dt)¶

Finalises the time step.

dt is the currently used time step size.

This function may be overwritten.

doStepPreprocessing(dt)¶

Sets up a time step of step size dt.

This function may be overwritten.

finalize()¶: returns true when t has reached t_end

getSafeTimeStepSize(dt)¶: returns dt_max

class esys.modellib.input.SmoothScalarDistributionFromTags(**kwargs)¶

creates a smooth scalar distribution on a domain from region tags

Variables

domain – domain
default – default value
tag0 – tag 0
value0 – value for tag 0
tag1 – tag 1
value1 – value for tag 1
tag2 – tag 2
value2 – value for tag 2
tag3 – tag 3
value3 – value for tag 3
tag4 – tag 4
value4 – value for tag 4
tag5 – tag 5
value5 – value for tag 5
tag6 – tag 6
value6 – value for tag 6
tag7 – tag 7
value7 – value for tag 7
tag8 – tag 8
value8 – value for tag 8
tag9 – tag 9
value9 – value for tag 9

__init__(**kwargs)¶: Creates a ParameterSet with given parameters.

out()¶: returns a esys.escript.Data object Link against this method to get the output of this model.

Functions¶

esys.modellib.input.exp(arg)¶

Returns e to the power of argument arg.

Parameters: arg (float, escript.Data, Symbol, numpy.ndarray.) – argument
Return type: float, escript.Data, Symbol, numpy.ndarray depending on the type of arg
Raises: TypeError – if the type of the argument is not expected

esys.modellib.input.inf(arg)¶

Returns the minimum value over all data points.

Parameters: arg (float, int, escript.Data, numpy.ndarray) – argument
Returns: minimum value of arg over all components and all data points
Return type: float
Raises: TypeError – if type of arg cannot be processed

esys.modellib.input.length(arg)¶

Returns the length (Euclidean norm) of argument arg at each data point.

Parameters: arg (float, escript.Data, Symbol, numpy.ndarray) – argument
Return type: float, escript.Data, Symbol depending on the type of arg

esys.modellib.input.sup(arg)¶

Returns the maximum value over all data points.

Parameters: arg (float, int, escript.Data, numpy.ndarray) – argument
Returns: maximum value of arg over all components and all data points
Return type: float
Raises: TypeError – if type of arg cannot be processed

esys.modellib.input.whereNegative(arg)¶

Returns mask of negative values of argument arg.

Parameters: arg (float, escript.Data, Symbol, numpy.ndarray) – argument
Return type: float, escript.Data, Symbol, numpy.ndarray depending on the type of arg
Raises: TypeError – if the type of the argument is not expected

esys.modellib.input.wherePositive(arg)¶

Returns mask of positive values of argument arg.

Parameters: arg (float, escript.Data, Symbol, numpy.ndarray.) – argument
Return type: float, escript.Data, Symbol, numpy.ndarray depending on the type of arg
Raises: TypeError – if the type of the argument is not expected

Others¶

log

esys.modellib.input Package¶

Classes¶

Functions¶

Others¶

Packages¶

Table of Contents