class FactoryTester(unittest.TestCase): def setUp(self): self.factory = Factory() ## Tests the createParametersObject() function without a type parameter def testCreateParametersObjectWithNoTypeParam(self): params = {"gamma" : "1.4", "R" : "200"} self.factory.createParametersObject("IdealGasEoS", params) ## Tests the createParametersObject() function with a type parameter def testCreateParametersObjectWithTypeParam(self): params = {"type" : "IdealGasEoS", "gamma" : "1.4", "R" : "200"} object_class = params["type"] self.factory.createParametersObject(object_class, params) ## Tests the createObject() function def testCreateObject(self): params = {"type" : "IdealGasEoS", "gamma" : "1.4", "R" : "200"} object_class = params["type"] self.factory.createObject(object_class, params) ## Tests the createObjectFromParametersObject() function def testCreateObjectFromParametersObject(self): object_class = "IdealGasEoS" parameters_object = self.factory.createParametersObject(object_class) parameters_object.set("gamma", 1.4) parameters_object.set("R", 200) self.factory.createObjectFromParametersObject(object_class, parameters_object)
def checkJacobian(self, test_option, model_type=ModelType.OnePhase, phase=0, junction_params=dict(), fd_eps=1e-8): # factory factory = Factory() # meshes params1 = {"n_cell": 1, "name": "mesh1"} params2 = {"n_cell": 1, "name": "mesh2"} meshes = [ factory.createObject("UniformMesh", params1), factory.createObject("UniformMesh", params2) ] # area function def A(x): return 0.2 # DoF handler dof_handler_params = {"meshes": meshes, "A": A} if model_type == ModelType.OnePhase: dof_handler_class = "DoFHandler1Phase" elif model_type == ModelType.TwoPhaseNonInteracting: dof_handler_class = "DoFHandler2PhaseNonInteracting" def vf1_initial(x): return 0.3 dof_handler_params["initial_vf1"] = vf1_initial elif model_type == ModelType.TwoPhase: dof_handler_class = "DoFHandler2Phase" dof_handler = factory.createObject(dof_handler_class, dof_handler_params) n_dof = dof_handler.n_dof # equation of state eos_params1 = {"slope_initial": 1.0, "slope_increment": 0.1} eos_list = [factory.createObject("TestEoS", eos_params1)] if model_type != ModelType.OnePhase: eos_params2 = {"slope_initial": 1.1, "slope_increment": 0.07} eos_list.append(factory.createObject("TestEoS", eos_params2)) # junction junction_params["mesh_names"] = " ".join( [mesh.name for mesh in meshes]) junction_params["mesh_sides"] = "right left" junction_params["dof_handler"] = dof_handler junction_params["eos_list"] = eos_list junction_parameters = factory.createParametersObject( self.junction_name) for param in junction_params: junction_parameters.set(param, junction_params[param]) if junction_parameters.hasRegisteredParam("phase"): junction_parameters.set("phase", phase) junction = factory.createObjectFromParametersObject( self.junction_name, junction_parameters) # update DoF handler with junction constraints dof_handler.updateWithJunctionConstraints([junction]) # compute base solution U = np.zeros(n_dof) U_old = np.zeros(n_dof) for i in xrange(n_dof): U[i] = i + 1.0 U_old[i] = i + 2.0 # determine evaluation function if test_option == "weak": f = junction.applyWeaklyToNonlinearSystem elif test_option == "strong": f = junction.applyStronglyToNonlinearSystem elif test_option == "both": def f(*args, **kwargs): junction.applyWeaklyToNonlinearSystem(*args, **kwargs) junction.applyStronglyToNonlinearSystem(*args, **kwargs) else: error("Invalid test option") # base calculation r = np.zeros(n_dof) J_hand_coded = np.zeros(shape=(n_dof, n_dof)) f(U, U_old, r, J_hand_coded) # finite difference Jacobians rel_diffs = np.zeros(shape=(n_dof, n_dof)) J_fd = np.zeros(shape=(n_dof, n_dof)) for j in xrange(n_dof): # perturb solution U_perturbed = deepcopy(U) U_perturbed[j] += fd_eps # compute finite difference Jacobian r_perturbed = np.zeros(n_dof) J_perturbed = np.zeros(shape=(n_dof, n_dof)) f(U_perturbed, U_old, r_perturbed, J_perturbed) for i in xrange(n_dof): J_fd[i, j] = (r_perturbed[i] - r[i]) / fd_eps # compute difference matrices abs_diffs = abs(J_hand_coded - J_fd) rel_diffs = computeRelativeDifferenceMatrix(J_hand_coded, J_fd) # print results if self.verbose: print "\nRelative difference of Jacobian for " + test_option + " contributions:" printRelativeMatrixDifference(rel_diffs, abs_diffs, 1e-1, 1e-3) matched = np.zeros((n_dof, n_dof), dtype=bool) for i in xrange(n_dof): for j in xrange(n_dof): matched[i, j] = abs_diffs[i, j] < self.abs_tol or rel_diffs[ i, j] < self.rel_tol return matched