def test_limit_conductivity_true(self): """ Test that the problem does inherit from ConductivityLimiterMixin if limit_conductivity is true. """ klass = problem.create_problem_class(limit_conductivity=True) self.assertTrue(issubclass(klass, ConductivityLimiterMixin))
def test_limit_flux_true(self): """ Test that the problem does inherit from FluxLimiterMixin if limit_flux is true. """ klass = problem.create_problem_class(limit_flux=True) self.assertTrue(issubclass(klass, FluxLimiterMixin))
def test_limit_conductivity_false(self): """ Test that the problem does not inherit from ConductivityLimiterMixin if limit_conductivity is false. """ klass = problem.create_problem_class(limit_conductivity=False) self.assertFalse(issubclass(klass, ConductivityLimiterMixin))
def test_constant_ionisation_true(self): """ Test that the problem does inherit from ConstantIonisationSHCMixin if constant_ionisation is true. """ klass = problem.create_problem_class(constant_ionisation=True) self.assertTrue(issubclass(klass, ConstantIonisationSHCMixin))
def test_limit_flux_false(self): """ Test that the problem does not inherit from FluxLimiterMixin if limit_flux is false. """ klass = problem.create_problem_class(limit_flux=False) self.assertFalse(issubclass(klass, FluxLimiterMixin))
def test_sh_conductivity_true(self): """ Test that the problem does inherit from SpitzerHarmMixin if sh_conductivity is true. """ klass = problem.create_problem_class(sh_conductivity=True) self.assertTrue(issubclass(klass, SpitzerHarmMixin))
def test_constant_ionisation_false(self): """ Test that the problem does inherits from NonConstantIonisationSHCMixin if constant_ionisation is false. """ klass = problem.create_problem_class(constant_ionisation=False) self.assertTrue(issubclass(klass, NonConstantIonisationSHCMixin))
def test_sh_conductivity_false(self): """ Test that the problem does not inherit from SpitzerHarmMixin if sh_conductivity is false. """ klass = problem.create_problem_class(sh_conductivity=False) self.assertFalse(issubclass(klass, SpitzerHarmMixin))
def test_time_dep_true(self): """ Test that the problem does inherit from TimeMixin if time_dep is true. """ klass = problem.create_problem_class(time_dep=True) self.assertTrue(issubclass(klass, TimeMixin))
def test_time_dep_false(self): """ Test that the problem does not inherit from TimeMixin if time_dep is false. """ klass = problem.create_problem_class(time_dep=False) self.assertFalse(issubclass(klass, TimeMixin))
def test_is_problem(self): """ Test that the returned class is a subclass of Problem. """ klass = problem.create_problem_class() self.assertTrue(issubclass(klass, problem.Problem)) self.assertTrue(issubclass(klass, BoundaryMixin))
def test_mix(self): """ Test that a mix of settings has all the required functionality. """ klass = problem.create_problem_class(time_dep=True, sh_conductivity=True, constant_ionisation=False, limit_flux=False, limit_conductivity=True) self.assertTrue(issubclass(klass, TimeMixin)) self.assertTrue(issubclass(klass, SpitzerHarmMixin)) self.assertTrue(issubclass(klass, NonConstantIonisationSHCMixin)) self.assertFalse(issubclass(klass, FluxLimiterMixin)) self.assertTrue(issubclass(klass, ConductivityLimiterMixin))
""" Tests for the solver.py file. """ import os import unittest from tempfile import TemporaryDirectory import numpy as np from firedrake import (Constant, FunctionSpace, SpatialCoordinate, UnitCubeMesh, UnitIntervalMesh, pi, sin) from TTiP.core.problem import create_problem_class from TTiP.core.solver import Solver SimpleSteadyState = create_problem_class(time_dep=False, sh_conductivity=False, limit_flux=False, limit_conductivity=False) SimpleTimeDep = create_problem_class(time_dep=True, sh_conductivity=False, limit_flux=False, limit_conductivity=False) # pylint: disable=protected-access class TestSolve(unittest.TestCase): """ Tests for the solve method. """ def setUp(self): """ Setup the mesh and function space.
def run(config_file, debug=False): """ Run the solve on the given problem definition config file. Args: config_file (string): The path to the config file to run. debug (bool, optional): Print debug output. Defaults to False. """ # pylint: disable=too-many-locals logger = setup_logger(debug=debug) logger.info('Running TTiP on %s', config_file) config = Config(config_file) logger.info('Setting up the problem.') start_time = time.time() logger.debug('Building mesh..') # Setup mesh and function space mesh, V = config.get_mesh() # Get parameters params = config.get_parameters() constant_ionisation = 'ionisation' in params logger.debug('Setting timescales..') # Set up timescale steps, dt, max_t = config.get_time() time_dep = (steps is not None or dt is not None or max_t is not None) limit_conductivity, limit_flux = config.get_physics_settings() ProblemClass = create_problem_class( time_dep=time_dep, sh_conductivity=True, constant_ionisation=constant_ionisation, limit_flux=limit_flux, limit_conductivity=limit_conductivity) problem = ProblemClass(mesh, V) if time_dep: problem.set_timescale(steps=steps, dt=dt, max_t=max_t) # Set up parameters ignored = [] for name, value in params.items(): try: problem.set_function(name, value) except AttributeError: ignored.append(name) if ignored: logger.info('Ignoring unnecesary parameters: %s', ', '.join(ignored)) logger.debug('Building sources..') # Set up source source = config.get_sources() problem.set_function('S', source) logger.debug('Building boundary conditions..') # Set up boundary conditions bcs = config.get_boundary_conds() for bc in bcs: problem.add_boundary(**bc) if not bcs: problem.set_no_boundary() logger.debug('Building initial value..') # Set up initial value initial_val = config.get_initial_val() problem.T.assign(initial_val) logger.info('Problem set up (%.1fs)', time.time() - start_time) logger.info('Running the solve.') start_time = time.time() # Solve file_path, method, params = config.get_solver_params() try: problem.set_method(method, **params) except AttributeError: pass solver = Solver(problem) solver.solve(file_path=file_path) logger.info('Success (%.1fs) - Results are stored in: %s', time.time() - start_time, file_path)