basis_matrix.h

Go to the documentation of this file.

/*
 * MAST: Multidisciplinary-design Adaptation and Sensitivity Toolkit
 * Copyright (C) 2013-2019  Manav Bhatia
 *
 * 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__structural_basis_matrix_h__
#define __mast__structural_basis_matrix_h__

// C++ includes
#include <vector>

// libmesh includes
#include "libmesh/shell_matrix.h"
#include "libmesh/numeric_vector.h"


namespace MAST {
    
    template <typename T>
    class BasisMatrix:
    public libMesh::ShellMatrix<T>
    {
    public:
        BasisMatrix(const libMesh::Parallel::Communicator &comm_in);
        
        virtual ~BasisMatrix();
        
        
        virtual libMesh::numeric_index_type m () const {
            
            libmesh_assert(modes.size() > 0);
            return modes[0]->size();
        }
        
        virtual libMesh::numeric_index_type n () const {
            
            libmesh_assert(modes.size() > 0);
            return (libMesh::numeric_index_type) modes.size();
        }
        
        
        template <typename VecType>
        void vector_mult (libMesh::NumericVector<T>& dest,
                          const VecType& arg) const {
            
            libmesh_assert(modes.size() > 0);
            libmesh_assert_equal_to(m(), dest.size());
            libmesh_assert_equal_to(n(), arg.size());
            
            dest.zero();
            for (unsigned int i=0; i<n(); i++)
                dest.add(arg(i), *(modes[i]));
        }
        
        virtual void
        vector_mult (libMesh::NumericVector<T>& dest,
                     const libMesh::NumericVector<T>& arg) const {
            
            // not defined for multiplcation with libMesh::NumericVector
            libmesh_assert(false);
        }
        
        
        template <typename VecType>
        void
        vector_mult_transpose (VecType& dest,
                               const libMesh::NumericVector<T>& arg) const {
            
            libmesh_assert(modes.size() > 0);
            libmesh_assert_equal_to(m(), arg.size());
            libmesh_assert_equal_to(n(), dest.size());
            
            dest.setZero(n());
            for (unsigned int i=0; i<n(); i++)
                dest(i) = arg.dot(*(modes[i]));
        }
        
        
        virtual void
        vector_mult_transpose (libMesh::NumericVector<T>& dest,
                               const libMesh::NumericVector<T>& arg) const {
            
            // not defined for multiplcation with libMesh::NumericVector
            libmesh_assert(false);
        }
        
        virtual void
        vector_mult_add (libMesh::NumericVector<T>& dest,
                         const libMesh::NumericVector<T>& arg) const {
            
            // not defined for multiplcation with libMesh::NumericVector
            libmesh_assert(false);
        }
        
        
        virtual void
        get_diagonal (libMesh::NumericVector<T>& dest) const {
            
            // not defined for multiplcation with libMesh::NumericVector
            libmesh_assert(false);
        }
        
        
        virtual libMesh::NumericVector<T>&
        basis(unsigned int i) {
            
            // not defined for multiplcation with libMesh::NumericVector
            libmesh_assert(modes.size() > 0);
            libmesh_assert_less(i, modes.size());
            
            return *(modes[i]);
        }
        
        std::vector<libMesh::NumericVector<T>*> modes;
    };
    
}

#endif // __mast__structural_basis_matrix_h__