def AbstractParabolicProblem(EllipticProblem_DerivedClass):
AbstractParabolicProblem_Base = LinearTimeDependentProblem(
EllipticProblem_DerivedClass)
class AbstractParabolicProblem_Class(AbstractParabolicProblem_Base):
# Default initialization of members
def __init__(self, V, **kwargs):
# Call to parent
AbstractParabolicProblem_Base.__init__(self, V, **kwargs)
# Form names for parabolic problems
self.terms.append("m")
self.terms_order.update({"m": 2})
class ProblemSolver(AbstractParabolicProblem_Base.ProblemSolver):
def residual_eval(self, t, solution, solution_dot):
problem = self.problem
assembled_operator = dict()
assembled_operator["m"] = sum(
product(problem.compute_theta("m"), problem.operator["m"]))
assembled_operator["a"] = sum(
product(problem.compute_theta("a"), problem.operator["a"]))
assembled_operator["f"] = sum(
product(problem.compute_theta("f"), problem.operator["f"]))
return (assembled_operator["m"] * solution_dot +
assembled_operator["a"] * solution -
assembled_operator["f"])
def jacobian_eval(self, t, solution, solution_dot,
solution_dot_coefficient):
problem = self.problem
assembled_operator = dict()
assembled_operator["m"] = sum(
product(problem.compute_theta("m"), problem.operator["m"]))
assembled_operator["a"] = sum(
product(problem.compute_theta("a"), problem.operator["a"]))
return (assembled_operator["m"] * solution_dot_coefficient +
assembled_operator["a"])
# return value (a class) for the decorator
return AbstractParabolicProblem_Class
return AbstractCFDUnsteadyProblem_Base.import_supremizer(self, folder, filename, supremizer=supremizer, component=component, suffix=int(round(self.t/self.dt)))
def export_solution(self, folder=None, filename=None, solution_over_time=None, component=None, suffix=None):
if component is None:
component = ["u", "p"] # but not "s"
AbstractCFDUnsteadyProblem_Base.export_solution(self, folder, filename, solution_over_time, component, suffix)
def import_solution(self, folder=None, filename=None, solution_over_time=None, component=None, suffix=None):
if component is None:
component = ["u", "p"] # but not "s"
return AbstractCFDUnsteadyProblem_Base.import_solution(self, folder, filename, solution_over_time, component, suffix)
return AbstractCFDUnsteadyProblem_Class
# Base class containing the definition of saddle point problems
StokesUnsteadyProblem_Base = AbstractCFDUnsteadyProblem(LinearTimeDependentProblem(StokesProblem))
class StokesUnsteadyProblem(StokesUnsteadyProblem_Base):
class ProblemSolver(StokesUnsteadyProblem_Base.ProblemSolver):
def residual_eval(self, t, solution, solution_dot):
problem = self.problem
assembled_operator = dict()
for term in ("m", "a", "b", "bt", "f", "g"):
assembled_operator[term] = sum(product(problem.compute_theta(term), problem.operator[term]))
return (
assembled_operator["m"]*solution_dot
+ (assembled_operator["a"] + assembled_operator["b"] + assembled_operator["bt"])*solution
- assembled_operator["f"] - assembled_operator["g"]
)
def jacobian_eval(self, t, solution, solution_dot, solution_dot_coefficient):
# (at your option) any later version.
#
# RBniCS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with RBniCS. If not, see <http://www.gnu.org/licenses/>.
#
from rbnics.problems.base import LinearTimeDependentProblem
from rbnics.problems.elliptic_coercive import EllipticCoerciveProblem
from rbnics.backends import product, sum
ParabolicCoerciveProblem_Base = LinearTimeDependentProblem(
EllipticCoerciveProblem)
# Base class containing the definition of parabolic coercive problems
class ParabolicCoerciveProblem(ParabolicCoerciveProblem_Base):
# Default initialization of members
def __init__(self, V, **kwargs):
# Call to parent
ParabolicCoerciveProblem_Base.__init__(self, V, **kwargs)
# Form names for parabolic problems
self.terms.append("m")
self.terms_order.update({"m": 2})
class ProblemSolver(ParabolicCoerciveProblem_Base.ProblemSolver):
folder=None,
filename=None,
solution_over_time=None,
component=None,
suffix=None):
if component is None:
component = ["u", "p"] # but not "s"
AbstractCFDUnsteadyProblem_Base.import_solution(
self, folder, filename, solution_over_time, component, suffix)
return AbstractCFDUnsteadyProblem_Class
# Base class containing the definition of saddle point problems
StokesUnsteadyProblem_Base = AbstractCFDUnsteadyProblem(
LinearTimeDependentProblem(StokesProblem))
class StokesUnsteadyProblem(StokesUnsteadyProblem_Base):
class ProblemSolver(StokesUnsteadyProblem_Base.ProblemSolver):
def residual_eval(self, t, solution, solution_dot):
problem = self.problem
assembled_operator = dict()
for term in ("m", "a", "b", "bt", "f", "g"):
assembled_operator[term] = sum(
product(problem.compute_theta(term),
problem.operator[term]))
return (assembled_operator["m"] * solution_dot +
(assembled_operator["a"] + assembled_operator["b"] +
assembled_operator["bt"]) * solution -
assembled_operator["f"] - assembled_operator["g"])