Liebe Gitlab-Nutzer, lieber Gitlab-Nutzer,
es ist nun möglich sich mittels des ZIH-Logins/LDAP an unserem Dienst anzumelden. Die Konten der externen Nutzer:innen sind über den Reiter "Standard" erreichbar.
Die Administratoren


Dear Gitlab user,
it is now possible to log in to our service using the ZIH login/LDAP. The accounts of external users can be accessed via the "Standard" tab.
The administrators

Commit 08de369a authored by Praetorius, Simon's avatar Praetorius, Simon
Browse files

some baseproblems extended

parent d57f700c
......@@ -145,14 +145,17 @@ namespace Helpers {
template<typename T>
inline std::string toString(const std::vector<T> &vec,
bool brackets = true,
ios_base::fmtflags flag = ios_base::scientific)
std::string separator = ",",
ios_base::fmtflags flag = ios_base::scientific,
size_t precision = 6
)
{
std::stringstream ss;
if (brackets) ss<<"[";
ss.setf(flag);
ss.precision(6);
ss.precision(precision);
for (size_t i = 0; i < vec.size(); ++i) {
if (!(ss<<(i>0?", ":"")<<vec[i]))
if (!(ss<<(i>0?(separator+" "):std::string(""))<<vec[i]))
throw(std::runtime_error("toString() not possible"));
}
if (brackets) ss<<"]";
......
......@@ -51,7 +51,7 @@ void eval(int nPoints,
mtl::dense_vector<double>& result,
double opFactor);
virtual WorldVector<double> f(const int iq) const;
WorldVector<double> f(const int iq) const;
void setFactor(const double fac_) { fac=fac_; }
protected:
......
......@@ -55,7 +55,7 @@ inline void eval(int nPoints,
void weakEval(const std::vector<WorldVector<double> > &grdUhAtQP,
std::vector<WorldVector<double> > &result);
virtual double f(const int iq) const;
double f(const int iq) const;
void setFactor(const double fac_) { fac=fac_; }
protected:
......
......@@ -47,7 +47,7 @@ void eval(int nPoints,
mtl::dense_vector<double>& result,
double opFactor);
virtual double f(const int iq) const;
double f(const int iq) const;
void setFactor(const double fac_) { fac=fac_; }
protected:
......@@ -56,6 +56,141 @@ mtl::dense_vector<double> phase;
double fac;
};
// struct DefaultOperation
// {
// int degree;
// int getDegree() const { return degree; }
//
// template<typename V1>
// DefaultQuartOperation(V1* v1)
// : degree(v1->getFeSpace()->getBasisFcts()->getDegree() ) {}
//
// DefaultQuartOperation(int d1)
// : degree(d1) {}
//
// template<typename T>
// double operator()(const T& v) const { return v; }
// };
//
// struct DefaultBinaryOperation
// {
// int degree;
// int getDegree() const { return degree; }
//
// template<typename V1, typename V2>
// DefaultQuartOperation(V1* v1, V2* v2)
// : degree(v1->getFeSpace()->getBasisFcts()->getDegree() +
// v2->getFeSpace()->getBasisFcts()->getDegree() ) {}
//
// DefaultQuartOperation(int d1, int d2)
// : degree(d1 + d2) {}
//
// template<typename T1, typename T2>
// double operator()(const T1& v1, const T2& v2) const { return v1 * v2; }
// };
//
// struct DefaultTertiaryOperation
// {
// int degree;
// int getDegree() const { return degree; }
//
// template<typename V1, typename V2, typename V3>
// DefaultQuartOperation(V1* v1, V2* v2, V3* v3)
// : degree(v1->getFeSpace()->getBasisFcts()->getDegree() +
// v2->getFeSpace()->getBasisFcts()->getDegree() +
// v3->getFeSpace()->getBasisFcts()->getDegree() ) {}
//
// DefaultQuartOperation(int d1, int d2, int d3)
// : degree(d1 + d2 + d3) {}
//
// template<typename T1, typename T2, typename T3>
// double operator()(const T1& v1, const T2& v2, const T3& v3) const { return v1 * v2 * v3; }
// };
//
// struct DefaultQuartOperation
// {
// int degree;
// int getDegree() const { return degree; }
//
// template<typename V1, typename V2, typename V3, typename V4>
// DefaultQuartOperation(V1* v1, V2* v2, V3* v3, V4* v4)
// : degree(v1->getFeSpace()->getBasisFcts()->getDegree() +
// v2->getFeSpace()->getBasisFcts()->getDegree() +
// v3->getFeSpace()->getBasisFcts()->getDegree() +
// v4->getFeSpace()->getBasisFcts()->getDegree() ) {}
//
// DefaultQuartOperation(int d1, int d2, int d3, int d4)
// : degree(d1 + d2 + d3 + d4) {}
//
// template<typename T1, typename T2, typename T3, typename T4>
// double operator()(const T1& v1, const T2& v2, const T3& v3, const T4& v4) const { return v1 * v2 * v3 * v4; }
// };
//
// /// < factor*op(vec)*u , psi >
// template<typename Op = DefaultOperation>
// class VecAtQP_Op_ZOT : public ZeroOrderTerm
// {
// public:
// VecAtQP_Op_ZOT(DOFVectorBase<double>* vecDV, double fac=1.0);
//
// /// Implementation of \ref OperatorTerm::initElement().
// void initElement(const ElInfo* elInfo,
// SubAssembler* subAssembler,
// Quadrature *quad=NULL);
// void initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
// SubAssembler* subAssembler,
// Quadrature *quad=NULL);
//
// void getC(const ElInfo *, int nPoints, ElementVector &C);
//
// void eval(int nPoints,
// const mtl::dense_vector<double>&,
// const mtl::dense_vector<WorldVector<double> >& grdUhAtQP,
// const mtl::dense_vector<WorldMatrix<double> >& D2UhAtQP,
// mtl::dense_vector<double>& result,
// double opFactor);
//
// protected:
// Op op;
// DOFVectorBase<double> *vecDV;
// mtl::dense_vector<double> vec;
// double fac;
// };
// _____________________________________________________________________________
/// < factor*op2(vec1,vec2)*u , psi >
// template<typename BinaryOp = DefaultBinaryOperation>
// class Vec2AtQP_Op_ZOT : public ZeroOrderTerm
// {
// public:
// Vec2AtQP_Op_ZOT(DOFVectorBase<double>* vec1DV, DOFVectorBase<double>* vec2DV, double fac=1.0);
//
// /// Implementation of \ref OperatorTerm::initElement().
// void initElement(const ElInfo* elInfo,
// SubAssembler* subAssembler,
// Quadrature *quad=NULL);
// void initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
// SubAssembler* subAssembler,
// Quadrature *quad=NULL);
//
// void getC(const ElInfo *, int nPoints, ElementVector &C);
//
// void eval(int nPoints,
// const mtl::dense_vector<double>&,
// const mtl::dense_vector<WorldVector<double> >& grdUhAtQP,
// const mtl::dense_vector<WorldMatrix<double> >& D2UhAtQP,
// mtl::dense_vector<double>& result,
// double opFactor);
//
// protected:
// binaryOp op2;
// DOFVectorBase<double> *vec1DV, *vec2DV;
// mtl::dense_vector<double> vec, vec2;
// double fac;
// };
/* -------------------------------------------------------------- */
/// < factor*(1-phase)*u , psi > or < factor*v[i]*(1-phase)*u , psi > where v in R^n
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment