compol_interface_status.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program 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.
 */
 
#ifndef __H__UG__compol_interface_status__
#define __H__UG__compol_interface_status__
 
#include <map>
#include <vector>
#include "common/assert.h"
#include "../distributed_grid.h"
#include "pcl/pcl_communication_structs.h"
 
namespace ug
{
 
 
template <class TLayout>
class ComPol_InterfaceStatus : public pcl::ICommunicationPolicy<TLayout>
{
  public:
    typedef TLayout               Layout;
    typedef typename Layout::Type       GeomObj;
    typedef typename Layout::Element      Element;
    typedef typename Layout::Interface      Interface;
    typedef typename Interface::const_iterator  InterfaceIter;
 
  public:
    ComPol_InterfaceStatus(uint status = INT_NONE) :
      m_pLayout(NULL),
      m_distGridMgr(NULL),
      m_status(status),
      m_curLevel(0) {}
 
    ComPol_InterfaceStatus(DistributedGridManager* distGridMgr,
                uint status = INT_NONE) :
      m_pLayout(NULL),
      m_distGridMgr(distGridMgr),
      m_status(status),
      m_curLevel(0) {}
 
    void set_status(uint status)  {m_status = status;}
    uint get_status()       {return m_status;}
 
    void set_distributed_grid_manager(DistributedGridManager* distGridMgr)
    {m_distGridMgr = distGridMgr;}
 
 
 
    const std::vector<bool>& get_result_vec(int procRank, int level = 0)
    {
      UG_ASSERT(m_pLayout, "communication has to be performed"
                " before results are checked.");
 
      UG_ASSERT(m_pLayout->interface_exists(procRank, level),
          "interface to proc " << procRank << " on level "
          << level << " does not exist.");
 
      if(level >= m_vecMaps.size())
        m_vecMaps.resize(level + 1);
 
      std::vector<bool>& result = m_vecMaps[level][procRank];
 
      UG_ASSERT(result.size() == m_pLayout->interface(procRank, level).size(),
            "result size and interface size do not match."
            " perform communication directly before querying the results.");
 
      return result;
    }
 
    const std::map<int, std::vector<bool> >& get_result_map(int level = 0)
    {
      UG_ASSERT(m_pLayout, "communication has to be performed"
                " before results are checked.");
 
      if(level >= (int)m_vecMaps.size())
        m_vecMaps.resize(level + 1);
 
      return m_vecMaps[level];
    }
 
  //  COMMUNICATION STUFF
    virtual int
    get_required_buffer_size(const Interface& interface)
    {
      return interface.size() * sizeof(char);
    }
 
    virtual bool
    begin_layout_extraction(const Layout* pLayout)
    {
    //  clear and prepare the maps and set the layout
      m_pLayout = pLayout;
 
      m_vecMaps.clear();
      m_vecMaps.resize(m_pLayout->num_levels());
 
      return true;
    }
 
    virtual bool
    collect(ug::BinaryBuffer& buff, const Interface& interface)
    {
    //  iterate over all elements in the interface and write
    //  whether they contain the status or not.
      UG_ASSERT(m_distGridMgr, "Please set the distributed grid manager"
                  " before performing communication.");
 
      for(InterfaceIter iter = interface.begin();
        iter != interface.end(); ++iter)
      {
        Element elem = interface.get_element(iter);
        char val = (char)m_distGridMgr->contains_status(elem, m_status);
        buff.write(&val, sizeof(char));
      }
 
      return true;
    }
 
    virtual void begin_level_extraction(int level)
    {
      UG_ASSERT(level < (int)m_vecMaps.size(), "Internal pcl error.");
      m_curLevel = level;
    }
 
    virtual bool
    extract(ug::BinaryBuffer& buff, const Interface& interface)
    {
    //  read the info from the buff and push bools to the
    //  vector associated with the interface.
 
      std::vector<bool>&
        vec = m_vecMaps[m_curLevel][interface.get_target_proc()];
      vec.clear();
      vec.reserve(interface.size());
 
      for(InterfaceIter iter = interface.begin();
        iter != interface.end(); ++iter)
      {
        Element elem = interface.get_element(iter);
        char val;
        buff.read(&val, sizeof(char));
 
        vec.push_back(((bool)val) ||
                m_distGridMgr->contains_status(elem, m_status));
      }
 
      return true;
    }
 
  private:
    typedef std::map<int, std::vector<bool> > VecMap;
 
    std::vector<VecMap>   m_vecMaps;
    const TLayout*      m_pLayout;
    DistributedGridManager* m_distGridMgr;
    uint          m_status;
    int           m_curLevel;
};
 
}// end of namespace
 
#endif