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, 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)
from NeuroCore.Models.Base import GeneralModel
from NeuroCore.Models.Conventions import Domains, Steps
from NeuroCore.Approximations.Space.FEM.GalerkinApproximation import GalerkinApproximation
from NeuroCore.Approximations.Time.BackwardEuler import BackwardEuler
from NeuroCore.Models.Conditions.BCs import BoundaryConditions
from NeuroCore.Models.Conditions.Dirichlets import KilledEnd
from Analytics.Solutions.Validations.Transient import ValidationWithF
from Plotting.Simulation import Simulation
from Plotting.IDataPlot import IDataPlot
from numpy import arange
########################################
### Simulation Variable ###
########################################
simDomain = Domains(space=[0, 1], time=[0, 10])
simSteps = Steps(space=0.1, time=0.1)
diffusionValue = 1
reactionValue = 1
kValue = 1
boundaryConditions = BoundaryConditions(KilledEnd(), KilledEnd())
sElements = arange(0, simDomain.space[-1] + simSteps.space,\
simSteps.space)
########################################
### Setting the Simulation ###
########################################
import numpy
import math
import time
########################################
### Simulation Variable ###
########################################
length = 1
T = 10
delta_x = 0.1
delta_t = 0.1
simDomain = Domains(time=[0,T],space=[0,length])
simSteps = Steps(time=delta_t,space=delta_x)
spatial_elements = numpy.arange(0, simDomain.space[-1] + simSteps.space,\
simSteps.space)
time_elements = numpy.arange(0, simDomain.time[-1] + simSteps.time, simSteps.time)
V_0 = []
def u0(x):
return math.sin(2*math.pi*x)
for x in spatial_elements:
V_0.append(u0(x))
from NeuroCore.Models.Conventions import Domains, Steps
from NeuroCore.Approximations.Space.FEM.GalerkinApproximation import GalerkinApproximation
#from Approximations.Time.BackwardEuler import BackwardEuler
from NeuroCore.Models.Conditions.BCs import BoundaryConditions
from NeuroCore.Models.Conditions.Dirichlets import KilledEnd
from math import pi, pow, sin
import numpy
import math
import time
########################################
### Simulation Variable ###
########################################
simDomain = Domains(time=[0, 10], space=[0, 1])
simSteps = Steps(time=0.1, space=0.1)
spatial_elements = numpy.arange(0, simDomain.space[-1] + simSteps.space,\
simSteps.space)
time_elements = numpy.arange(0, simDomain.time[-1] + simSteps.time,
simSteps.time)
V_0 = []
def u0(x):
return math.sin(2 * math.pi * x)
from Analytics.Solutions.Validations.Stationary import ValidationWithF
from NeuroCore.Approximations.Space.FEM.GalerkinApproximation import GalerkinApproximation
from NeuroCore.Models.Conditions.BCs import BoundaryConditions
from NeuroCore.Models.Conditions.Neumanns import SealedEnd
from NeuroCore.Models.Conventions import Domains, Steps
from NeuroCore.Models.GeneralModel import GeneralModel
from NeuroCore.Neuron.Segment.Base import ISegment
from Plotting.IDataPlot import IDataPlot
from Plotting.IDataPlots import IDataPlots
from Plotting.Simulation import Simulation
########################################
### Simulation Variable ###
########################################
simDomain = Domains(space=[0, 12])
simSteps = Steps(space=0.01)
diffusionValue = 100
reactionValue = 10
boundaryConditions = BoundaryConditions(SealedEnd(), SealedEnd())
sElements = numpy.arange(0, simDomain.space[-1] + simSteps.space, \
simSteps.space)
########################################
### Setting the Simulation ###
########################################
analytical = ValidationWithF(domain=simDomain, steps=simSteps, \