def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().FEMElement,
constants().Domain: None,
constants().NumLocalNodes: None,
constants().NumIntegration: None,
constants().Matrix: None,
constants().Font: None,
constants().CoupledApprox: None,
constants().ExtraData: {
constants().Previous: []
},
constants().Bilinear: None,
constants().Linear: None
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IElement, self).__init__(whole_options, **kw)
self.__prepareData()
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().IModel,
constants().Domain: None,
constants().Steps: None,
constants().CurrentTime: None,
constants().InitialCondition: None,
constants().Results: [],
constants().Coeffs: None,
constants().Font: None,
constants().BCs: None,
constants().IApproximation: None,
constants().TimeApproximation: None,
constants().Equation: {}
})
# Merge the default options and the user generated options
whole_options = default_options << options
# print("IModel Kw Options:",kw)
# print("\nIModel Whole Options:",whole_options.__dict__)
super(IModel, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{constants().Name: Names().ClassicGalerkin})
# Merge the default options and the user generated options
whole_options = default_options << options
super(GalerkinApproximation, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{constants().Name: Names().Equation,
constants().Coeffs: {}})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IEquation, self).__init__(whole_options, **kw)
def __init__(self, bcValue, options=Options(), **kw):
# Define the default options
default_options = Options(**{
constants().Name: Names().VoltageClamp,
constants().BcValue: bcValue
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(VoltageClamp, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{constants().Name: Names().SimuPlots,
constants().Marker: itertools.cycle((',', '+', '.', 'o', '*', 'v', '>', '<')),
constants().Linestyles: itertools.cycle(('--', '-', '-.', ':'))})
# Merge the default options and the user generated options
whole_options = default_options << options
super(Simulation, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{
constants().Name: Names().Trapezoidal,
constants().NumPoints: 2
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(Trapezoidal, self).__init__(whole_options, **kw)
def __init__(self,options=Options(), **kw):
'''A class initializer.'''
# Define the default options
default_options = Options(**{constants().Name:Names().BackwardEuler})
# Merge the default options and the user generated options
whole_options = default_options << options
super(BackwardEuler,self).__init__(whole_options,**kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{constants().Name: Names().StationaryBaseClass,
constants().Description: Descriptions().StationaryBaseClass,
constants().SElements: None,
constants().BCs: None,
constants().Solution: []})
# Merge the default options and the user generated options
whole_options = default_options << options
super(StationaryBase, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().GenericIntegration,
constants().Domain: [-1, 1]
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IIntegration, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().WeightFunction,
constants().NumLocalNodes: None
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IWeightFunction, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{
constants().Name: Names().SealedEnd,
constants().BcValue: 0.0
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(SealedEnd, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{constants().Name: Names().IAnalysis,
constants().Description: Descriptions().IAnalysis,
constants().Solution: None,
constants().Domain: None,
constants().Steps: None})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IAnalysis, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().Neumann,
constants().BcValue: 1.0,
constants().BcType: constants().Neumann
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(Neumann, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{constants().Name: Names().IProblem,
constants().Description: Descriptions().IProblem,
constants().SpatialSteps: None,
constants().Mesh: None,
constants().BCs: None})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IProblem, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
'''A class initializer.'''
# Define the default options
default_options = Options(**{constants().Name: Names().CoupledHHAproximations,
constants().M: [],
constants().N: [],
constants().H: []})
# Merge the default options and the user generated options
whole_options = default_options << options
super(CoupledHHApprox, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
'''Class initializer. Use it's Base Class initializer
and adds the weight function to be used. '''
# Define the default options
default_options = Options(**{
constants().Name: Names().Component,
constants().Coeff: None
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IComponent, self).__init__(whole_options, **kw)
def __init__(self, inStart, inEnd, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().BoundaryCondition,
constants().InStart: inStart,
constants().InEnd: inEnd
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(BoundaryConditions, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().ValidationZeroF,
constants().DiffusionValue: 1,
constants().ReactionValue: 1,
constants().Description: Descriptions().ValidationZeroF
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(ValidationZeroF, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options({
currentConstanst().Name: Names().CurrentInjection,
currentConstanst().Diameter: None,
currentConstanst().ResistanceL: None,
currentConstanst().Current: None,
currentConstanst().BcValue: 1.0
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(CurrentInjection, self).__init__(whole_options, **kw)
def __init__(self, userFunction, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
UtilitiesParameters().Name: Names().Function,
UtilitiesParameters().InFunction: self.__fixFunction(
userFunction),
UtilitiesParameters().InConstant: 1.0
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(Function, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().GaussianQuadrature,
constants().Degree: 2,
constants().IntPoints: {}
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(Gaussian, self).__init__(whole_options, **kw)
self.__calculatePoints()
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().TimeApproximation,
constants().Disturbance: {},
constants().CoeffT: None,
constants().Font: 1.0,
constants().Reaction: 1.0,
constants().Step: None
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IApproximation, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().IDataPlots,
constants().ListPlots: None,
constants().IterablePlots: None,
constants().Length: None,
constants().XElems: None,
constants().Transient: False
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IDataPlots, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
'''Class initializer. Use it's Base Class initializer
and adds the weight function to be used. '''
# Define the default options
default_options = Options(
**{
constants().Name: Names().FEMComponent,
constants().WeightFunction: None,
constants().ReferenceElement: True,
constants().Line: 0,
constants().Column: 0
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IFEM, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().FEM,
constants().ReferenceElement: True,
constants().Modifiers: {},
constants().WeightFunction: Linear_Lagrange(),
constants().NumIntegration: Gaussian(),
constants().IElements: None
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(FEM_Approximation, self).__init__(whole_options, **kw)
self.iElements = IElements(numLocalNodes=self.weightFunction.numLocalNodes, \
numIntegration=self.numIntegration)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().IPlot,
constants().Plots: IDataPlots(),
constants().Xlim: (-1.5, 1.5),
constants().Ylim: (-1.5, 1.5),
constants().Length: None,
constants().XElems: None,
constants().TElems: None,
constants().Transient: False
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IPlot, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
**{
constants().Name: Names().IDataPlot,
constants().Domain: None,
constants().Steps: None,
constants().Results: None,
constants().Transient: False,
constants().Color: BasicPlottingColors().Black
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IDataPlot, self).__init__(whole_options, **kw)
self.transient = False if self.steps.time is None else True
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(**{constants().Name: Names().FEMElements,
constants().NumElements: None,
constants().Domain: None,
constants().Steps: None,
constants().Matrix: None,
constants().Font: None,
constants().Previous: [],
constants().NumLocalNodes: None,
constants().NumIntegration: None,
constants().Bilinear: None,
constants().Linear: None,
constants().Elements: []})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IElements, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
'''The initializer for the class receives a list
of terms that the composed term is going to
be based in.
It's used like:
Composed_Term(diffusion = Galerking_Diffusion,...)'''
# Define the default options
default_options = Options(
**{
constants().Name: Names().Composite,
constants().Domain: None,
constants().Equation: {}
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(IComposite, self).__init__(whole_options, **kw)