fluxes.hh

Go to the documentation of this file.

 
#ifndef fluxes_estimator_hh
#define fluxes_estimator_hh
 
#include "formula/elementFormula.hh"
#include "formula/elementFormulaContainer.hh"
 
 
#include "operator/lapack.hh"
#include "basics/exceptions.hh"
#include "moments.hh"
 
 
namespace concepts {
 
// **************************************************** FluxesError **
 
class FluxesError: public ExceptionBase {
public:
  FluxesError(const std::string& errorMessage) throw () {
    errorMessage_ = errorMessage;
  }
 
  virtual ~FluxesError() throw () {
  }
  ;
protected:
  virtual std::ostream& info(std::ostream& os) const throw () {
    return os << concepts::typeOf(*this)<< "[" << errorMessage_ << " ]";
 
  }
private:
  std::string errorMessage_;
};
 
}
 
namespace hp2D {
 
 
 
class Fluxes: public concepts::ElementFormula<Real, Real> {
 
public:
  typedef concepts::ElementAndFacette<hp2D::Element<Real> > UnderlyingElement;
 
  Fluxes(hp2D::TraceSpace& spc,const EquilibratedMomentsAO<Real>& moments);
 
  void compress(Real eps = EPS);
 
  Real operator()(const concepts::ElementWithCell<Real>& elm,
      const concepts::Real p, const Real t = 0.0) const;
 
 
  Real operator()(const concepts::ElementWithCell<Real>& elm,
      const concepts::Real2d& p, const Real t = 0.0) const {
    concepts::conceptsException(concepts::MissingFeature("Not implemented"));
    return 0;
  }
  Real operator()(const concepts::ElementWithCell<Real>& elm,
      const concepts::Real3d& p, const Real t = 0.0) const {
    concepts::conceptsException(concepts::MissingFeature("Not implemented"));
    return 0;
  }
 
  Real getWeight(uint E, uint K) const {
    concepts::HashMap<concepts::Sequence<UnderlyingElement> >::const_iterator iter = uelm_.find(E);
    conceptsAssert(iter != uelm_.end(), concepts::Assertion());
    if(iter->second[0].elm->support().key().key()==K)
      return 1.0;
    else
      return -1.0;
  }
 
  const concepts::Vector<Real>& getCoeffs(uint E) const {
    concepts::HashMap<concepts::Vector<Real> >::const_iterator iter = coeffs_.find(E);
    conceptsAssert(iter != coeffs_.end(), concepts::Assertion());
    return iter->second;
  }
 
 
 
  virtual ~Fluxes() {
    //delete allocated cholesky descompositions
    for(concepts::HashMap<concepts::LapackChol*>::iterator iter =  Minv_.begin(); iter != Minv_.end(); ++iter){
      delete iter->second;
      iter->second = 0;
    }
  }
 
  virtual Fluxes* clone() const {
    return new hp2D::Fluxes(*this);
  }
 
  const concepts::LapackChol*  getInverseMass(uint m){
    concepts::HashMap<concepts::LapackChol*>::const_iterator iter= Minv_.find(m);
    conceptsAssert(iter != Minv_.end(),concepts::Assertion());
    return iter->second;
  }
 
 
protected:
 
  std::ostream& info(std::ostream& os) const {
    os << concepts::typeOf(*this) << "[ #edges = "<<coeffs_.size()<<std::endl;
    concepts::HashMap<concepts::Vector<Real> >::const_iterator iter = coeffs_.begin();
    for( ;iter != coeffs_.end(); ++iter) {
      os<< "Edge("<<iter->first<<") --> (";
      uint i=0;
      for( ; i< iter->second.size()-1;++i){
        os<< iter->second[i] << " , ";
      }
      os << iter->second[i] <<")"<<std::endl;
    }
    return os<<"]"<<std::endl;
  }
 
private:
 
  uint currElmKey_;
 
  //atm K -> E -> coeffs
  //atm computed to times for have sth
  concepts::HashMap<concepts::Vector<Real> >  coeffs_;
 
  concepts::HashMap<concepts::LapackChol*> Minv_;
 
 
  concepts::HashMap<concepts::Sequence<UnderlyingElement> > uelm_;
 
  const hp2D::TraceSpace& tspc_;
};
 
 
//TODO Documentation
 
class LocalFluxes: public concepts::ElementFormula<Real, Real> {
 
public:
  typedef concepts::ElementAndFacette<hp2D::Element<Real> > UnderlyingElement;
 
  //@pre the local tracespace just has edges with keys given in the globalflux
 
  LocalFluxes(hp2D::TraceSpace& locTspc,uint K, const Fluxes& globalflux);
 
  Real operator()(const concepts::ElementWithCell<Real>& elm,
      const concepts::Real p, const Real t = 0.0) const;
 
 
  Real operator()(const concepts::ElementWithCell<Real>& elm,
      const concepts::Real2d& p, const Real t = 0.0) const {
      concepts::conceptsException(concepts::MissingFeature("Not implemented"));
      return 0;
  }
 
  Real operator()(const concepts::ElementWithCell<Real>& elm,
    const concepts::Real3d& p, const Real t = 0.0) const {
    concepts::conceptsException(concepts::MissingFeature("Not implemented"));
    return 0;
  }
 
  virtual ~LocalFluxes() {
    //TODO IMPLEMENT
  }
 
  virtual LocalFluxes* clone() const {
      return new hp2D::LocalFluxes(*this);
  }
 
  protected:
 
    std::ostream& info(std::ostream& os) const {
      os << concepts::typeOf(*this) << "[ #edges = "<<coeffs_.size()<<std::endl;
      concepts::HashMap<concepts::Vector<Real> >::const_iterator iter = coeffs_.begin();
      for( ;iter != coeffs_.end(); ++iter) {
        os<< "Edge("<<iter->first<<") --> (";
        uint i=0;
        for( ; i< iter->second.size()-1;++i){
          os<< iter->second[i] << " , ";
        }
        os << iter->second[i] <<")"<<std::endl;
      }
      return os<<"]"<<std::endl;
    }
 
  private:
 
    uint currElmKey_;
 
    //atm K -> E -> coeffs
    //atm computed to times for have sth
    concepts::HashMap<concepts::Vector<Real> >  coeffs_;
 
    const hp2D::TraceSpace& locTspc_;
 
    const uint K_;
 
    const hp2D::Fluxes& globFlux_;
};
 
 
}
 
#endif //fluxes_hh