def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
name="Jemmy's Example 1",
numSegments=3,
bifurcationPoints=1,
domainE=Domains(space=[0, 1], time=[0, 1]),
domainLw=Domains(space=[1, 2], time=[0, 1]),
domainUp=Domains(space=[1, 3], time=[0, 1]),
bcDomainE=BoundaryConditions(SealedEnd(), SealedEnd()),
bcDomainLw=BoundaryConditions(SealedEnd(), SealedEnd()),
bcDomainUp=BoundaryConditions(SealedEnd(), SealedEnd()),
solutionE=[],
solutionLw=[],
solutionUp=[],
description="This is the solution for the \
following problem:\
Problem being solved is: [0,3]X[0,1]\
d2u/dx2 = du\dt + u \
BC: du/dx(0,t) = du/dx(2,t) = du/dx(3,t) = 0 \
Initial Conditions:\
u(x,0) = cos(pi*x)\
Solution: u = (e^(-(1 + pi^2)*t)*cos(pi*x)"
)
# Merge the default options and the user generated options
whole_options = default_options << options
super(JemmyEx1, self).__init__(whole_options, **kw)
def __init__(self,
name,
localConditions,
domain,
steps,
iModel,
options=Options(),
**kw):
# Define the default options
default_options = Options(
**{
constants().Domain: domain,
constants().Steps: steps,
constants().Name: name,
constants().LocalConditions: localConditions,
constants().IModel: iModel
})
# Merge the default options and the user generated options
whole_options = default_options << options
super(ISegment, self).__init__(whole_options, **kw)
self.iModel.domain = self.domain
self.iModel.BCs = self.localConditions
self.iModel.steps = self.steps
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(
name="Jemmy's Example 2",
numSegments=3,
bifurcationPoints=1,
segmentsDomain=[
Domains(space=[0, pi / 2], time=[0, 1]),
Domains(space=[pi / 2, pi], time=[0, 1]),
Domains(space=[pi / 2, 3 * (pi / 2)], time=[0, 1])
],
boundaryConditions=[
BoundaryConditions(SealedEnd(), SealedEnd()),
BoundaryConditions(SealedEnd(), SealedEnd()),
BoundaryConditions(SealedEnd(), SealedEnd())
],
description="This is the solution for the \
following problem:\
Problem being solved is: [0,3*pi/2]X[0,1]\
d2u/dx2 = du\dt - 2*u \
BC: du/dx(0,t) = -e^t, du/dx(pi,t) = e^t , du/dx(3*pi/2,t) = 0 \
Initial Conditions:\
u(x,0) = -sin(x)\
Solution: u = (e^-t)*sin(x)")
# Merge the default options and the user generated options
whole_options = default_options << options
super(JemmyEx2, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
#Other Example would be:
# Ek = -77,
# ENa = 50,
# ELeaky = -54.4,
# Define the default options
default_options = Options(name="Cable Model",
results=[],
gk=36,
gNa=120,
gLeaky=0.3,
Ek=-12,
ENa=115,
ELeaky=10.6,
coeff_t=None,
coeff_dx2=None,
coeff_v=None,
coeff_font=None)
# Merge the default options and the user generated options
whole_options = default_options << options
#print("CableModel Kw Options:",kw)
#print("\nCableModel Whole Options:",whole_options.__dict__)
super(CableModel, self).__init__(whole_options, **kw)
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().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().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, userCoeff, options=Options(), **kw):
# Define the default options
default_options = Options(name="Discrete", positionCalculations={})
# Merge the default options and the user generated options
whole_options = default_options << options
super(HH, self).__init__(whole_options, **kw)
def __init__(self, space, time=None, options=Options(), **kw):
# Define the default options
default_options = Options(name="Steps", space=space, time=time)
# Merge the default options and the user generated options
whole_options = default_options << options
super(Steps, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(name="Boundary Condition")
# Merge the default options and the user generated options
whole_options = default_options << options
super(ICondition, 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, options=Options(), **kw):
# Define the default options
self.default_options = Options(name="Neuron")
# Merge the default options and the user generated options
whole_options = self.default_options << options
# Initialize the options and the extra arguments
self.class_option.init_options(self, 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, 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().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):
'''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: Components().Diffusion})
# Merge the default options and the user generated options
whole_options = default_options << options
super(Diffusion, self).__init__(whole_options, **kw)
def __init__(self, options=Options(), **kw):
# Define the default options
default_options = Options(name="IProtocol",
dataToBeAnalysed=IDataAnalysed(),
data=None)
# Merge the default options and the user generated options
whole_options = default_options << options
super(TestProtocols, 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().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().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, userCoeff, options=Options(), **kw):
# Define the default options
default_options = Options(name="Coefficient",
customFunctions={},
coeffType=self.__identifyType(userCoeff),
value=userCoeff)
# Merge the default options and the user generated options
whole_options = default_options << options
super(ICoefficient, 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().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(name="Default", neuron=NetX_Neuron())
# Merge the default options and the user generated options
whole_options = default_options << options
# Initialize the options and the extra arguments
self.class_option.init_options(self, whole_options, kw)
self.__prepareClasses()
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):
'''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):
# 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, component, 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(name="NonLinear" + component.name,
inComponent=component,
discreteElements={})
# Merge the default options and the user generated options
whole_options = default_options << options
super(Discrete, 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):
# Define the default options
default_options = Options(name="ISolution",
description="A Solution Interface",
sElements=None,
BCs=None,
solution=[])
# Merge the default options and the user generated options
whole_options = default_options << options
super(ISolution, self).__init__(whole_options, **kw)