block_mask.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2009 - 2019 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, 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.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_fe_block_mask_h
#define dealii_fe_block_mask_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/memory_consumption.h>
 
#include <algorithm>
#include <iosfwd>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
 
class BlockMask
{
public:
  BlockMask() = default;
 
  BlockMask(const std::vector<bool> &block_mask);
 
  BlockMask(const unsigned int n_blocks, const bool initializer);
 
  unsigned int
  size() const;
 
  bool operator[](const unsigned int block_index) const;
 
  bool
  represents_n_blocks(const unsigned int n) const;
 
  unsigned int
  n_selected_blocks(const unsigned int overall_number_of_blocks =
                      numbers::invalid_unsigned_int) const;
 
  unsigned int
  first_selected_block(const unsigned int overall_number_of_blocks =
                         numbers::invalid_unsigned_int) const;
 
  bool
  represents_the_all_selected_mask() const;
 
  BlockMask
  operator|(const BlockMask &mask) const;
 
  BlockMask operator&(const BlockMask &mask) const;
 
  bool
  operator==(const BlockMask &mask) const;
 
  bool
  operator!=(const BlockMask &mask) const;
 
  std::size_t
  memory_consumption() const;
 
private:
  std::vector<bool> block_mask;
 
  // make the output operator a friend so it can access
  // the block_mask array
  friend std::ostream &
  operator<<(std::ostream &out, const BlockMask &mask);
};
 
 
std::ostream &
operator<<(std::ostream &out, const BlockMask &mask);
 
 
// -------------------- inline functions ---------------------
 
inline BlockMask::BlockMask(const std::vector<bool> &block_mask)
  : block_mask(block_mask)
{}
 
 
inline BlockMask::BlockMask(const unsigned int n_blocks, const bool initializer)
  : block_mask(n_blocks, initializer)
{}
 
 
inline unsigned int
BlockMask::size() const
{
  return block_mask.size();
}
 
 
inline bool BlockMask::operator[](const unsigned int block_index) const
{
  // if the mask represents the all-block mask
  // then always return true
  if (block_mask.size() == 0)
    return true;
  else
    {
      // otherwise check the validity of the index and
      // return whatever is appropriate
      Assert(block_index < block_mask.size(),
             ExcIndexRange(block_index, 0, block_mask.size()));
      return block_mask[block_index];
    }
}
 
 
inline bool
BlockMask::represents_n_blocks(const unsigned int n) const
{
  return ((block_mask.size() == 0) || (block_mask.size() == n));
}
 
 
inline unsigned int
BlockMask::n_selected_blocks(const unsigned int n) const
{
  if ((n != numbers::invalid_unsigned_int) && (size() > 0))
    AssertDimension(n, size());
 
  const unsigned int real_n = (n != numbers::invalid_unsigned_int ? n : size());
  if (block_mask.size() == 0)
    return real_n;
  else
    {
      AssertDimension(real_n, block_mask.size());
      return std::count_if(block_mask.begin(),
                           block_mask.end(),
                           [](const bool selected) { return selected; });
    }
}
 
 
inline unsigned int
BlockMask::first_selected_block(const unsigned int n) const
{
  if ((n != numbers::invalid_unsigned_int) && (size() > 0))
    AssertDimension(n, size());
 
  if (block_mask.size() == 0)
    return 0;
  else
    {
      for (unsigned int c = 0; c < block_mask.size(); ++c)
        if (block_mask[c] == true)
          return c;
 
      Assert(false, ExcMessage("No block is selected at all!"));
      return numbers::invalid_unsigned_int;
    }
}
 
 
 
inline bool
BlockMask::represents_the_all_selected_mask() const
{
  return (block_mask.size() == 0);
}
 
 
 
inline BlockMask
BlockMask::operator|(const BlockMask &mask) const
{
  // if one of the two masks denotes the all-block mask,
  // then return the other one
  if (block_mask.size() == 0)
    return mask;
  else if (mask.block_mask.size() == 0)
    return *this;
  else
    {
      // if both masks have individual entries set, form
      // the combination of the two
      AssertDimension(block_mask.size(), mask.block_mask.size());
      std::vector<bool> new_mask(block_mask.size());
      for (unsigned int i = 0; i < block_mask.size(); ++i)
        new_mask[i] = (block_mask[i] || mask.block_mask[i]);
 
      return new_mask;
    }
}
 
 
inline BlockMask BlockMask::operator&(const BlockMask &mask) const
{
  // if one of the two masks denotes the all-block mask,
  // then return the other one
  if (block_mask.size() == 0)
    return mask;
  else if (mask.block_mask.size() == 0)
    return *this;
  else
    {
      // if both masks have individual entries set, form
      // the combination of the two
      AssertDimension(block_mask.size(), mask.block_mask.size());
      std::vector<bool> new_mask(block_mask.size());
      for (unsigned int i = 0; i < block_mask.size(); ++i)
        new_mask[i] = (block_mask[i] && mask.block_mask[i]);
 
      return new_mask;
    }
}
 
 
inline bool
BlockMask::operator==(const BlockMask &mask) const
{
  return block_mask == mask.block_mask;
}
 
 
inline bool
BlockMask::operator!=(const BlockMask &mask) const
{
  return block_mask != mask.block_mask;
}
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif