some baseproblems extended

extensions/Helpers.h

@@ -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<<"]";

extensions/POperators_FOT.h

@@ -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:

extensions/POperators_SOT.h

@@ -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:

extensions/POperators_ZOT.h

@@ -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