assembly_base.h

Go to the documentation of this file.

/*
 * MAST: Multidisciplinary-design Adaptation and Sensitivity Toolkit
 * Copyright (C) 2013-2020  Manav Bhatia and MAST authors
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __mast__system_assembly_base_h__
#define __mast__system_assembly_base_h__

// C++ includes
#include <map>
#include <memory>


// MAST includes
#include "base/mast_data_types.h"


// libMesh includes
#include "libmesh/system.h"
#include "libmesh/nonlinear_implicit_system.h"
#include "libmesh/sparse_matrix.h"


namespace MAST {
    
    // Forward declerations
    class PhysicsDisciplineBase;
    class SystemInitialization;
    class ElementBase;
    class MeshFieldFunction;
    class NonlinearSystem;
    class FEBase;
    class AssemblyElemOperations;
    class OutputAssemblyElemOperations;
    class FunctionBase;
    
    class AssemblyBase:
    public libMesh::NonlinearImplicitSystem::ComputeResidualandJacobian {
    public:
        
        AssemblyBase();
        
        virtual ~AssemblyBase();
        
        std::set<unsigned int> diagonal_elem_subdomain_id;
        

        class SolverMonitor {
        public:
            SolverMonitor(){}
            virtual ~SolverMonitor(){}
            virtual void init(MAST::AssemblyBase& assembly) = 0;
            virtual void clear() = 0;
        };
        
        class ElemParameterDependence {
        public:
            ElemParameterDependence(bool o_flag): override_flag(o_flag) {}
            virtual ~ElemParameterDependence() {}
            virtual bool if_elem_depends_on_parameter(const libMesh::Elem& e,
                                                      const MAST::FunctionBase& p) const = 0;
            bool override_flag;
        };
        
        bool close_matrix;
        
        const MAST::PhysicsDisciplineBase& discipline() const;
        
        MAST::PhysicsDisciplineBase& discipline();
        
        
        MAST::AssemblyElemOperations& get_elem_ops();
        
        
        virtual void
        set_discipline_and_system(MAST::PhysicsDisciplineBase& discipline,
                                  MAST::SystemInitialization& system);

        void
        attach_elem_parameter_dependence_object(MAST::AssemblyBase::ElemParameterDependence& dep);

        
        void
        clear_elem_parameter_dependence_object();

        
        virtual void
        clear_discipline_and_system();


        virtual void
        set_elem_operation_object(MAST::AssemblyElemOperations& elem_ops);

        
        virtual void
        clear_elem_operation_object();

        
        const MAST::NonlinearSystem& system() const;
        
        MAST::NonlinearSystem& system();

        MAST::SystemInitialization& system_init();


        void set_solver_monitor(MAST::AssemblyBase::SolverMonitor& monitor);

        MAST::AssemblyBase::SolverMonitor* get_solver_monitor();

        void clear_solver_monitor();
        
        void attach_solution_function(MAST::MeshFieldFunction& f);

        
        void detach_solution_function();
        
        virtual void
        residual_and_jacobian (const libMesh::NumericVector<Real>& X,
                               libMesh::NumericVector<Real>* R,
                               libMesh::SparseMatrix<Real>*  J,
                               libMesh::NonlinearImplicitSystem& S) {
            libmesh_assert(false); // implement in the derived class
        }

        virtual bool
        sensitivity_assemble (const libMesh::NumericVector<Real>& X,
                              bool if_localize_sol,
                              const MAST::FunctionBase& f,
                              libMesh::NumericVector<Real>& sensitivity_rhs,
                              bool close_vector = true) {
            libmesh_assert(false); // implemented in the derived class
        }

        virtual void
        calculate_output(const libMesh::NumericVector<Real>& X,
                         bool if_localize_sol,
                         MAST::OutputAssemblyElemOperations& output);

        
        virtual void
        calculate_output_derivative(const libMesh::NumericVector<Real>& X,
                                    bool if_localize_sol,
                                    MAST::OutputAssemblyElemOperations& output,
                                    libMesh::NumericVector<Real>& dq_dX);

        
        virtual void
        calculate_output_direct_sensitivity(const libMesh::NumericVector<Real>& X,
                                            bool if_localize_sol,
                                            const libMesh::NumericVector<Real>* dXdp,
                                            bool if_localize_sol_sens,
                                            const MAST::FunctionBase& p,
                                            MAST::OutputAssemblyElemOperations& output);

        
        virtual Real
        calculate_output_adjoint_sensitivity(const libMesh::NumericVector<Real>& X,
                                             bool if_localize_sol,
                                             const libMesh::NumericVector<Real>& adj_sol,
                                             const MAST::FunctionBase& p,
                                             MAST::AssemblyElemOperations&       elem_ops,
                                             MAST::OutputAssemblyElemOperations& output,
                                             const bool include_partial_sens = true);

        
        virtual void
        calculate_output_adjoint_sensitivity_multiple_parameters_no_direct
        (const libMesh::NumericVector<Real>&           X,
         bool                                          if_localize_sol,
         const libMesh::NumericVector<Real>&           adj_sol,
         const std::vector<const MAST::FunctionBase*>& p_vec,
         MAST::AssemblyElemOperations&                 elem_ops,
         MAST::OutputAssemblyElemOperations&           output,
         std::vector<Real>&                            sens);

        
        std::unique_ptr<libMesh::NumericVector<Real> >
        build_localized_vector(const libMesh::System& sys,
                               const libMesh::NumericVector<Real>& global) const;
        
        
    protected:
        
        MAST::AssemblyElemOperations*  _elem_ops;

        
        MAST::PhysicsDisciplineBase* _discipline;
        
        
        MAST::SystemInitialization* _system;
        
        MAST::MeshFieldFunction* _sol_function;
        
        MAST::AssemblyBase::SolverMonitor *_solver_monitor;
        
        MAST::AssemblyBase::ElemParameterDependence *_param_dependence;
    };
        
}

#endif // __mast__system_assembly_base_h__