Esempio n. 1
0
    def __init__(self, grid, fields):
        timer = Timer('setup'); timer.start()
        mesh = fields[0].function_space().mesh()
        # Same meshes for all
        assert all(mesh.id() == f.function_space().mesh().id() for f in fields)

        # Locate each point
        limit = mesh.num_entities_global(mesh.topology().dim())
        bbox_tree = mesh.bounding_box_tree()

        npoints = np.prod(grid.ns)
        cells_for_x = [None]*npoints
        for i, x in enumerate(grid.points()):
            cell = bbox_tree.compute_first_entity_collision(Point(*x))
            if -1 < cell < limit:
                cells_for_x[i] = Cell(mesh, cell)
        assert not any(c is None for c in cells_for_x)

        # For each field I want to build a function which which evals
        # it at all the points
        self.data = {}
        self.eval_fields = []
        for u in fields:
            # Alloc
            key = u.name()
            self.data[key] = [np.zeros(npoints) for _ in range(u.value_size())]
            # Attach the eval for u
            self.eval_fields.append(eval_u(u, grid.points(), cells_for_x, self.data[key]))
        info('Probe setup took %g' % timer.stop())
        self.grid = grid
        # Get values at construction
        self.update()
Esempio n. 2
0
 def update(self):
     '''Evaluate now (with the fields as they are at the moment)'''
     timer = Timer('update'); timer.start()
     status = [f() for f in self.eval_fields]
     info('Probe update took %g' % timer.stop())
     return all(status)
Esempio n. 3
0
        # Initialize the l2 projection
        lstsq_psi = l2projection(p, W, property_idx)

        # Set initial condition at mesh and particles
        psi0_h.interpolate(psi0_expression)
        p.interpolate(psi0_h.cpp_object(), property_idx)

        # Initialize add/delete particle
        AD = AddDelete(p, 15, 25, [psi0_h])

        step = 0
        t = 0.0
        area_0 = assemble(psi0_h * dx)
        timer = Timer()

        timer.start()
        while step < num_steps:
            step += 1
            t += float(dt)

            if comm.rank == 0:
                print("Step " + str(step))

            # Advect particle, assemble and solve pde projection
            t1 = Timer("[P] Advect particles step")
            AD.do_sweep()
            ap.do_step(float(dt))
            AD.do_sweep_failsafe(4)
            del t1

            if projection_type == "PDE":
Esempio n. 4
0
    def solve(self):
        """
        Solve optmal control problem

        """

        msg = "You need to build the problem before solving it"
        assert hasattr(self, "opt_type"), msg

        module, method = self.opt_type.split("_")

        logger.info("\n" + "Starting optimization".center(100, "-"))
        logger.info(
            "Scale: {}, \nDerivative Scale: {}".format(
                self.rd.scale, self.rd.derivative_scale
            )
        )
        logger.info(
            "Tolerace: {}, \nMaximum iterations: {}\n".format(self.tol, self.max_iter)
        )

        t = Timer()
        t.start()

        if self.oneD:

            res = minimize_1d(self.rd, self.x[0], **self.options)
            x = res["x"]

        else:

            if module == "scipy":
                res = scipy_minimize(self.rd, self.x, **self.options)
                x = res["x"]

            elif module == "pyOpt":

                obj, x, d = self.problem(**self.options)

            elif module == "moola":

                sol = self.solver.solve()
                x = sol["control"].data

            elif module == "ipopt":
                x = self.solver.solve(self.x)

            else:
                msg = (
                    "Unknown optimizatin type {}. "
                    "Define the optimization type as 'module-method', "
                    "where module is e.g scipy, pyOpt and methos is "
                    "eg slsqp."
                )
                raise ValueError(msg)

        run_time = t.stop()

        opt_result = {}

        opt_result["x"] = x
        opt_result["nfev"] = self.rd.iter
        opt_result["nit"] = self.rd.iter
        opt_result["njev"] = self.rd.nr_der_calls
        opt_result["ncrash"] = self.rd.nr_crashes
        opt_result["run_time"] = run_time
        opt_result["controls"] = self.rd.controls_lst
        opt_result["func_vals"] = self.rd.func_values_lst
        opt_result["forward_times"] = self.rd.forward_times
        opt_result["backward_times"] = self.rd.backward_times
        opt_result["grad_norm"] = self.rd.grad_norm

        return self.rd, opt_result
Esempio n. 5
0
def main(module_name, ncases, params, petsc_params):
    '''
    Run the test case in module with ncases. Optionally store results
    in savedir. For some modules there are multiple (which) choices of 
    preconditioners.
    '''
    
    # Unpack
    for k, v in params.items(): exec(k + '=v', locals())

    RED = '\033[1;37;31m%s\033[0m'
    print RED % ('\tRunning %s with %d preconditioner' % (module_name, precond))

    module = __import__(module_name)  # no importlib in python2.7

    # Setup the MMS case
    u_true, rhs_data = module.setup_mms(eps)

    # Setup the convergence monitor
    if log:
        params = [('solver', solver), ('precond', str(precond)), ('eps', str(eps))]
        
        path = '_'.join([module_name] + ['%s=%s' % pv for pv in params])
        path = os.path.join(save_dir if save_dir else '.', path)
        path = '.'.join([path, 'txt'])
    else:
        path = ''

    memory, residuals  = [], []
    monitor = module.setup_error_monitor(u_true, memory, path=path)

    # Sometimes it is usedful to transform the solution before computing
    # the error. e.g. consider subdomains
    if hasattr(module, 'setup_transform'):
        # NOTE: transform take two args for case and the current computed
        # solution
        transform = module.setup_transform
    else:
        transform = lambda i, x: x

    print '='*79
    print '\t\t\tProblem eps = %r' % eps
    print '='*79
    for i in ncases:
        a, L, W = module.setup_problem(i, rhs_data, eps=eps)
        
        # Assemble blocks
        t = Timer('assembly'); t.start()
        AA, bb = map(ii_assemble, (a, L))
        print '\tAssembled blocks in %g s' % t.stop()

        # Check the symmetry
        wh = ii_Function(W)

        assert (AA*wh.block_vec() - (AA.T)*wh.block_vec()).norm() < 1E-10

        if solver == 'direct':
            # Turn into a (monolithic) PETScMatrix/Vector
            t = Timer('conversion'); t.start()        
            AAm, bbm = map(ii_convert, (AA, bb))
            print '\tConversion to PETScMatrix/Vector took %g s' % t.stop()

            t = Timer('solve'); t.start()
            LUSolver('umfpack').solve(AAm, wh.vector(), bbm)
            print '\tSolver took %g s' % t.stop()

            niters = 1

        if solver == 'iterative':
            # Here we define a Krylov solver using PETSc
            BB = module.setup_preconditioner(W, precond, eps=eps)

            ## AA and BB as block_mat
            ksp = PETSc.KSP().create()

            # Default is minres
            if '-ksp_type' not in petsc_params: petsc_params['-ksp_type'] = 'minres'
            
            opts = PETSc.Options()
            for key, value in petsc_params.iteritems():
                opts.setValue(key, None if value == 'none' else value)

            ksp.setOperators(ii_PETScOperator(AA))

            ksp.setNormType(PETSc.KSP.NormType.NORM_PRECONDITIONED)
            # ksp.setTolerances(rtol=1E-6, atol=None, divtol=None, max_it=300)
            ksp.setConvergenceHistory()
            # We attach the wrapped preconditioner defined by the module
            ksp.setPC(ii_PETScPreconditioner(BB, ksp))
            
            ksp.setFromOptions()
            
            print ksp.getTolerances()
            
            # Want the iterations to start from random
            wh.block_vec().randomize()

            # Solve, note the past object must be PETSc.Vec
            t = Timer('solve'); t.start()            
            ksp.solve(as_petsc_nest(bb), wh.petsc_vec())
            print '\tSolver took %g s' % t.stop()

            niters = ksp.getIterationNumber()

            residuals.append(ksp.getConvergenceHistory())
            
        # Let's check the final size of the residual
        r_norm = (bb - AA*wh.block_vec()).norm()
        # Convergence?
        monitor.send((transform(i, wh), W, niters, r_norm))
        
    # Only send the final
    if save_dir:
        path = os.path.join(save_dir, module_name)
        for i, wh_i in enumerate(wh):
            # Renaming to make it easier to save state in Visit/Pareview
            wh_i.rename('u', str(i))
            
            File('%s_%d.pvd' % (path, i)) << wh_i

    # Plot relative residual norm
    if plot:
        plt.figure()
        [plt.semilogy(res/res[0], label=str(i)) for i, res in enumerate(residuals, 1)]
        plt.legend(loc='best')
        plt.show()
Esempio n. 6
0
def main(module_name, ncases, params, petsc_params):
    '''
    Run the test case in module with ncases. Optionally store results
    in savedir. For some modules there are multiple (which) choices of 
    preconditioners.
    '''

    # Unpack
    for k, v in params.items():
        exec(k + '=v', locals())

    RED = '\033[1;37;31m%s\033[0m'
    print RED % ('\tRunning %s' % module_name)

    module = __import__(module_name)  # no importlib in python2.7

    # Setup the MMS case
    u_true, rhs_data = module.setup_mms(eps)

    # Setup the convergence monitor
    if log:
        params = [('solver', solver), ('precond', str(precond)),
                  ('eps', str(eps))]

        path = '_'.join([module_name] + ['%s=%s' % pv for pv in params])
        path = os.path.join(save_dir if save_dir else '.', path)
        path = '.'.join([path, 'txt'])
    else:
        path = ''

    memory, residuals = [], []
    monitor = module.setup_error_monitor(u_true, memory, path=path)

    # Sometimes it is usedful to transform the solution before computing
    # the error. e.g. consider subdomains
    if hasattr(module, 'setup_transform'):
        # NOTE: transform take two args for case and the current computed
        # solution
        transform = module.setup_transform
    else:
        transform = lambda i, x: x

    print '=' * 79
    print '\t\t\tProblem eps = %g' % eps
    print '=' * 79
    for i in ncases:
        a, L, W = module.setup_problem(i, rhs_data, eps=eps)

        # Assemble blocks
        t = Timer('assembly')
        t.start()
        AA, bb = map(ii_assemble, (a, L))
        print '\tAssembled blocks in %g s' % t.stop()

        wh = ii_Function(W)

        if solver == 'direct':
            # Turn into a (monolithic) PETScMatrix/Vector
            t = Timer('conversion')
            t.start()
            AAm, bbm = map(ii_convert, (AA, bb))
            print '\tConversion to PETScMatrix/Vector took %g s' % t.stop()

            t = Timer('solve')
            t.start()
            LUSolver('umfpack').solve(AAm, wh.vector(), bbm)
            print '\tSolver took %g s' % t.stop()

            niters = 1
        else:
            # Here we define a Krylov solver using PETSc
            BB = module.setup_preconditioner(W, precond, eps=eps)
            ## AA and BB as block_mat
            ksp = PETSc.KSP().create()

            # Default is minres
            if '-ksp_type' not in petsc_params:
                petsc_params['-ksp_type'] = 'minres'

            opts = PETSc.Options()
            for key, value in petsc_params.iteritems():
                opts.setValue(key, None if value == 'none' else value)

            ksp.setOperators(ii_PETScOperator(AA))

            ksp.setNormType(PETSc.KSP.NormType.NORM_PRECONDITIONED)
            # ksp.setTolerances(rtol=1E-6, atol=None, divtol=None, max_it=300)
            ksp.setConvergenceHistory()
            # We attach the wrapped preconditioner defined by the module
            ksp.setPC(ii_PETScPreconditioner(BB, ksp))

            ksp.setFromOptions()

            print ksp.getTolerances()

            # Want the iterations to start from random
            wh.block_vec().randomize()
            # Solve, note the past object must be PETSc.Vec
            t = Timer('solve')
            t.start()
            ksp.solve(as_petsc_nest(bb), wh.petsc_vec())
            print '\tSolver took %g s' % t.stop()

            niters = ksp.getIterationNumber()

            residuals.append(ksp.getConvergenceHistory())

        # Let's check the final size of the residual
        r_norm = (bb - AA * wh.block_vec()).norm()

        # Convergence?
        monitor.send((transform(i, wh), niters, r_norm))

    # Only send the final
    if save_dir:
        path = os.path.join(save_dir, module_name)
        for i, wh_i in enumerate(wh):
            # Renaming to make it easier to save state in Visit/Pareview
            wh_i.rename('u', str(i))

            File('%s_%d.pvd' % (path, i)) << wh_i

    # Plot relative residual norm
    if plot:
        plt.figure()
        [
            plt.semilogy(res / res[0], label=str(i))
            for i, res in enumerate(residuals, 1)
        ]
        plt.legend(loc='best')
        plt.show()
    def solve(self):
        """
        Solve optmal control problem

        """

        # msg = "You need to build the problem before solving it"
        # assert hasattr(self, "opt_type"), msg

        module = self.parameters["opt_lib"]

        logger.info("Starting optimization")
        # logger.info(
        #     "Scale: {}, \nDerivative Scale: {}".format(
        #         self.J.scale, self.J.derivative_scale
        #     )
        # )
        # logger.info(
        #     "Tolerace: {}, \nMaximum iterations: {}\n".format(self.tol, self.max_iter)
        # )

        t = Timer()
        t.start()

        if self.parameters["nvar"] == 1:

            res = minimize_1d(self.J, self.x[0], **self.options)
            x = res["x"]

        else:

            if module == "scipy":
                res = scipy_minimize(self.J, self.x, **self.options)
                x = res["x"]

            elif module == "pyOpt":
                obj, x, d = self.problem(**self.options)

            elif module == "moola":
                sol = self.solver.solve()
                x = sol["control"].data

            elif module == "ipopt":
                x = self.solver.solve(self.x)

            else:
                msg = (
                    "Unknown optimizatin type {}. "
                    "Define the optimization type as 'module-method', "
                    "where module is e.g scipy, pyOpt and methos is "
                    "eg slsqp."
                )
                raise ValueError(msg)

        run_time = t.stop()
        # opt_result = {}
        # opt_result['initial_contorl'] = self.initial_control
        # opt_result["optimal_control"] = x
        # opt_result["run_time"] = run_time
        # opt_result["nfev"] = self.J.iter
        # opt_result["nit"] = self.J.iter
        # opt_result["njev"] = self.J.nr_der_calls
        # opt_result["ncrash"] = self.J.nr_crashes
        # opt_result["controls"] = self.J.controls_lst
        # opt_result["func_vals"] = self.J.func_values_lst
        # opt_result["forwaJ_times"] = self.J.forwaJ_times
        # opt_result["backwaJ_times"] = self.J.backwaJ_times
        # opt_result["grad_norm"] = self.J.grad_norm
        return optimization_results(
            initial_control=self.initial_control, optimal_control=x, run_time=run_time
        )