blockoperator.hpp

Go to the documentation of this file.

// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
// reserved. See file COPYRIGHT for details.
//
// This file is part of the MFEM library. For more information and source code
// availability see http://mfem.org.
//
// MFEM 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) version 2.1 dated February 1999.

#ifndef MFEM_BLOCKOPERATOR
#define MFEM_BLOCKOPERATOR

#include "../config/config.hpp"
#include "../general/array.hpp"
#include "operator.hpp"
#include "blockvector.hpp"

namespace mfem
{


class BlockOperator : public Operator
{
public:

   BlockOperator(const Array<int> & offsets);

   BlockOperator(const Array<int> & row_offsets, const Array<int> & col_offsets);


   void SetDiagonalBlock(int iblock, Operator *op);

   void SetBlock(int iRow, int iCol, Operator *op);

   int NumRowBlocks() const { return nRowBlocks; }
   int NumColBlocks() const { return nColBlocks; }

   int IsZeroBlock(int i, int j) const { return (op(i,j)==NULL) ? 1 : 0; }
   Operator & GetBlock(int i, int j)
   { MFEM_VERIFY(op(i,j), ""); return *op(i,j); }

   Array<int> & RowOffsets() { return row_offsets; }
   Array<int> & ColOffsets() { return col_offsets; }

   virtual void Mult (const Vector & x, Vector & y) const;

   virtual void MultTranspose (const Vector & x, Vector & y) const;

   ~BlockOperator();

   int owns_blocks;

private:
   int nRowBlocks;
   int nColBlocks;
   Array<int> row_offsets;
   Array<int> col_offsets;
   Array2D<Operator *> op;

   mutable BlockVector xblock;
   mutable BlockVector yblock;
   mutable Vector tmp;
};


class BlockDiagonalPreconditioner : public Solver
{
public:
   BlockDiagonalPreconditioner(const Array<int> & offsets);

   void SetDiagonalBlock(int iblock, Operator *op);
   virtual void SetOperator(const Operator &op) { }

   int NumBlocks() const { return nBlocks; }

   Operator & GetDiagonalBlock(int iblock)
   { MFEM_VERIFY(op[iblock], ""); return *op[iblock]; }

   Array<int> & Offsets() { return offsets; }

   virtual void Mult (const Vector & x, Vector & y) const;

   virtual void MultTranspose (const Vector & x, Vector & y) const;

   ~BlockDiagonalPreconditioner();

   int owns_blocks;

private:
   int nBlocks;
   Array<int> offsets;
   Array<Operator *> op;
   mutable BlockVector xblock;
   mutable BlockVector yblock;
};

}

#endif /* MFEM_BLOCKOPERATOR */