map_matrix.h

Go to the documentation of this file.

// LIC// ====================================================================
// LIC// This file forms part of oomph-lib, the object-oriented,
// LIC// multi-physics finite-element library, available
// LIC// at http://www.oomph-lib.org.
// LIC//
// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
// LIC//
// LIC// This library is free software; you can redistribute it and/or
// LIC// modify it under the terms of the GNU Lesser General Public
// LIC// License as published by the Free Software Foundation; either
// LIC// version 2.1 of the License, or (at your option) any later version.
// LIC//
// LIC// This library is distributed in the hope that it will be useful,
// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// LIC// Lesser General Public License for more details.
// LIC//
// LIC// You should have received a copy of the GNU Lesser General Public
// LIC// License along with this library; if not, write to the Free Software
// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// LIC// 02110-1301  USA.
// LIC//
// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
// LIC//
// LIC//====================================================================
#ifndef OOMPH_MAP_MATRIX_HEADER
#define OOMPH_MAP_MATRIX_HEADER
 
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
 
#ifdef OOMPH_HAS_MPI
#include "mpi.h"
#endif
 
#include <map>
 
// oomph-lib headers
#include "Vector.h"
#include "oomph_utilities.h"
 
namespace oomph
{
  //================================================================
  //================================================================
  template<class KEY_TYPE_ROW, class KEY_TYPE_COL, class VALUE_TYPE>
  class MapMatrixMixed
  {
  public:
    MapMatrixMixed(){};
 
    void operator=(const MapMatrixMixed&) = delete;
 
    typedef std::map<KEY_TYPE_COL, VALUE_TYPE> InnerMapMixed;
 
    typedef typename InnerMapMixed::iterator InnerMixedIt;
 
    typedef typename InnerMapMixed::const_iterator ConstInnerMixedIt;
 
    typedef std::map<KEY_TYPE_ROW, std::map<KEY_TYPE_COL, VALUE_TYPE>*>
      OuterMapMixed;
 
    typedef typename OuterMapMixed::iterator OuterMixedIt;
 
