BoundaryMeshAssociation.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  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 General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: BoundaryMeshAssociation.hpp,v 1.11 2008/03/04 00:17:58 delpinux Exp $

#ifndef BOUNDARY_MESH_ASSOCIATION_HPP
#define BOUNDARY_MESH_ASSOCIATION_HPP

#include <map>
#include <ReferenceCounting.hpp>

#include <Problem.hpp>
#include <Boundary.hpp>

#include <BoundarySurfaceMesh.hpp>
#include <BoundaryReferences.hpp>
#include <BoundaryPOVRay.hpp>

#include <BoundaryConditionSet.hpp>
#include <BoundaryMeshAssociation.hpp>

#include <SurfaceMesh.hpp>
#include <SurfaceMeshOfTriangles.hpp>
#include <SurfaceMeshOfQuadrangles.hpp>

#include <MeshExtractor.hpp>

#include <PDESystem.hpp>
#include <VariationalProblem.hpp>

#include <Stringify.hpp>
#include <ErrorHandler.hpp>

class BoundaryMeshAssociation
{
private:
  bool __hasPOVReference;       
  typedef std::map<const Boundary*, ConstReferenceCounting<SurfaceMesh> >
  MapBoundaryToMesh;

  MapBoundaryToMesh __boundaryMesh; 
  template <typename MeshType>
  void __storesBoundariesAndMeshes(const BoundaryConditionSet& bc,
                                   const MeshType& M)
  {
    for (size_t i=0; i<bc.nbBoundaryCondition(); ++i) {
      if (__boundaryMesh.find(bc[i].boundary())
          == __boundaryMesh.end()) {
        switch(bc[i].boundary()->type()) {
        case Boundary::povRay: {
          __boundaryMesh[bc[i].boundary()] = 0;
          __hasPOVReference = true;
          break;
        }
        case Boundary::surfaceMesh: {
          const BoundarySurfaceMesh& b
            = dynamic_cast<const BoundarySurfaceMesh&>(*bc[i].boundary());
          const SurfaceMesh* t = b.surfaceMesh();
          __boundaryMesh[bc[i].boundary()] = t;
          break;
        }
        case Boundary::references: {
          const BoundaryReferences& b
            = dynamic_cast<const BoundaryReferences&>(*bc[i].boundary());
          
          MeshExtractor<typename MeshType::BorderMeshType>
            extractor(M.borderMesh());

          __boundaryMesh[bc[i].boundary()]
            = extractor(b.references());
          break;
        }
        default: {
          throw ErrorHandler(__FILE__,__LINE__,
                             "unknown boundary type",
                             ErrorHandler::unexpected);
        }
        }
      }
    }
  }

  template <typename MeshType>
  void __storesBoundariesAndMeshes(const VariationalBorderOperator& borderOperator,
                                   const MeshType& M)
  {
    if (__boundaryMesh.find(borderOperator.boundary())
        == __boundaryMesh.end()) {
      switch(borderOperator.boundary()->type()) {
      case Boundary::povRay: {
        __boundaryMesh[borderOperator.boundary()] = 0;
        __hasPOVReference = true;
        break;
      }
      case Boundary::surfaceMesh: {
        const BoundarySurfaceMesh& b
          = dynamic_cast<const BoundarySurfaceMesh&>(*borderOperator.boundary());
        const SurfaceMesh* t = b.surfaceMesh();
        __boundaryMesh[borderOperator.boundary()] = t;
        break;
      }
      case Boundary::references: {
        const BoundaryReferences& b
          = dynamic_cast<const BoundaryReferences&>(*borderOperator.boundary());
          
        MeshExtractor<typename MeshType::BorderMeshType>
          extractor(M.borderMesh());

        __boundaryMesh[borderOperator.boundary()]
          = extractor(b.references());
        break;
      }
      default: {
        throw ErrorHandler(__FILE__,__LINE__,
                           "unknown boundary type",
                           ErrorHandler::unexpected);
      }
      }
    }
  }

public:
  typedef MapBoundaryToMesh::const_iterator const_iterator;

  const_iterator begin() const
  {
    return __boundaryMesh.begin();
  } 

  const_iterator end() const
  {
    return __boundaryMesh.end();
  } 

  const bool& hasPOVReferences() const
  {
    return __hasPOVReference;
  }

  void setPOVMeshes(const Domain& omega,
                    ConstReferenceCounting<SurfaceMeshOfTriangles> mesh)
  {
    for (MapBoundaryToMesh::iterator i = __boundaryMesh.begin();
         i != __boundaryMesh.end(); ++i) {
      const Boundary& b = (*(i->first));
      if (b.type() == Boundary::povRay) {
        ASSERT(i->second == 0);
        const BoundaryPOVRay& pov = dynamic_cast<const BoundaryPOVRay&>(b);
        std::set<size_t> references;
        for (size_t n=0; n<pov.numberOfPOVReferences(); ++n) {
          references.insert(omega.reference(pov.povReference(n)));
        }
        MeshExtractor<SurfaceMeshOfTriangles> extractor(mesh);
        __boundaryMesh[i->first] = extractor(references);
      }
    }
  }

  ConstReferenceCounting<SurfaceMesh> operator[](const Boundary& b) const
  {
    MapBoundaryToMesh::const_iterator i = __boundaryMesh.find(&b);
    if (i != __boundaryMesh.end()) {
      return i->second;
    } else {
      const std::string errorMsg
        = "the boundary "+stringify(b)+" was unexpected\n";
      throw ErrorHandler(__FILE__,__LINE__,
                         errorMsg,
                         ErrorHandler::normal);
    }
  }

  template <typename MeshType>
  BoundaryMeshAssociation(const Problem& P,
                          MeshType& M)
    : __hasPOVReference(false)
  {
    switch (P.type()) {
    case Problem::pde: {
      const PDESystem& system = static_cast<const PDESystem&>(P);
      for (size_t i=0; i<system.numberOfUnknown(); ++i) {
        this->__storesBoundariesAndMeshes(P.boundaryConditionSet(i), M);
      }
      break;
    }
    case Problem::variational: {
      const VariationalProblem& V = static_cast<const VariationalProblem&>(P);
      for (size_t i=0; i<V.numberOfUnknown(); ++i) {
        this->__storesBoundariesAndMeshes(P.boundaryConditionSet(i), M);
      }
      for (VariationalProblem::bilinearBorderOperatorConst_iterator i
             = V.beginBilinearBorderOperator();
           i != V.endBilinearBorderOperator(); ++i) {
        this->__storesBoundariesAndMeshes(**i, M);
      }
      for (VariationalProblem::linearBorderOperatorConst_iterator i
             = V.beginLinearBorderOperator();
           i != V.endLinearBorderOperator(); ++i) {
        this->__storesBoundariesAndMeshes(**i, M);
      }
      break;
    }
    }
  }

  ~BoundaryMeshAssociation()
  {
    ;
  }
};

#endif // BOUNDARY_MESH_ASSOCIATION_HPP

---