AbstractStaticAssembler.hpp

/*

Copyright (C) University of Oxford, 2005-2009

University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.

This file is part of Chaste.

Chaste 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.

Chaste 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. The offer of Chaste under the terms of the
License is subject to the License being interpreted in accordance with
English Law and subject to any action against the University of Oxford
being under the jurisdiction of the English Courts.

You should have received a copy of the GNU Lesser General Public License
along with Chaste. If not, see <http://www.gnu.org/licenses/>.

*/
#ifndef _ABSTRACTSTATICASSEMBLER_HPP_
#define _ABSTRACTSTATICASSEMBLER_HPP_

#include "AbstractAssembler.hpp"
#include "LinearBasisFunction.hpp"
#include "GaussianQuadratureRule.hpp"
#include "AbstractMesh.hpp"
#include "BoundaryConditionsContainer.hpp"
#include "LinearSystem.hpp"
#include "GaussianQuadratureRule.hpp"
#include "ReplicatableVector.hpp"
#include "DistributedVector.hpp"
#include "PetscTools.hpp"
#include "HeartEventHandler.hpp"
#include <iostream>

#include <boost/mpl/void.hpp>

template<class T>
struct AssemblerTraits
{
    typedef T CVT_CLS;
    typedef T CMT_CLS;
    typedef AbstractAssembler<T::E_DIM, T::S_DIM, T::P_DIM> INTERPOLATE_CLS;
};

template<>
struct AssemblerTraits<boost::mpl::void_>
{
    typedef boost::mpl::void_ CVT_CLS;
    typedef boost::mpl::void_ CMT_CLS;
    typedef boost::mpl::void_ INTERPOLATE_CLS;
};

template <unsigned ELEMENT_DIM, unsigned SPACE_DIM, unsigned PROBLEM_DIM, bool NON_HEART, class CONCRETE>
class AbstractStaticAssembler : virtual public AbstractAssembler<ELEMENT_DIM,SPACE_DIM,PROBLEM_DIM>
{
protected:
    AbstractMesh<ELEMENT_DIM, SPACE_DIM>* mpMesh;

    GaussianQuadratureRule<ELEMENT_DIM> *mpQuadRule;
    GaussianQuadratureRule<ELEMENT_DIM-1> *mpSurfaceQuadRule;


    typedef LinearBasisFunction<ELEMENT_DIM> BasisFunction;
    typedef LinearBasisFunction<ELEMENT_DIM-1> SurfaceBasisFunction;

    ReplicatableVector mCurrentSolutionOrGuessReplicated;

    LinearSystem *mpLinearSystem;