    typedef typename OuterMapMixed::const_iterator ConstOuterMixedIt;
 
 
    MapMatrixMixed(
      const MapMatrixMixed<KEY_TYPE_ROW, KEY_TYPE_COL, VALUE_TYPE>& map_mat)
    {
      // Step through the row pointers
      for (ConstOuterMixedIt it = map_mat.Row_pt.begin();
           it != map_mat.Row_pt.end();
           it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (ConstInnerMixedIt it2 = inner_map.begin();
               it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Copy
            if (it2->second != 0)
            {
              // key1, key2, value
              (*this)(it->first, it2->first) = it2->second;
            }
          }
        }
      }
    }
 
 
    void copy_column(const KEY_TYPE_COL& j,
                     std::map<KEY_TYPE_ROW, VALUE_TYPE>& copied_map)
    {
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
          // If the desired column of the inner map is non-zero
          if (inner_map[j] != 0)
          {
            // Set the value of the copied map to be the desired column of the
            // inner map
            copied_map[it->first] = inner_map[j];
          }
        }
      }
    }
 
 
    virtual ~MapMatrixMixed()
    {
      // Step through the pointers to row maps
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // it->second is the stored object
          delete it->second;
        }
      }
    }
 
    void clear()
    {
      // Step through the pointers to row maps
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // it->second is the stored object: a map which can be cleared!
          it->second->clear();
        }
      }
    }
 
 
    VALUE_TYPE& operator()(const KEY_TYPE_ROW& i, const KEY_TYPE_COL& j)
    {
      return *entry_pt(i, j);
    }
 
    VALUE_TYPE get(const KEY_TYPE_ROW& i, const KEY_TYPE_COL& j) const
    {
      if (Row_pt.count(i) > 0)
      {
        // Get the pointer to the row and check the j key
        InnerMapMixed* inner_map_mixed_pt = Row_pt.find(i)->second;
        if (inner_map_mixed_pt->count(j) > 0)
        {
          return inner_map_mixed_pt->find(j)->second;
        }
        else
        {
          return VALUE_TYPE(0);
        }
      }
      else
      {
        // The key does not exist, return VALUE_TYPE(0)
        return VALUE_TYPE(0);
      }
    }
 
 
    void output(std::ostream& outfile)
    {
      // NOTE:
      //------
      // map.first = key
      // map.second = value
 
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (InnerMixedIt it2 = inner_map.begin(); it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Doc
            if (it2->second != 0)
            {
              // Output key1, key2, value
              outfile << it->first << " " << it2->first << " " << it2->second
                      << std::endl;
            }
          }
        }
      }
    }
 
    unsigned long nnz()
    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (InnerMixedIt it2 = inner_map.begin(); it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Increment counter
            if (it2->second != 0)
            {
              count++;
            }
          }
        }
      }
      return count;
    }
 
    unsigned long nnz() const
    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (ConstOuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over entries in the row
          for (ConstInnerMixedIt it2 = inner_map.begin();
               it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Increment counter
            if (it2->second != 0)
            {
              count++;
            }
          }
        }
      }
      return count;
    }
 
 
    unsigned long size()
    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (OuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over all (!) entries in the row (incl. zero ones!)
          for (InnerMixedIt it2 = inner_map.begin(); it2 != inner_map.end();
               it2++)
          {
            count++;
          }
        }
      }
      return count;
    }
 
    unsigned long size() const
    {
      // Initialise counter for # of nonzero entries
      unsigned long count = 0;
 
      // Step through the row pointers
      for (ConstOuterMixedIt it = Row_pt.begin(); it != Row_pt.end(); it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMapMixed inner_map = *(it->second);
 
          // Loop over all (!) entries in the row (incl. zero ones!)
          for (ConstInnerMixedIt it2 = inner_map.begin();
               it2 != inner_map.end();
               it2++)
          {
            count++;
          }
        }
      }
      return count;
    }
 
 
  protected:
    VALUE_TYPE* entry_pt(const KEY_TYPE_ROW& i, const KEY_TYPE_COL& j)
    {
      // There's not a single entry in this row: Entry must be zero.
      if (Row_pt[i] == 0)
      {
        // Create row and entry in row and set the value to zero
        Row_pt[i] = new std::map<KEY_TYPE_COL, VALUE_TYPE>;
        (*Row_pt[i])[j] = VALUE_TYPE(0);
        return &(*Row_pt[i])[j];
      }
      // Simply return pointer to existing entry
      else
      {
        return &(*Row_pt[i])[j];
      }
    }
 
 
    std::map<KEY_TYPE_ROW, std::map<KEY_TYPE_COL, VALUE_TYPE>*> Row_pt;
  };
 
 
 
 
  //================================================================
  //================================================================
  template<class KEY_TYPE, class VALUE_TYPE>
  class MapMatrix : public MapMatrixMixed<KEY_TYPE, KEY_TYPE, VALUE_TYPE>
  {
  public:
    MapMatrix(){};
 
    typedef std::map<KEY_TYPE, VALUE_TYPE> InnerMap;
 
    typedef typename InnerMap::iterator InnerIt;
 
    typedef typename InnerMap::const_iterator ConstInnerIt;
 
    typedef std::map<KEY_TYPE, std::map<KEY_TYPE, VALUE_TYPE>*> OuterMap;
 
    typedef typename OuterMap::iterator OuterIt;
 
    typedef typename OuterMap::const_iterator ConstOuterIt;
 
    MapMatrix(const MapMatrix<KEY_TYPE, VALUE_TYPE>& map_mat)
    {
      // Step through the row pointers
      for (ConstOuterIt it = map_mat.Row_pt.begin(); it != map_mat.Row_pt.end();
           it++)
      {
        // Is the row pointer nonzero, i.e. are there any entries in this row?
        if (it->second != 0)
        {
          // Identify the map that holds the entries in this row:
          InnerMap inner_map = *(it->second);
 
          // Loop over entries in the row
          for (ConstInnerIt it2 = inner_map.begin(); it2 != inner_map.end();
               it2++)
          {
            // If the entry is nonzero: Copy
            if (it2->second != 0)
            {
              (*this)(it->first, it2->first) = it2->second;
            }
          }
        }
      }
    }
 
    void operator=(const MapMatrix&) = delete;
  };
 
} // namespace oomph
 
#endif