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"])