    virtual void AssembleOnElement( Element<ELEMENT_DIM,SPACE_DIM> &rElement,
                                    c_matrix<double, PROBLEM_DIM*(ELEMENT_DIM+1), PROBLEM_DIM*(ELEMENT_DIM+1) > &rAElem,
                                    c_vector<double, PROBLEM_DIM*(ELEMENT_DIM+1)> &rBElem,
                                    bool assembleVector,
                                    bool assembleMatrix)
    {
        GaussianQuadratureRule<ELEMENT_DIM> &quad_rule =
            *(AbstractStaticAssembler<ELEMENT_DIM,SPACE_DIM,PROBLEM_DIM, NON_HEART, CONCRETE>::mpQuadRule);

        c_matrix<double, SPACE_DIM, SPACE_DIM> jacobian;
        c_matrix<double, SPACE_DIM, SPACE_DIM> inverse_jacobian;
        double jacobian_determinant;
        
        mpMesh->GetInverseJacobianForElement(rElement.GetIndex(), jacobian, jacobian_determinant, inverse_jacobian);

// With the new signature of GetInverseJacobianForElement, inverse and jacobian are returned at the same time
//        // Initialise element contributions to zero
//        if ( assembleMatrix || this->ProblemIsNonlinear() ) // don't need to construct grad_phi or grad_u in that case
//        {
//            this->mpMesh->GetInverseJacobianForElement(rElement.GetIndex(), inverse_jacobian);
//        }

        if (assembleMatrix)
        {
            rAElem.clear();
        }

        if (assembleVector)
        {
            rBElem.clear();
        }

        const unsigned num_nodes = rElement.GetNumNodes();

        // allocate memory for the basis functions values and derivative values
        c_vector<double, ELEMENT_DIM+1> phi;
        c_matrix<double, ELEMENT_DIM, ELEMENT_DIM+1> grad_phi;

        // loop over Gauss points
        for (unsigned quad_index=0; quad_index < quad_rule.GetNumQuadPoints(); quad_index++)
        {
            const ChastePoint<ELEMENT_DIM>& quad_point = quad_rule.rGetQuadPoint(quad_index);

            BasisFunction::ComputeBasisFunctions(quad_point, phi);

            if ( assembleMatrix || this->ProblemIsNonlinear() )
            {
                BasisFunction::ComputeTransformedBasisFunctionDerivatives(quad_point, inverse_jacobian, grad_phi);
            }

            // Location of the gauss point in the original element will be stored in x
            // Where applicable, u will be set to the value of the current solution at x
            ChastePoint<SPACE_DIM> x(0,0,0);

            c_vector<double,PROBLEM_DIM> u = zero_vector<double>(PROBLEM_DIM);
            c_matrix<double,PROBLEM_DIM,SPACE_DIM> grad_u = zero_matrix<double>(PROBLEM_DIM,SPACE_DIM);

            // allow the concrete version of the assembler to interpolate any
            // desired quantities
            static_cast<typename AssemblerTraits<CONCRETE>::INTERPOLATE_CLS *>(this)->ResetInterpolatedQuantities();


            // interpolation
            for (unsigned i=0; i<num_nodes; i++)
            {
                const Node<SPACE_DIM> *p_node = rElement.GetNode(i);

                if (NON_HEART)
                {
                    const c_vector<double, SPACE_DIM>& r_node_loc = p_node->rGetLocation();
                    // interpolate x
                    x.rGetLocation() += phi(i)*r_node_loc;
                }

                // interpolate u and grad u if a current solution or guess exists
                unsigned node_global_index = rElement.GetNodeGlobalIndex(i);
                if (mCurrentSolutionOrGuessReplicated.size()>0)
                {
                    for (unsigned index_of_unknown=0; index_of_unknown<(NON_HEART ? PROBLEM_DIM : 1); index_of_unknown++)
                    {
                        // If we have a current solution (e.g. this is a dynamic problem)
                        // get the value in a usable form.rElement

                        // NOTE - currentSolutionOrGuess input is actually now redundant at this point -

                        // NOTE - following assumes that, if say there are two unknowns u and v, they
                        // are stored in the current solution vector as
                        // [U1 V1 U2 V2 ... U_n V_n]
                        double u_at_node=GetCurrentSolutionOrGuessValue(node_global_index, index_of_unknown);
                        u(index_of_unknown) += phi(i)*u_at_node;

                        if (this->ProblemIsNonlinear() ) // don't need to construct grad_phi or grad_u in that case
                        {
                            for (unsigned j=0; j<SPACE_DIM; j++)
                            {
                                grad_u(index_of_unknown,j) += grad_phi(j,i)*u_at_node;
                            }
                        }
                    }
                }

                // allow the concrete version of the assembler to interpolate any
                // desired quantities
                static_cast<typename AssemblerTraits<CONCRETE>::INTERPOLATE_CLS *>(this)->IncrementInterpolatedQuantities(phi(i), p_node);
            }
            
            //HeartEventHandler::BeginEvent(HeartEventHandler::USER1); //Temporarily using USER1 to instrument the Compute.. terms
            double wJ = jacobian_determinant * quad_rule.GetWeight(quad_index);

            // create rAElem and rBElem
            if (assembleMatrix)
            {
                noalias(rAElem) += static_cast<typename AssemblerTraits<CONCRETE>::CMT_CLS *>(this)->ComputeMatrixTerm(phi, grad_phi, x, u, grad_u, &rElement) * wJ;
            }

            if (assembleVector)
            {
                noalias(rBElem) += static_cast<typename AssemblerTraits<CONCRETE>::CVT_CLS *>(this)->ComputeVectorTerm(phi, grad_phi, x, u, grad_u, &rElement) * wJ;
            }
            //HeartEventHandler::EndEvent(HeartEventHandler::USER1); //Temporarily using USER1 to instrument the Compute.. terms
        }
    }



    virtual void AssembleOnSurfaceElement(const BoundaryElement<ELEMENT_DIM-1,SPACE_DIM> &rSurfaceElement,
                                          c_vector<double, PROBLEM_DIM*ELEMENT_DIM> &rBSurfElem)
    {
        GaussianQuadratureRule<ELEMENT_DIM-1> &quad_rule =
            *(AbstractStaticAssembler<ELEMENT_DIM,SPACE_DIM,PROBLEM_DIM, NON_HEART, CONCRETE>::mpSurfaceQuadRule);

        c_vector<double, SPACE_DIM> weighted_direction;
        double jacobian_determinant;
        mpMesh->GetWeightedDirectionForBoundaryElement(rSurfaceElement.GetIndex(), weighted_direction, jacobian_determinant);

        rBSurfElem.clear();

        // allocate memory for the basis function values
        c_vector<double, ELEMENT_DIM>  phi;

        // loop over Gauss points
        for (unsigned quad_index=0; quad_index<quad_rule.GetNumQuadPoints(); quad_index++)
        {
            const ChastePoint<ELEMENT_DIM-1>& quad_point = quad_rule.rGetQuadPoint(quad_index);

            SurfaceBasisFunction::ComputeBasisFunctions(quad_point, phi);


            // interpolation

            // Location of the gauss point in the original element will be
            // stored in x
            ChastePoint<SPACE_DIM> x(0,0,0);

            this->ResetInterpolatedQuantities();
            for (unsigned i=0; i<rSurfaceElement.GetNumNodes(); i++)
            {
                const c_vector<double, SPACE_DIM> node_loc = rSurfaceElement.GetNode(i)->rGetLocation();
                x.rGetLocation() += phi(i)*node_loc;

                // allow the concrete version of the assembler to interpolate any
                // desired quantities
                IncrementInterpolatedQuantities(phi(i), rSurfaceElement.GetNode(i));

            }

            double wJ = jacobian_determinant * quad_rule.GetWeight(quad_index);

            // create rAElem and rBElem
            noalias(rBSurfElem) += ComputeVectorSurfaceTerm(rSurfaceElement, phi, x) * wJ;
        }
    }



