Skip to content

GitLab

Commit a81287a5 authored by Praetorius, Simon's avatar Praetorius, Simon
Browse files

a lot of changes

parent 4246111b
Hide whitespace changes
Inline Side-by-side
extensions/POperators.cc
View file @ a81287a5
......@@ -827,6 +827,86 @@ void WorldVecPhase_FOT::eval(int nPoints,
}
};
/* ----------------------------------------------------------- */
VecAndWorldVec_FOT::VecAndWorldVec_FOT(DOFVector<double>* vec0_,
WorldVector<DOFVector<double>*> vecs_,
AbstractFunction<double, double>* fct_, double fac_)
: FirstOrderTerm(2), vDV(vec0_), fct(fct_), fac(fac_)
{
numVecs = vecs_.size();
TEST_EXIT(numVecs == 2 || numVecs == 3)
("Only Dim=2 or Dim=3 possible\n");
for (int i = 0; i < numVecs; i++) {
TEST_EXIT(vecs_[i])("One vector is NULL!\n");
auxFeSpaces.insert(vecs_[i]->getFeSpace());
}
vec0DV = vecs_[0];
vec1DV = vecs_[1];
if (numVecs >= 3)
vec2DV = vecs_[2];
};
void VecAndWorldVec_FOT::initElement(const ElInfo* elInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vDV, elInfo, subAssembler, quad, v);
getVectorAtQPs(vec0DV, elInfo, subAssembler, quad, vec0);
getVectorAtQPs(vec1DV, elInfo, subAssembler, quad, vec1);
if (numVecs >= 3)
getVectorAtQPs(vec2DV, elInfo, subAssembler, quad, vec2);
};
void VecAndWorldVec_FOT::initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vDV, smallElInfo, largeElInfo, subAssembler, quad, v);
getVectorAtQPs(vec0DV, smallElInfo, largeElInfo, subAssembler, quad, vec0);
getVectorAtQPs(vec1DV, smallElInfo, largeElInfo, subAssembler, quad, vec1);
if (numVecs >= 3)
getVectorAtQPs(vec2DV, smallElInfo, largeElInfo, subAssembler, quad, vec2);
};
void VecAndWorldVec_FOT::getLb(const ElInfo *elInfo,
vector<mtl::dense_vector<double> >& result) const
{
const DimVec<WorldVector<double> > &Lambda = elInfo->getGrdLambda();
const int nPoints = static_cast<int>(result.size());
for (int iq = 0; iq < nPoints; iq++) {
double f = (*fct)(v[iq]);
WorldVector<double> vec;
vec[0] = vec0[iq];
vec[1] = vec1[iq];
if (numVecs >= 3)
vec[2] = vec2[iq];
lb(Lambda, f*vec, result[iq], fac);
}
};
void VecAndWorldVec_FOT::eval(int nPoints,
const mtl::dense_vector<double>& uhAtQP,
const mtl::dense_vector<WorldVector<double> >& grdUhAtQP,
const mtl::dense_vector<WorldMatrix<double> >& D2UhAtQP,
mtl::dense_vector<double>& result,
double opFactor)
{
double factor = fac * opFactor;
for (int iq = 0; iq < nPoints; iq++) {
double resultQP = 0.0;
resultQP += grdUhAtQP[iq][0] * vec0[iq];
resultQP += grdUhAtQP[iq][1] * vec1[iq];
if (numVecs >= 3)
resultQP += grdUhAtQP[iq][2] * vec2[iq];
result[iq] += factor * resultQP * (*fct)(v[iq]);
}
};
/* ----------------------------------------------------------- */
// vec1*vec2*d/dxi(...)
......@@ -872,6 +952,164 @@ void VecAndPartialDerivative_FOT::eval(int nPoints,
result[iq] += opFactor * vec1[iq] * grdUhAtQP[iq][component] * fac;
};
/* ----------------------------------------------------------- */
// vec1*vec2*d/dxi(...)
VecAndPartialDerivativeIJ_FOT::VecAndPartialDerivativeIJ_FOT(DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int i_,
int j_,
double fac_)
: FirstOrderTerm(4), vec1DV(dv1), vec2DV(dv2), fct(NULL), fac(fac_), xi(i_), xj(j_)
{
auxFeSpaces.insert(vec1DV->getFeSpace());
auxFeSpaces.insert(vec2DV->getFeSpace());
setB(xi);
}
VecAndPartialDerivativeIJ_FOT::VecAndPartialDerivativeIJ_FOT(DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int i_,
int j_,
BinaryAbstractFunction<double, double, double>* fct_, // = f(v1, d_j(v2))
double fac_)
: FirstOrderTerm(4), vec1DV(dv1), vec2DV(dv2), fct(fct_), fac(fac_), xi(i_), xj(j_)
{
auxFeSpaces.insert(vec1DV->getFeSpace());
auxFeSpaces.insert(vec2DV->getFeSpace());
setB(xi);
}
void VecAndPartialDerivativeIJ_FOT::initElement(const ElInfo* elInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vec1DV, elInfo, subAssembler, quad, vec1);
getGradientsAtQPs(vec2DV, elInfo, subAssembler, quad, grad);
}
void VecAndPartialDerivativeIJ_FOT::initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vec1DV, smallElInfo, largeElInfo, subAssembler, quad, vec1);
getGradientsAtQPs(vec1DV, smallElInfo, largeElInfo, subAssembler, quad, grad);
}
void VecAndPartialDerivativeIJ_FOT::getLb(const ElInfo *elInfo,
vector<mtl::dense_vector<double> >& result) const
{
const DimVec<WorldVector<double> > &Lambda = elInfo->getGrdLambda();
const int nPoints = static_cast<int>(result.size());
if (fct == NULL) {
for(int iq = 0; iq < nPoints; iq++) {
lb_one(Lambda, result[iq], vec1[iq] * grad[iq][xj] * fac);
}
} else {
for(int iq = 0; iq < nPoints; iq++) {
lb_one(Lambda, result[iq], (*fct)(vec1[iq], grad[iq][xj]) * fac);
}
}
}
void VecAndPartialDerivativeIJ_FOT::eval(int nPoints,
const mtl::dense_vector<double>& uhAtQP,
const mtl::dense_vector<WorldVector<double> >& grdUhAtQP,
const mtl::dense_vector<WorldMatrix<double> >& D2UhAtQP,
mtl::dense_vector<double>& result,
double opFactor)
{
if (fct == NULL) {
for(int iq = 0; iq < nPoints; iq++)
result[iq] += opFactor * vec1[iq] * grad[iq][xj] * grdUhAtQP[iq][xi] * fac;
} else {
for(int iq = 0; iq < nPoints; iq++)
result[iq] += opFactor * (*fct)(vec1[iq], grad[iq][xj]) * grdUhAtQP[iq][xi] * fac;
}
}
/* ----------------------------------------------------------- */
// vec1*vec2*d/dxi(...)
Vec2AndPartialDerivative_FOT::Vec2AndPartialDerivative_FOT(
DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int component_,
double fac_)
: FirstOrderTerm(3), vec1DV(dv1), vec2DV(dv2), fct(NULL), fac(fac_), component(component_)
{
auxFeSpaces.insert(vec1DV->getFeSpace());
auxFeSpaces.insert(vec2DV->getFeSpace());
setB(component);
}
Vec2AndPartialDerivative_FOT::Vec2AndPartialDerivative_FOT(
DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int component_,
BinaryAbstractFunction<double, double, double>* fct_, // = f(v1, v2)
double fac_)
: FirstOrderTerm(3), vec1DV(dv1), vec2DV(dv2), fct(fct_), fac(fac_), component(component_)
{
auxFeSpaces.insert(vec1DV->getFeSpace());
auxFeSpaces.insert(vec2DV->getFeSpace());
setB(component);
}
void Vec2AndPartialDerivative_FOT::initElement(const ElInfo* elInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vec1DV, elInfo, subAssembler, quad, vec1);
getVectorAtQPs(vec2DV, elInfo, subAssembler, quad, vec2);
}
void Vec2AndPartialDerivative_FOT::initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vec1DV, smallElInfo, largeElInfo, subAssembler, quad, vec1);
getVectorAtQPs(vec2DV, smallElInfo, largeElInfo, subAssembler, quad, vec2);
}
void Vec2AndPartialDerivative_FOT::getLb(const ElInfo *elInfo,
vector<mtl::dense_vector<double> >& result) const
{
const DimVec<WorldVector<double> > &Lambda = elInfo->getGrdLambda();
const int nPoints = static_cast<int>(result.size());
if (fct == NULL) {
for(int iq = 0; iq < nPoints; iq++)
lb_one(Lambda, result[iq], vec1[iq] * vec2[iq] * fac);
} else {
for(int iq = 0; iq < nPoints; iq++)
lb_one(Lambda, result[iq], (*fct)(vec1[iq], vec2[iq]) * fac);
}
};
void Vec2AndPartialDerivative_FOT::eval(int nPoints,
const mtl::dense_vector<double>& uhAtQP,
const mtl::dense_vector<WorldVector<double> >& grdUhAtQP,
const mtl::dense_vector<WorldMatrix<double> >& D2UhAtQP,
mtl::dense_vector<double>& result,
double opFactor)
{
if (fct == NULL) {
for(int iq = 0; iq < nPoints; iq++)
result[iq] += opFactor * vec1[iq] * vec2[iq] * grdUhAtQP[iq][component] * fac;
} else {
for(int iq = 0; iq < nPoints; iq++)
result[iq] += opFactor * (*fct)(vec1[iq], vec2[iq]) * grdUhAtQP[iq][component] * fac;
}
};
/* ----------------------------------------------------------- */
// vec1*vec2*d/dxi(...)
......@@ -1161,6 +1399,27 @@ VecAndPartialDerivative_ZOT::VecAndPartialDerivative_ZOT(DOFVectorBase<double> *
vecDV(vecDV_),
gradDV(gradDV_),
component(component_),
fct(NULL),
fac(fac_)
{
TEST_EXIT(vecDV_)("No value vector!\n");
TEST_EXIT(gradDV_)("No gradient vector!\n");
auxFeSpaces.insert(vecDV_->getFeSpace());
auxFeSpaces.insert(gradDV_->getFeSpace());
}
VecAndPartialDerivative_ZOT::VecAndPartialDerivative_ZOT(DOFVectorBase<double> *vecDV_,
DOFVectorBase<double> *gradDV_,
int component_,
AbstractFunction<double, double>* fct_,
double fac_)
: ZeroOrderTerm(2),
vecDV(vecDV_),
gradDV(gradDV_),
component(component_),
fct(fct_),
fac(fac_)
{
TEST_EXIT(vecDV_)("No value vector!\n");
......@@ -1192,8 +1451,14 @@ void VecAndPartialDerivative_ZOT::initElement(const ElInfo* largeElInfo,
void VecAndPartialDerivative_ZOT::getC(const ElInfo *, int nPoints, ElementVector &C)
{
for (int iq = 0; iq < nPoints; iq++)
C[iq] += vec[iq] * grad[iq][component] * fac;
if (fct == NULL) {
for (int iq = 0; iq < nPoints; iq++)
C[iq] += vec[iq] * grad[iq][component] * fac;
} else {
for (int iq = 0; iq < nPoints; iq++)
C[iq] += (*fct)(vec[iq]) * grad[iq][component] * fac;
}
}
......@@ -1205,42 +1470,73 @@ void VecAndPartialDerivative_ZOT::eval(int nPoints,
double opFactor)
{
double fac_ = fac * opFactor;
for (int iq = 0; iq < nPoints; iq++)
result[iq] += vec[iq] * grad[iq][component] * uhAtQP[iq] * fac_;
if (fct == NULL) {
for (int iq = 0; iq < nPoints; iq++)
result[iq] += vec[iq] * grad[iq][component] * uhAtQP[iq] * fac_;
} else {
for (int iq = 0; iq < nPoints; iq++)
result[iq] += (*fct)(vec[iq]) * grad[iq][component] * uhAtQP[iq] * fac_;
}
}
/* ----------------------------------------------------------- */
Vec2AndPartialDerivative_ZOT::Vec2AndPartialDerivative_ZOT(DOFVectorBase<double> *vec1DV_, DOFVectorBase<double> *vec2DV_, DOFVectorBase<double> *gradDV_,int component_, double fac_)
: ZeroOrderTerm(3), vec1DV(vec1DV_), vec2DV(vec2DV_), gradDV(gradDV_), fac(fac_), component(component_)
Vec2AndPartialDerivative_ZOT::Vec2AndPartialDerivative_ZOT(DOFVectorBase<double> *vec1DV_,
DOFVectorBase<double> *vec2DV_,
DOFVectorBase<double> *gradDV_,
int component_,
double fac_)
: ZeroOrderTerm(3), vec1DV(vec1DV_), vec2DV(vec2DV_), gradDV(gradDV_), fct(NULL), fac(fac_), component(component_)
{
TEST_EXIT(vec1DV_)("No first vector!\n");
TEST_EXIT(vec2DV_)("No second vector!\n");
TEST_EXIT(gradDV_)("No gradient vector!\n");
auxFeSpaces.insert(vec1DV_->getFeSpace());
auxFeSpaces.insert(vec2DV_->getFeSpace());
auxFeSpaces.insert(gradDV_->getFeSpace());
TEST_EXIT(vec1DV_)("No first vector!\n");
TEST_EXIT(vec2DV_)("No second vector!\n");
TEST_EXIT(gradDV_)("No gradient vector!\n");
auxFeSpaces.insert(vec1DV_->getFeSpace());
auxFeSpaces.insert(vec2DV_->getFeSpace());
auxFeSpaces.insert(gradDV_->getFeSpace());
};
Vec2AndPartialDerivative_ZOT::Vec2AndPartialDerivative_ZOT(DOFVectorBase<double> *vec1DV_,
DOFVectorBase<double> *vec2DV_,
DOFVectorBase<double> *gradDV_,
int component_,
BinaryAbstractFunction<double, double, double>* fct_,
double fac_)
: ZeroOrderTerm(3), vec1DV(vec1DV_), vec2DV(vec2DV_), gradDV(gradDV_), fct(fct_), fac(fac_), component(component_)
{
TEST_EXIT(vec1DV_)("No first vector!\n");
TEST_EXIT(vec2DV_)("No second vector!\n");
TEST_EXIT(gradDV_)("No gradient vector!\n");
auxFeSpaces.insert(vec1DV_->getFeSpace());
auxFeSpaces.insert(vec2DV_->getFeSpace());
auxFeSpaces.insert(gradDV_->getFeSpace());
};
void Vec2AndPartialDerivative_ZOT::initElement(const ElInfo* elInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vec1DV, elInfo, subAssembler, quad, vec1);
getVectorAtQPs(vec2DV, elInfo, subAssembler, quad, vec2);
getGradientsAtQPs(gradDV, elInfo, subAssembler, quad, grad);
getVectorAtQPs(vec1DV, elInfo, subAssembler, quad, vec1);
getVectorAtQPs(vec2DV, elInfo, subAssembler, quad, vec2);
getGradientsAtQPs(gradDV, elInfo, subAssembler, quad, grad);
};
void Vec2AndPartialDerivative_ZOT::initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
SubAssembler* subAssembler,
Quadrature *quad)
{
getVectorAtQPs(vec1DV, smallElInfo, largeElInfo, subAssembler, quad, vec1);
getVectorAtQPs(vec2DV, smallElInfo, largeElInfo, subAssembler, quad, vec2);
getGradientsAtQPs(gradDV, smallElInfo, largeElInfo, subAssembler, quad, grad);
getVectorAtQPs(vec1DV, smallElInfo, largeElInfo, subAssembler, quad, vec1);
getVectorAtQPs(vec2DV, smallElInfo, largeElInfo, subAssembler, quad, vec2);
getGradientsAtQPs(gradDV, smallElInfo, largeElInfo, subAssembler, quad, grad);
};
void Vec2AndPartialDerivative_ZOT::getC(const ElInfo *, int nPoints, ElementVector &C)
{
for (int iq = 0; iq < nPoints; iq++)
C[iq] += vec1[iq]*vec2[iq]*grad[iq][component]*fac;
if (fct == NULL) {
for (int iq = 0; iq < nPoints; iq++)
C[iq] += vec1[iq]*vec2[iq]*grad[iq][component]*fac;
} else {
for (int iq = 0; iq < nPoints; iq++)
C[iq] += (*fct)(vec1[iq],vec2[iq])*grad[iq][component]*fac;
}
};
void Vec2AndPartialDerivative_ZOT::eval(int nPoints,
const mtl::dense_vector<double>& uhAtQP,
......@@ -1249,9 +1545,15 @@ void Vec2AndPartialDerivative_ZOT::eval(int nPoints,
mtl::dense_vector<double>& result,
double opFactor)
{
for (int iq = 0; iq < nPoints; iq++) {
result[iq] += (vec1[iq] * vec2[iq]) * grad[iq][component] * uhAtQP[iq] * opFactor * fac;
}
if (fct == NULL) {
for (int iq = 0; iq < nPoints; iq++) {
result[iq] += (vec1[iq] * vec2[iq]) * grad[iq][component] * uhAtQP[iq] * opFactor * fac;
}
} else {
for (int iq = 0; iq < nPoints; iq++) {
result[iq] += (*fct)(vec1[iq], vec2[iq]) * grad[iq][component] * uhAtQP[iq] * opFactor * fac;
}
}
};
/* ----------------------------------------------------------- */
......
extensions/POperators_FOT.h
View file @ a81287a5
......@@ -180,6 +180,45 @@ double fac;
int numVecs;
};
/* -------------------------------------------------------------- */
/// < f(vec0)*vecs*grad(u) , psi > or < f(vec0)*vecs*u , grad(psi) > where vecs in R^n
struct VecAndWorldVec_FOT : FirstOrderTerm
{
VecAndWorldVec_FOT(DOFVector<double>* vec0,
WorldVector<DOFVector<double>*> vecs,
AbstractFunction<double, double>* fct,
double fac = 1.0);
void initElement(const ElInfo*,
SubAssembler*,
Quadrature *quad= NULL);
void initElement(const ElInfo* largeElInfo,
const ElInfo* smallElInfo,
SubAssembler*,
Quadrature *quad = NULL);
void getLb(const ElInfo *elInfo,
vector<mtl::dense_vector<double> >& result) const;
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);
private:
DOFVector<double> *vDV, *vec0DV, *vec1DV, *vec2DV;
mtl::dense_vector<double> v, vec0, vec1, vec2;
AbstractFunction<double, double>* fct;
double fac;
int numVecs;
};
/* -------------------------------------------------------------- */
/// < factor*d_i(u) , psi > or < factor*u , d_i(psi) >
......@@ -242,6 +281,96 @@ mtl::dense_vector<double> vec1;
double fac;
int component;
};
/* -------------------------------------------------------------- */
/// < d_i(u) * factor*v1*d_j(v2) , psi > or < u * factor*v1*d_j(v2) , d_i(psi) >
struct VecAndPartialDerivativeIJ_FOT : FirstOrderTerm
{
VecAndPartialDerivativeIJ_FOT(DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int i_,
int j_,
double fac_ = 1.0);
VecAndPartialDerivativeIJ_FOT(DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int i_,
int j_,
BinaryAbstractFunction<double, double, double>* fct, // = f(v1, d_j(v2))
double fac_ = 1.0);
void initElement(const ElInfo* elInfo,
SubAssembler* subAssembler,
Quadrature *quad = NULL);
void initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
SubAssembler* subAssembler,
Quadrature *quad = NULL);
void getLb(const ElInfo *elInfo, vector<mtl::dense_vector<double> >& result) const;
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);
private:
DOFVectorBase<double>* vec1DV;
DOFVectorBase<double>* vec2DV;
mtl::dense_vector<double> vec1;
mtl::dense_vector<WorldVector<double> > grad;
BinaryAbstractFunction<double, double, double>* fct;
double fac;
int xi, xj;
};
/* -------------------------------------------------------------- */
/// < factor*v1*v2*d_i(u) , psi > or < factor*v1*v2*u , d_i(psi) >
struct Vec2AndPartialDerivative_FOT : public FirstOrderTerm
{
Vec2AndPartialDerivative_FOT(DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int component_,
double fac_=1.0);
Vec2AndPartialDerivative_FOT(DOFVectorBase<double> *dv1,
DOFVectorBase<double> *dv2,
int component_,
BinaryAbstractFunction<double, double, double>* fct, // = f(v1, v2)
double fac_=1.0);
void initElement(const ElInfo* elInfo,
SubAssembler* subAssembler,
Quadrature *quad = NULL);
void initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
SubAssembler* subAssembler,
Quadrature *quad = NULL);
void getLb(const ElInfo *elInfo, vector<mtl::dense_vector<double> >& result) const;
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);
private:
DOFVectorBase<double>* vec1DV;
DOFVectorBase<double>* vec2DV;
mtl::dense_vector<double> vec1,vec2;
BinaryAbstractFunction<double, double, double>* fct;
double fac;
int component;
};
/* -------------------------------------------------------------- */
......
extensions/POperators_ZOT.h
View file @ a81287a5
......@@ -336,65 +336,87 @@ int component, component2;
/* -------------------------------------------------------------- */
/// < factor*v*d_i(w)*u , psi >
class VecAndPartialDerivative_ZOT : public ZeroOrderTerm
struct VecAndPartialDerivative_ZOT : ZeroOrderTerm
{
public:
VecAndPartialDerivative_ZOT(DOFVectorBase<double>* vecDV_, DOFVectorBase<double>* gradDV_, int component_, double fac_=1.0);
void initElement(const ElInfo*,
SubAssembler*,
Quadrature *quad= NULL);
void initElement(const ElInfo* largeElInfo, const ElInfo* smallElInfo,
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:
DOFVectorBase<double> *vecDV, *gradDV;
mtl::dense_vector<double> vec;
double fac;
mtl::dense_vector<WorldVector<double> > grad;
int component;
VecAndPartialDerivative_ZOT(DOFVectorBase<double>* vecDV_,
DOFVectorBase<double>* gradDV_,
int component_,
double fac_ = 1.0);
VecAndPartialDerivative_ZOT(DOFVectorBase<double>* vecDV_,
DOFVectorBase<double>* gradDV_,
int component_,