spacePreBuilder.hh

Go to the documentation of this file.

 
#ifndef hpSpacePreBuilder_hh
#define hpSpacePreBuilder_hh
 
#include "basics/debug.hh"
#include "basics/exceptions.hh"
#include "basics/outputOperator.hh"
#include "geometry/boundaryConditions.hh"
#include "geometry/cellConditions.hh"
#include "geometry/mesh.hh"
#include "geometry/connectorSet.hh"
#include "spaceSet.hh"
 
#define SubSpaceHelper_D 0
 
namespace concepts {
 
  // forward declarations
  template<class F, class G>
  class BuildTColumnsBase;
 
  // *********************************************************** NotValidDof **
 
  class NotValidDof : public ExceptionBase {};
 
  // ******************************************************* SpacePreBuilder **
 
  class SpacePreBuilder : public virtual OutputOperator {
  public:
    SpacePreBuilder() {}
    virtual ~SpacePreBuilder() {}
 
    virtual concepts::Mesh& mesh() const = 0;
    virtual void rebuildMesh() = 0;
    virtual void rebuildDof() = 0;
    virtual concepts::IndexRange&
      setIndex(uint& firstIdx, uint noIdx, uint dim,
         const concepts::Connector& cntr, uint i = 0,
         uint spcNo = 0) throw(NotValidDof) = 0;
    virtual concepts::Set<concepts::IndexRange> indices
      (uint dim, const concepts::Connector& cntr, uint spcNo = 0) const 
      throw(concepts::MissingFeature) = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  // *********************************************************** SpaceHelper **
 
  template<class F, class G>
  class SpaceHelper : public virtual OutputOperator {
//     friend class BuildTColumnsBase<F,G>;
  public:
    SpaceHelper(G& prebuild, const BoundaryConditions* bc = 0,
    const CellConditions* cc = 0) : 
      prebuild_(&prebuild), 
      bc_(bc ? new const BoundaryConditions(*bc) : nullptr), 
      cc_(cc ? new const CellConditions    (*cc) : nullptr) {}
    virtual ~SpaceHelper() {}
    const BoundaryConditions* bc() const { return bc_.get(); }
    const CellConditions* cc() const { return cc_.get(); }
    void set_bc(const BoundaryConditions* bc) { 
      return bc_.reset(bc ? new BoundaryConditions(*bc) : 0);
    }
    G& prebuild() { return *prebuild_; }
    virtual void reset() = 0;
    virtual uint& idx() = 0;
    virtual const uint& idx() const = 0;
    virtual uint spcNo() const { return 0; }
    bool passive(const concepts::Connector& cntr) const {
      return passive_.exist(&cntr);
    }
    void setPassive(const concepts::Connector& cntr) {
      passive_.insert(&cntr);
    }
    const concepts::Set<const concepts::Connector*> passive() const {
      return passive_;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    G* prebuild_;
    std::unique_ptr<const BoundaryConditions> bc_;
    std::unique_ptr<const CellConditions> cc_;
    concepts::Set<const concepts::Connector*> passive_;
  };
 
  template<class F, class G>
  std::ostream& SpaceHelper<F,G>::info(std::ostream& os) const {
    os << concepts::typeOf(*this)<<"(";
    if (bc_.get()) {
      os << *bc_; if (cc_.get()) os << ", ";
    }
    if (cc_.get()) os << *cc_;
    
    return os << ')';
  }
 
  // ******************************************************** SubspaceHelper **
 
  template<class F, class G>
  class SubspaceHelper : public SpaceHelper<F,G> {
  public:
    SubspaceHelper(G& prebuild, uint spcNo, const BoundaryConditions* bc = 0,
                   const CellConditions* cc = 0, uint* const offset = 0,
                   uint* const idx = 0)
      : SpaceHelper<F,G>(prebuild, bc, cc), spcNo_(spcNo), offset_(offset),
        ownIndex_(idx == 0), idx_(ownIndex_ ? new uint(this->offset()) : idx) {
      DEBUGL(SubSpaceHelper_D, *this);
    }
    virtual ~SubspaceHelper() {
      if (ownIndex_) delete idx_;
      DEBUGL(SubSpaceHelper_D, "done");
    }
    virtual void reset() { *idx_ = offset(); }
    virtual uint& idx() { 
      DEBUGL(SubSpaceHelper_D, "idx = " << *idx_); 
      return *idx_; }
    virtual const uint& idx() const { 
      DEBUGL(SubSpaceHelper_D, "idx = " << *idx_); 
      return *idx_;
    }
    bool ownIndex() const { return ownIndex_; }
    virtual uint spcNo() const { return spcNo_; }
    uint offset() const { return offset_ ? *offset_ : 0; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    uint spcNo_;
    uint* const offset_;
    bool ownIndex_;
    uint* const idx_;
 
  };
 
  template<class F, class G>
  std::ostream& SubspaceHelper<F,G>::info(std::ostream& os) const {
    os << concepts::typeOf(*this)<<"(";
    if (this->bc()) os << *this->bc() << ", ";
    if (this->cc()) os << *this->cc() << ", ";
    if (offset_ == 0) os << "(own)"; else os << "(given)";
    os << " offset = " << offset() << ", ";
    if (ownIndex_) os << "(own)"; else os << "(given)";
    return os << " idx = " << idx() << ")";
  }
 
  // ***************************************************** BuildTColumnsBase **
 
  template<class F, class G>
  class BuildTColumnsBase : public virtual OutputOperator {
  public:
    BuildTColumnsBase() : spc_(0) {}
    BuildTColumnsBase(SpaceHelper<F,G>& spc) : spc_(&spc) {}
    virtual ~BuildTColumnsBase() {}
 
    inline SpaceHelper<F,G>& spc() const;
    inline G& prebuild() const;
 
    virtual BuildTColumnsBase<F,G>* clone(SpaceHelper<F,G>* spc = 0) const = 0;
  protected:
    SpaceHelper<F,G>* spc_;
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  template<class F, class G>
  SpaceHelper<F,G>& BuildTColumnsBase<F,G>::spc() const { 
    conceptsAssert(spc_, Assertion());
    return *spc_;
  }
 
  template<class F, class G>
  G& BuildTColumnsBase<F,G>::prebuild() const { 
    conceptsAssert(spc_, Assertion());
    return spc_->prebuild();
  }
 
  template<class F, class G>
  std::ostream& BuildTColumnsBase<F,G>::info(std::ostream& os) const {
    return os << concepts::typeOf(*this)<<"(" << *spc_ << ")";
  }
 
}
 
#endif // hpSpacePreBuilder_hh