    virtual void AssembleSystem(bool assembleVector, bool assembleMatrix,
                                Vec currentSolutionOrGuess=NULL, double currentTime=0.0)
    {
        HeartEventHandler::EventType assemble_event;
        if(assembleMatrix)
        {
            assemble_event = HeartEventHandler::ASSEMBLE_SYSTEM;
        }
        else
        {
            assemble_event = HeartEventHandler::ASSEMBLE_RHS;
        }

        // Check we've actually been asked to do something!
        assert(assembleVector || assembleMatrix);

        // Check the linear system object has been set up correctly
        assert(mpLinearSystem != NULL);
        assert(mpLinearSystem->GetSize() == PROBLEM_DIM * this->mpMesh->GetNumNodes());
        assert(!assembleVector || mpLinearSystem->rGetRhsVector() != NULL);
        assert(!assembleMatrix || mpLinearSystem->rGetLhsMatrix() != NULL);

//        // Is the matrix symmetric?
//        if (assembleMatrix && !this->mpBoundaryConditions->HasDirichletBoundaryConditions())
//        {
//            mpLinearSystem->SetMatrixIsSymmetric();
//        }

        // Replicate the current solution and store so can be used in
        // AssembleOnElement
        if (currentSolutionOrGuess != NULL)
        {
            HeartEventHandler::BeginEvent(HeartEventHandler::COMMUNICATION);
            this->mCurrentSolutionOrGuessReplicated.ReplicatePetscVector(currentSolutionOrGuess);
            HeartEventHandler::EndEvent(HeartEventHandler::COMMUNICATION);
        }


        // the AssembleOnElement type methods will determine if a current solution or
        // current guess exists by looking at the size of the replicated vector, so
        // check the size is zero if there isn't a current solution
        assert(    ( currentSolutionOrGuess && mCurrentSolutionOrGuessReplicated.size()>0)
                || ( !currentSolutionOrGuess && mCurrentSolutionOrGuessReplicated.size()==0));


        // the concrete class can override this following method if there is
        // work to be done before assembly
        this->PrepareForAssembleSystem(currentSolutionOrGuess, currentTime);

        // this has to be below PrepareForAssembleSystem as in that
        // method the odes are solved in cardiac problems
        HeartEventHandler::BeginEvent(assemble_event);

        // Zero the matrix/vector if it is to be assembled
        if (assembleVector)
        {
            mpLinearSystem->ZeroRhsVector();
        }
        if (assembleMatrix)
        {
            mpLinearSystem->ZeroLhsMatrix();
        }

        // Get an iterator over the elements of the mesh
        typename AbstractMesh<ELEMENT_DIM, SPACE_DIM>::ElementIterator
            iter = this->mpMesh->GetElementIteratorBegin();

        const size_t STENCIL_SIZE=PROBLEM_DIM*(ELEMENT_DIM+1);
        c_matrix<double, STENCIL_SIZE, STENCIL_SIZE> a_elem;
        c_vector<double, STENCIL_SIZE> b_elem;


        // loop over elements
        while (iter != this->mpMesh->GetElementIteratorEnd())
        {
            Element<ELEMENT_DIM, SPACE_DIM>& element = **iter;

            if (element.GetOwnership() == true)
            {
                AssembleOnElement(element, a_elem, b_elem, assembleVector, assembleMatrix);

                unsigned p_indices[STENCIL_SIZE];
                element.GetStiffnessMatrixGlobalIndices(PROBLEM_DIM, p_indices);

                if (assembleMatrix)
                {
                    mpLinearSystem->AddLhsMultipleValues(p_indices, a_elem);
                }

                if (assembleVector)
                {
                    mpLinearSystem->AddRhsMultipleValues(p_indices, b_elem);
                }
            }

            iter++;
        }

        // add the integrals associated with Neumann boundary conditions to the linear system
        typename AbstractMesh<ELEMENT_DIM, SPACE_DIM>::BoundaryElementIterator
            surf_iter = this->mpMesh->GetBoundaryElementIteratorBegin();


        // Apply any Neumann boundary conditions
        //
        // NB. We assume that if an element has a boundary condition on any unknown there is a boundary condition
        // on unknown 0. This can be so for any problem by adding zero constant conditions where required
        // although this is a bit inefficient. Proper solution involves changing BCC to have a map of arrays
        // boundary conditions rather than an array of maps.
        if (assembleVector)
        {
            this->ApplyNeummanBoundaryConditions();
        }

        if (assembleVector)
        {
            mpLinearSystem->AssembleRhsVector();
        }
        
        if (assembleMatrix)
        {
            mpLinearSystem->AssembleIntermediateLhsMatrix();
        }

        // Apply dirichlet boundary conditions
        this->ApplyDirichletConditions(currentSolutionOrGuess, assembleMatrix);

        this->FinaliseLinearSystem(currentSolutionOrGuess, currentTime, assembleVector, assembleMatrix);

        if (assembleVector)
        {
            mpLinearSystem->AssembleRhsVector();
        }
        if (assembleMatrix)
        {
            mpLinearSystem->AssembleFinalLhsMatrix();
        }

        // overload this method if the assembler has to do anything else
        // required (like setting up a null basis (see BidomainDg0Assembler))
        this->FinaliseAssembleSystem(currentSolutionOrGuess, currentTime);

        HeartEventHandler::EndEvent(assemble_event);
    }



