esys.modellib.input Package¶
Classes¶
- 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 inFunction
and the coefficients A_reduced, B_reduced, C_reduced, D_reduced, X_reduced and Y_reduced have to be specified throughData
objects inReducedFunction
. It is also allowed to use objects that can be converted into suchData
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 inReducedFunctionOnBoundary
.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 inReducedFunctionOnBoundary
.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 asJ[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
ofFunctionOnContactZero
. For a system of PDEs the contact condition takes the formn[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 inFunctionOnContactZero
orFunctionOnContactOne
. The coefficient d_contact_reduced is of rank two and y_contact_reduced is of rank one both inReducedFunctionOnContactZero
orReducedFunctionOnContactOne
. In case of a single PDE and a single component solution the contact condition takes the formn[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
orFunctionOnContactOne
and the coefficient d_contact_reduced and y_contact_reduced are each scalar both inReducedFunctionOnContactZero
orReducedFunctionOnContactOne
.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 PDEnumEquations – 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 equalsNone
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 inself.getFunctionSpaceForSolution()
. If u is not present or equalsNone
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
ofOperator
andData
- 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 onFunction
) – value for coefficientA
A_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientA_reduced
B (any type that can be cast to a
Data
object onFunction
) – value for coefficientB
B_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientB_reduced
C (any type that can be cast to a
Data
object onFunction
) – value for coefficientC
C_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientC_reduced
D (any type that can be cast to a
Data
object onFunction
) – value for coefficientD
D_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientD_reduced
X (any type that can be cast to a
Data
object onFunction
) – value for coefficientX
X_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientX_reduced
Y (any type that can be cast to a
Data
object onFunction
) – value for coefficientY
Y_reduced (any type that can be cast to a
Data
object onReducedFunction
) – value for coefficientY_reduced
d (any type that can be cast to a
Data
object onFunctionOnBoundary
) – value for coefficientd
d_reduced (any type that can be cast to a
Data
object onReducedFunctionOnBoundary
) – value for coefficientd_reduced
y (any type that can be cast to a
Data
object onFunctionOnBoundary
) – value for coefficienty
d_contact (any type that can be cast to a
Data
object onFunctionOnContactOne
orFunctionOnContactZero
) – value for coefficientd_contact
d_contact_reduced (any type that can be cast to a
Data
object onReducedFunctionOnContactOne
orReducedFunctionOnContactZero
) – value for coefficientd_contact_reduced
y_contact (any type that can be cast to a
Data
object onFunctionOnContactOne
orFunctionOnContactZero
) – value for coefficienty_contact
y_contact_reduced (any type that can be cast to a
Data
object onReducedFunctionOnContactOne
orReducedFunctionOnContactZero
) – value for coefficienty_contact_reduced
d_dirac (any type that can be cast to a
Data
object onDiracDeltaFunctions
) – value for coefficientd_dirac
y_dirac (any type that can be cast to a
Data
object onDiracDeltaFunctions
) – value for coefficienty_dirac
r (any type that can be cast to a
Data
object onSolution
orReducedSolution
depending on whether reduced order is used for the solution) – values prescribed to the solution at the locations of constraintsq (any type that can be cast to a
Data
object onSolution
orReducedSolution
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 givenNone
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 reachedt_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 ofarg
- 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 ofarg
- 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 ofarg
- Raises
TypeError – if the type of the argument is not expected
Others¶
log