    virtual void PrepareForSolve()
    {
        assert(mpMesh != NULL);

        // NOTE: this line used to be commented out because FlaggedMeshAssembler
        // has it's own FlaggedMeshBcc. (design issue). FlaggedMeshAssembler (and
        // related classes has now been deleted so can bring this back)
        assert(this->mpBoundaryConditions != NULL);

        std::vector<unsigned>& r_nodes_per_processor = mpMesh->rGetNodesPerProcessor();

        // check number of processor agrees with definition in mesh
        if((r_nodes_per_processor.size() != 0) && (r_nodes_per_processor.size() != PetscTools::NumProcs()) )
        {
            EXCEPTION("Number of processors defined in mesh class not equal to number of processors used");
        }

        if(r_nodes_per_processor.size() != 0)
        {
            unsigned num_local_nodes = r_nodes_per_processor[ PetscTools::GetMyRank() ];
            DistributedVector::SetProblemSizePerProcessor(this->mpMesh->GetNumNodes(), num_local_nodes);
        }
        else
        {
            DistributedVector::SetProblemSize(this->mpMesh->GetNumNodes());
        }

        this->mpMesh->SetElementOwnerships(DistributedVector::Begin().Global,
                                           DistributedVector::End().Global);
    }



    LinearSystem** GetLinearSystem()
    {
        return &mpLinearSystem;
    }

    ReplicatableVector& rGetCurrentSolutionOrGuess()
    {
        return mCurrentSolutionOrGuessReplicated;
    }

    virtual double GetCurrentSolutionOrGuessValue(unsigned nodeIndex, unsigned indexOfUnknown)
    {
        return mCurrentSolutionOrGuessReplicated[ PROBLEM_DIM*nodeIndex + indexOfUnknown];
    }

public:
    AbstractStaticAssembler(unsigned numQuadPoints = 2)
        : AbstractAssembler<ELEMENT_DIM,SPACE_DIM,PROBLEM_DIM>()
    {
        // Initialise mesh and bcs to null, so we can check they
        // have been set before attempting to solve
        mpMesh = NULL;

        mpQuadRule = NULL;
        mpSurfaceQuadRule = NULL;
        SetNumberOfQuadraturePointsPerDimension(numQuadPoints);

        mpLinearSystem = NULL;
    }

    void SetNumberOfQuadraturePointsPerDimension(unsigned numQuadPoints)
    {
        delete mpQuadRule;
        mpQuadRule = new GaussianQuadratureRule<ELEMENT_DIM>(numQuadPoints);
        delete mpSurfaceQuadRule;
        mpSurfaceQuadRule = new GaussianQuadratureRule<ELEMENT_DIM-1>(numQuadPoints);
    }


    void SetMesh(AbstractMesh<ELEMENT_DIM,SPACE_DIM>* pMesh)
    {
        mpMesh = pMesh;
    }


    virtual ~AbstractStaticAssembler()
    {
        delete mpQuadRule;
        delete mpSurfaceQuadRule;
        delete mpLinearSystem;
    }
};

#endif //_ABSTRACTSTATICASSEMBLER_HPP_

---