int main(int argc, char *argv[])
{
int i,j;
int surfID;
if(argc != 5)
{
fprintf(stderr,"Usage: FldAddScalGrad meshfile infld outfld BoundaryID\n");
exit(1);
}
surfID = boost::lexical_cast<int>(argv[argc - 1]);
argv[argc -1] = argv[argc - 2];
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
//----------------------------------------------
// Read in mesh from input file
string meshfile(argv[argc-4]);
SpatialDomains::MeshGraphSharedPtr graphShPt = SpatialDomains::MeshGraph::Read(vSession);
//----------------------------------------------
//----------------------------------------------
// Import field file.
string fieldfile(argv[argc-3]);
vector<LibUtilities::FieldDefinitionsSharedPtr> fielddef;
vector<vector<NekDouble> > fielddata;
LibUtilities::Import(fieldfile,fielddef,fielddata);
//----------------------------------------------
//----------------------------------------------
// Define Expansion
int expdim = graphShPt->GetMeshDimension();
int nfields = 1;
int addfields = 7;
Array<OneD, MultiRegions::ExpListSharedPtr> exp(nfields + addfields);
MultiRegions::AssemblyMapCGSharedPtr m_locToGlobalMap;
switch(expdim)
{
case 1:
{
ASSERTL0(false,"Expansion dimension not recognised");
}
break;
case 2:
{
ASSERTL0(false,"Expansion dimension not recognised");
}
break;
case 3:
{
MultiRegions::ContField3DSharedPtr originalfield =
MemoryManager<MultiRegions::ContField3D>
::AllocateSharedPtr(vSession, graphShPt,
vSession->GetVariable(0));
m_locToGlobalMap = originalfield->GetLocalToGlobalMap();
exp[0] = originalfield;
for (i=0; i<addfields; i++)
{
exp[i+1] = MemoryManager<MultiRegions::ContField3D>
::AllocateSharedPtr(*originalfield, graphShPt,
vSession->GetVariable(0));
}
}
break;
default:
ASSERTL0(false,"Expansion dimension not recognised");
break;
}
//----------------------------------------------
//----------------------------------------------
// Copy data from field file
for(j = 0; j < nfields+addfields; ++j)
{
for(int i = 0; i < fielddata.size(); ++i)
{
exp[j]->ExtractDataToCoeffs(fielddef [i],
fielddata[i],
fielddef [i]->m_fields[0],
exp[j]->UpdateCoeffs());
}
exp[j]->BwdTrans(exp[j]->GetCoeffs(),exp[j]->UpdatePhys());
}
//----------------------------------------------
//----------------------------------------------
int n, cnt, elmtid, nq, offset, nt, boundary, nfq;
nt = exp[0]->GetNpoints();
Array<OneD, Array<OneD, NekDouble> > grad(expdim);
Array<OneD, Array<OneD, NekDouble> > fgrad(expdim);
Array<OneD, Array<OneD, NekDouble> > values(addfields);
// Set up mapping from Boundary condition to element details.
StdRegions::StdExpansionSharedPtr elmt;
StdRegions::StdExpansion2DSharedPtr bc;
Array<OneD, int> BoundarytoElmtID;
Array<OneD, int> BoundarytoTraceID;
Array<OneD, Array<OneD, MultiRegions::ExpListSharedPtr> > BndExp(addfields);
Array<OneD, const NekDouble> U(nt);
Array<OneD, NekDouble> outvalues;
exp[0]->GetBoundaryToElmtMap(BoundarytoElmtID,BoundarytoTraceID);
//get boundary expansions for each field
for (i = 0; i<addfields; i++)
{
BndExp[i] = exp[i]->GetBndCondExpansions();
}
// loop over the types of boundary conditions
for(cnt = n = 0; n < BndExp[0].num_elements(); ++n)
{
// identify boundary which the user wanted
if(n == surfID)
{
for(i = 0; i < BndExp[0][n]->GetExpSize(); ++i, cnt++)
{
// find element and face of this expansion.
elmtid = BoundarytoElmtID[cnt];
elmt = exp[0]->GetExp(elmtid);
nq = elmt->GetTotPoints();
offset = exp[0]->GetPhys_Offset(elmtid);
// Initialise local arrays for the velocity gradients
// size of total number of quadrature points for each element (hence local).
for(j = 0; j < expdim; ++j)
{
grad[j] = Array<OneD, NekDouble>(nq);
}
if(expdim == 2)
{
}
else
{
for (j = 0; j< addfields; j++)
{
values[j] = BndExp[j][n]->UpdateCoeffs() + BndExp[j][n]->GetCoeff_Offset(i);
}
// Get face 2D expansion from element expansion
bc = boost::dynamic_pointer_cast<StdRegions::StdExpansion2D> (BndExp[0][n]->GetExp(i));
// Number of face quadrature points
nfq = bc->GetTotPoints();
//identify boundary of element
boundary = BoundarytoTraceID[cnt];
//Extract scalar field
U = exp[0]->GetPhys() + offset;
//Compute gradients
elmt->PhysDeriv(U,grad[0],grad[1],grad[2]);
if(i ==0)
{
for (j = 0; j< nq; j++)
{
cout << "element grad: " << grad[0][j] << endl;
}
}
for(j = 0; j < expdim; ++j)
{
fgrad[j] = Array<OneD, NekDouble>(nfq);
}
// Get gradient at the quadrature points of the face
for(j = 0; j < expdim; ++j)
{
elmt->GetFacePhysVals(boundary,bc,grad[j],fgrad[j]);
bc->FwdTrans(fgrad[j],values[j]);
}
if(i ==0)
{
for (j = 0; j< nfq; j++)
{
cout << "face grad: " << fgrad[0][j] << endl;
}
}
const SpatialDomains::GeomFactorsSharedPtr m_metricinfo=bc->GetMetricInfo();
const Array<OneD, const Array<OneD, NekDouble> > normals
= elmt->GetFaceNormal(boundary);
Array<OneD, NekDouble> gradnorm(nfq);
if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
{
Vmath::Vvtvvtp(nfq,normals[0],1,fgrad[0],1,
normals[1],1,fgrad[1],1,gradnorm,1);
Vmath::Vvtvp (nfq,normals[2],1,fgrad[2],1,gradnorm,1,gradnorm,1);
}
else
{
Vmath::Svtsvtp(nfq,normals[0][0],fgrad[0],1,
normals[1][0],fgrad[1],1,gradnorm,1);
Vmath::Svtvp(nfq,normals[2][0],fgrad[2],1,gradnorm,1,gradnorm,1);
}
for(j = 0; j<expdim; j++)
{
bc->FwdTrans(normals[j],values[j+expdim]);
}
//gradient (grad(u) n)
Vmath::Smul(nfq,-1.0,gradnorm,1,gradnorm,1);
bc->FwdTrans(gradnorm,values[expdim*2]);
}
}
}
else
{
cnt += BndExp[0][n]->GetExpSize();
}
}
for(int j = 0; j < addfields; ++j)
{
int ncoeffs = exp[0]->GetNcoeffs();
Array<OneD, NekDouble> output(ncoeffs);
output=exp[j+1]->UpdateCoeffs();
int nGlobal=m_locToGlobalMap->GetNumGlobalCoeffs();
Array<OneD, NekDouble> outarray(nGlobal,0.0);
int bndcnt=0;
const Array<OneD,const int>& map = m_locToGlobalMap->GetBndCondCoeffsToGlobalCoeffsMap();
NekDouble sign;
for(int i = 0; i < BndExp[j].num_elements(); ++i)
{
if(i==surfID)
{
const Array<OneD,const NekDouble>& coeffs = BndExp[j][i]->GetCoeffs();
for(int k = 0; k < (BndExp[j][i])->GetNcoeffs(); ++k)
{
sign = m_locToGlobalMap->GetBndCondCoeffsToGlobalCoeffsSign(bndcnt);
outarray[map[bndcnt++]] = sign * coeffs[k];
}
}
else
{
bndcnt += BndExp[j][i]->GetNcoeffs();
}
}
m_locToGlobalMap->GlobalToLocal(outarray,output);
}
//-----------------------------------------------
// Write solution to file with additional computed fields
string out(argv[argc-2]);
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= exp[0]->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
vector<string > outname;
outname.push_back("du/dx");
outname.push_back("du/dy");
outname.push_back("du/dz");
outname.push_back("nx");
outname.push_back("ny");
outname.push_back("nz");
outname.push_back("gradient");
for(j = 0; j < nfields+addfields; ++j)
{
for(i = 0; i < FieldDef.size(); ++i)
{
if (j >= nfields)
{
FieldDef[i]->m_fields.push_back(outname[j-nfields]);
}
else
{
FieldDef[i]->m_fields.push_back(fielddef[i]->m_fields[j]);
}
exp[j]->AppendFieldData(FieldDef[i], FieldData[i]);
}
}
LibUtilities::Write(out, FieldDef, FieldData);
//-----------------------------------------------
return 0;
}
void FilterAeroForces::v_Update(
const Array<OneD, const MultiRegions::ExpListSharedPtr> &pFields,
const NekDouble &time)
{
// Only output every m_outputFrequency.
if ((m_index++) % m_outputFrequency)
{
return;
}
int n, cnt, elmtid, nq, offset, nt, boundary;
nt = pFields[0]->GetNpoints();
int dim = pFields.num_elements()-1;
StdRegions::StdExpansionSharedPtr elmt;
Array<OneD, int> BoundarytoElmtID;
Array<OneD, int> BoundarytoTraceID;
Array<OneD, MultiRegions::ExpListSharedPtr> BndExp;
Array<OneD, const NekDouble> P(nt);
Array<OneD, const NekDouble> U(nt);
Array<OneD, const NekDouble> V(nt);
Array<OneD, const NekDouble> W(nt);
Array<OneD, Array<OneD, NekDouble> > gradU(dim);
Array<OneD, Array<OneD, NekDouble> > gradV(dim);
Array<OneD, Array<OneD, NekDouble> > gradW(dim);
Array<OneD, Array<OneD, NekDouble> > fgradU(dim);
Array<OneD, Array<OneD, NekDouble> > fgradV(dim);
Array<OneD, Array<OneD, NekDouble> > fgradW(dim);
Array<OneD, NekDouble> values;
LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
NekDouble Fx,Fy,Fz,Fxp,Fxv,Fyp,Fyv,Fzp,Fzv;
Fxp = 0.0; // x-component of the force due to pressure difference
Fxv = 0.0; // x-component of the force due to viscous stress
Fx = 0.0; // x-component of the force (total) Fx = Fxp + Fxv (Drag)
Fyp = 0.0; // y-component of the force due to pressure difference
Fyv = 0.0; // y-component of the force due to viscous stress
Fy = 0.0; // y-component of the force (total) Fy = Fyp + Fyv (Lift)
Fzp = 0.0; // z-component of the force due to pressure difference
Fzv = 0.0; // z-component of the force due to viscous stress
Fz = 0.0; // z-component of the force (total) Fz = Fzp + Fzv (Side)
NekDouble rho = (m_session->DefinesParameter("rho"))
? (m_session->GetParameter("rho"))
: 1;
NekDouble mu = rho*m_session->GetParameter("Kinvis");
for(int i = 0; i < pFields.num_elements(); ++i)
{
pFields[i]->SetWaveSpace(false);
pFields[i]->BwdTrans(pFields[i]->GetCoeffs(),
pFields[i]->UpdatePhys());
pFields[i]->SetPhysState(true);
}
// Homogeneous 1D case Compute forces on all WALL boundaries
// This only has to be done on the zero (mean) Fourier mode.
if(m_isHomogeneous1D)
{
if(vComm->GetColumnComm()->GetRank() == 0)
{
pFields[0]->GetPlane(0)->GetBoundaryToElmtMap(
BoundarytoElmtID,BoundarytoTraceID);
BndExp = pFields[0]->GetPlane(0)->GetBndCondExpansions();
StdRegions::StdExpansion1DSharedPtr bc;
// loop over the types of boundary conditions
for(cnt = n = 0; n < BndExp.num_elements(); ++n)
{
if(m_boundaryRegionIsInList[n] == 1)
{
for(int i = 0; i < BndExp[n]->GetExpSize();
++i, cnt++)
{
// find element of this expansion.
elmtid = BoundarytoElmtID[cnt];
elmt = pFields[0]->GetPlane(0)->GetExp(elmtid);
nq = elmt->GetTotPoints();
offset = pFields[0]->GetPlane(0)->GetPhys_Offset(elmtid);
// Initialise local arrays for the velocity
// gradients size of total number of quadrature
// points for each element (hence local).
for(int j = 0; j < dim; ++j)
{
gradU[j] = Array<OneD, NekDouble>(nq,0.0);
gradV[j] = Array<OneD, NekDouble>(nq,0.0);
gradW[j] = Array<OneD, NekDouble>(nq,0.0);
}
// identify boundary of element
boundary = BoundarytoTraceID[cnt];
// Extract fields
U = pFields[0]->GetPlane(0)->GetPhys() + offset;
V = pFields[1]->GetPlane(0)->GetPhys() + offset;
P = pFields[3]->GetPlane(0)->GetPhys() + offset;
// compute the gradients
elmt->PhysDeriv(U,gradU[0],gradU[1]);
elmt->PhysDeriv(V,gradV[0],gradV[1]);
// Get face 1D expansion from element expansion
bc = boost::dynamic_pointer_cast<LocalRegions
::Expansion1D> (BndExp[n]->GetExp(i));
// number of points on the boundary
int nbc = bc->GetTotPoints();
// several vectors for computing the forces
Array<OneD, NekDouble> Pb(nbc,0.0);
for(int j = 0; j < dim; ++j)
{
fgradU[j] = Array<OneD, NekDouble>(nbc,0.0);
fgradV[j] = Array<OneD, NekDouble>(nbc,0.0);
}
Array<OneD, NekDouble> drag_t(nbc,0.0);
Array<OneD, NekDouble> lift_t(nbc,0.0);
Array<OneD, NekDouble> drag_p(nbc,0.0);
Array<OneD, NekDouble> lift_p(nbc,0.0);
Array<OneD, NekDouble> temp(nbc,0.0);
Array<OneD, NekDouble> temp2(nbc,0.0);
// identify boundary of element .
boundary = BoundarytoTraceID[cnt];
// extraction of the pressure and wss on the
// boundary of the element
elmt->GetEdgePhysVals(boundary,bc,P,Pb);
for(int j = 0; j < dim; ++j)
{
elmt->GetEdgePhysVals(boundary,bc,gradU[j],
fgradU[j]);
elmt->GetEdgePhysVals(boundary,bc,gradV[j],
fgradV[j]);
}
//normals of the element
const Array<OneD, Array<OneD, NekDouble> > &normals
= elmt->GetEdgeNormal(boundary);
//
// Compute viscous tractive forces on wall from
//
// t_i = - T_ij * n_j (minus sign for force
// exerted BY fluid ON wall),
//
// where
//
// T_ij = viscous stress tensor (here in Cartesian
// coords)
// dU_i dU_j
// = RHO * KINVIS * ( ---- + ---- ) .
// dx_j dx_i
//a) DRAG TERMS
//-rho*kinvis*(2*du/dx*nx+(du/dy+dv/dx)*ny
Vmath::Vadd(nbc,fgradU[1],1,fgradV[0],1,drag_t,1);
Vmath::Vmul(nbc,drag_t,1,normals[1],1,drag_t,1);
Vmath::Smul(nbc,2.0,fgradU[0],1,fgradU[0],1);
Vmath::Vmul(nbc,fgradU[0],1,normals[0],1,temp2,1);
Vmath::Smul(nbc,0.5,fgradU[0],1,fgradU[0],1);
Vmath::Vadd(nbc,temp2,1,drag_t,1,drag_t,1);
Vmath::Smul(nbc,-mu,drag_t,1,drag_t,1);
//zero temporary storage vector
Vmath::Zero(nbc,temp,0);
Vmath::Zero(nbc,temp2,0);
//b) LIFT TERMS
//-rho*kinvis*(2*dv/dy*nx+(du/dy+dv/dx)*nx
Vmath::Vadd(nbc,fgradU[1],1,fgradV[0],1,lift_t,1);
Vmath::Vmul(nbc,lift_t,1,normals[0],1,lift_t,1);
Vmath::Smul(nbc,2.0,fgradV[1],1,fgradV[1],1);
Vmath::Vmul(nbc,fgradV[1],1,normals[1],1,temp2,1);
Vmath::Smul(nbc,-0.5,fgradV[1],1,fgradV[1],1);
Vmath::Vadd(nbc,temp2,1,lift_t,1,lift_t,1);
Vmath::Smul(nbc,-mu,lift_t,1,lift_t,1);
// Compute normal tractive forces on all WALL
// boundaries
Vmath::Vvtvp(nbc,Pb,1,normals[0],1,
drag_p,1,drag_p, 1);
Vmath::Vvtvp(nbc,Pb,1,normals[1],1,
lift_p,1,lift_p,1);
//integration over the boundary
Fxv += bc->Integral(drag_t);
Fyv += bc->Integral(lift_t);
Fxp += bc->Integral(drag_p);
Fyp += bc->Integral(lift_p);
}
}
else
{
cnt += BndExp[n]->GetExpSize();
}
}
}
for(int i = 0; i < pFields.num_elements(); ++i)
{
pFields[i]->SetWaveSpace(true);
pFields[i]->BwdTrans(pFields[i]->GetCoeffs(),
pFields[i]->UpdatePhys());
pFields[i]->SetPhysState(false);
}
}
//3D WALL case
else if(dim==3 && !m_isHomogeneous1D)
{
pFields[0]->GetBoundaryToElmtMap(BoundarytoElmtID,
BoundarytoTraceID);
BndExp = pFields[0]->GetBndCondExpansions();
LocalRegions::Expansion2DSharedPtr bc;
// loop over the types of boundary conditions
for(cnt = n = 0; n < BndExp.num_elements(); ++n)
{
if(m_boundaryRegionIsInList[n] == 1)
{
for(int i = 0; i < BndExp[n]->GetExpSize(); ++i, cnt++)
{
// find element of this expansion.
elmtid = BoundarytoElmtID[cnt];
elmt = pFields[0]->GetExp(elmtid);
nq = elmt->GetTotPoints();
offset = pFields[0]->GetPhys_Offset(elmtid);
// Initialise local arrays for the velocity
// gradients size of total number of quadrature
// points for each element (hence local).
for(int j = 0; j < dim; ++j)
{
gradU[j] = Array<OneD, NekDouble>(nq,0.0);
gradV[j] = Array<OneD, NekDouble>(nq,0.0);
gradW[j] = Array<OneD, NekDouble>(nq,0.0);
}
//identify boundary of element
boundary = BoundarytoTraceID[cnt];
//Extract fields
U = pFields[0]->GetPhys() + offset;
V = pFields[1]->GetPhys() + offset;
W = pFields[2]->GetPhys() + offset;
P = pFields[3]->GetPhys() + offset;
//compute the gradients
elmt->PhysDeriv(U,gradU[0],gradU[1],gradU[2]);
elmt->PhysDeriv(V,gradV[0],gradV[1],gradV[2]);
elmt->PhysDeriv(W,gradW[0],gradW[1],gradW[2]);
// Get face 2D expansion from element expansion
bc = boost::dynamic_pointer_cast<LocalRegions
::Expansion2D> (BndExp[n]->GetExp(i));
//number of points on the boundary
int nbc = bc->GetTotPoints();
//several vectors for computing the forces
Array<OneD, NekDouble> Pb(nbc,0.0);
for(int j = 0; j < dim; ++j)
{
fgradU[j] = Array<OneD, NekDouble>(nbc,0.0);
fgradV[j] = Array<OneD, NekDouble>(nbc,0.0);
fgradW[j] = Array<OneD, NekDouble>(nbc,0.0);
}
Array<OneD, NekDouble> drag_t(nbc,0.0);
Array<OneD, NekDouble> lift_t(nbc,0.0);
Array<OneD, NekDouble> side_t(nbc,0.0);
Array<OneD, NekDouble> drag_p(nbc,0.0);
Array<OneD, NekDouble> lift_p(nbc,0.0);
Array<OneD, NekDouble> side_p(nbc,0.0);
Array<OneD, NekDouble> temp(nbc,0.0);
Array<OneD, NekDouble> temp2(nbc,0.0);
// identify boundary of element .
boundary = BoundarytoTraceID[cnt];
// extraction of the pressure and wss on the
// boundary of the element
elmt->GetFacePhysVals(boundary,bc,P,Pb);
for(int j = 0; j < dim; ++j)
{
elmt->GetFacePhysVals(boundary,bc,gradU[j],
fgradU[j]);
elmt->GetFacePhysVals(boundary,bc,gradV[j],
fgradV[j]);
elmt->GetFacePhysVals(boundary,bc,gradW[j],
fgradW[j]);
}
// normals of the element
const Array<OneD, Array<OneD, NekDouble> > &normals
= elmt->GetFaceNormal(boundary);
//
// Compute viscous tractive forces on wall from
//
// t_i = - T_ij * n_j (minus sign for force
// exerted BY fluid ON wall),
//
// where
//
// T_ij = viscous stress tensor (here in Cartesian
// coords)
// dU_i dU_j
// = RHO * KINVIS * ( ---- + ---- ) .
// dx_j dx_i
//a) DRAG TERMS
//-rho*kinvis*
// (2*du/dx*nx+(du/dy+dv/dx)*ny+(du/dz+dw/dx)*nz)
Vmath::Vadd(nbc,fgradU[2],1,fgradW[0],1,temp,1);
Vmath::Neg(nbc,temp,1);
Vmath::Vmul(nbc,temp,1,normals[2],1,temp,1);
Vmath::Vadd(nbc,fgradU[1],1,fgradV[0],1,drag_t,1);
Vmath::Neg(nbc,drag_t,1);
Vmath::Vmul(nbc,drag_t,1,normals[1],1,drag_t,1);
Vmath::Smul(nbc,-2.0,fgradU[0],1,fgradU[0],1);
Vmath::Vmul(nbc,fgradU[0],1,normals[0],1,temp2,1);
Vmath::Smul(nbc,-0.5,fgradU[0],1,fgradU[0],1);
Vmath::Vadd(nbc,temp,1,temp2,1,temp,1);
Vmath::Vadd(nbc,temp,1,drag_t,1,drag_t,1);
Vmath::Smul(nbc,mu,drag_t,1,drag_t,1);
//zero temporary storage vector
Vmath::Zero(nbc,temp,0);
Vmath::Zero(nbc,temp2,0);
//b) LIFT TERMS
//-rho*kinvis*
// (2*dv/dy*nx+(du/dy+dv/dx)*nx+(dv/dz+dw/dy)*nz)
Vmath::Vadd(nbc,fgradV[2],1,fgradW[1],1,temp,1);
Vmath::Neg(nbc,temp,1);
Vmath::Vmul(nbc,temp,1,normals[2],1,temp,1);
Vmath::Vadd(nbc,fgradU[1],1,fgradV[0],1,lift_t,1);
Vmath::Neg(nbc,lift_t,1);
Vmath::Vmul(nbc,lift_t,1,normals[0],1,lift_t,1);
Vmath::Smul(nbc,-2.0,fgradV[1],1,fgradV[1],1);
Vmath::Vmul(nbc,fgradV[1],1,normals[1],1,temp2,1);
Vmath::Smul(nbc,-0.5,fgradV[1],1,fgradV[1],1);
Vmath::Vadd(nbc,temp,1,temp2,1,temp,1);
Vmath::Vadd(nbc,temp,1,lift_t,1,lift_t,1);
Vmath::Smul(nbc,mu,lift_t,1,lift_t,1);
//zero temporary storage vector
Vmath::Zero(nbc,temp,0);
Vmath::Zero(nbc,temp2,0);
//b) SIDE TERMS
//-rho*kinvis*
// (2*dv/dy*nx+(du/dy+dv/dx)*nx+(dv/dz+dw/dy)*nz)
Vmath::Vadd(nbc,fgradV[2],1,fgradW[1],1,temp,1);
Vmath::Neg(nbc,temp,1);
Vmath::Vmul(nbc,temp,1,normals[1],1,temp,1);
Vmath::Vadd(nbc,fgradU[2],1,fgradW[0],1,side_t,1);
Vmath::Neg(nbc,side_t,1);
Vmath::Vmul(nbc,side_t,1,normals[0],1,side_t,1);
Vmath::Smul(nbc,-2.0,fgradW[2],1,fgradW[2],1);
Vmath::Vmul(nbc,fgradW[2],1,normals[2],1,temp2,1);
Vmath::Smul(nbc,-0.5,fgradW[2],1,fgradW[2],1);
Vmath::Vadd(nbc,temp,1,temp2,1,temp,1);
Vmath::Vadd(nbc,temp,1,side_t,1,side_t,1);
Vmath::Smul(nbc,mu,side_t,1,side_t,1);
// Compute normal tractive forces on all WALL
// boundaries
Vmath::Vvtvp(nbc,Pb,1,normals[0],1,
drag_p,1,drag_p,1);
Vmath::Vvtvp(nbc,Pb,1,normals[1],1,
lift_p,1,lift_p,1);
Vmath::Vvtvp(nbc,Pb,1,normals[2],1,
side_p,1,side_p,1);
//integration over the boundary
Fxv += bc->Expansion::Integral(drag_t);
Fyv += bc->Expansion::Integral(lift_t);
Fzv += bc->Expansion::Integral(side_t);
Fxp += bc->Expansion::Integral(drag_p);
Fyp += bc->Expansion::Integral(lift_p);
Fzp += bc->Expansion::Integral(side_p);
}
}
else
{
cnt += BndExp[n]->GetExpSize();
}
}
}
//2D WALL Condition
else
{
pFields[0]->GetBoundaryToElmtMap(BoundarytoElmtID,
BoundarytoTraceID);
BndExp = pFields[0]->GetBndCondExpansions();
StdRegions::StdExpansion1DSharedPtr bc;
// loop over the types of boundary conditions
for(cnt = n = 0; n < BndExp.num_elements(); ++n)
{
if(m_boundaryRegionIsInList[n] == 1)
{
for(int i = 0; i < BndExp[n]->GetExpSize(); ++i, cnt++)
{
elmtid = BoundarytoElmtID[cnt];
elmt = pFields[0]->GetExp(elmtid);
nq = elmt->GetTotPoints();
offset = pFields[0]->GetPhys_Offset(elmtid);
for(int j = 0; j < dim; ++j)
{
gradU[j] = Array<OneD, NekDouble>(nq,0.0);
gradV[j] = Array<OneD, NekDouble>(nq,0.0);
}
boundary = BoundarytoTraceID[cnt];
U = pFields[0]->GetPhys() + offset;
V = pFields[1]->GetPhys() + offset;
P = pFields[2]->GetPhys() + offset;
elmt->PhysDeriv(U,gradU[0],gradU[1]);
elmt->PhysDeriv(V,gradV[0],gradV[1]);
bc = boost::dynamic_pointer_cast<LocalRegions
::Expansion1D> (BndExp[n]->GetExp(i));
int nbc = bc->GetTotPoints();
Array<OneD, NekDouble> Pb(nbc,0.0);
Array<OneD, NekDouble> drag_t(nbc,0.0);
Array<OneD, NekDouble> lift_t(nbc,0.0);
Array<OneD, NekDouble> drag_p(nbc,0.0);
Array<OneD, NekDouble> lift_p(nbc,0.0);
Array<OneD, NekDouble> temp(nbc,0.0);
boundary = BoundarytoTraceID[cnt];
elmt->GetEdgePhysVals(boundary,bc,P,Pb);
for(int j = 0; j < dim; ++j)
{
fgradU[j] = Array<OneD, NekDouble>(nbc,0.0);
fgradV[j] = Array<OneD, NekDouble>(nbc,0.0);
}
for(int j = 0; j < dim; ++j)
{
elmt->GetEdgePhysVals(boundary,bc,gradU[j],
fgradU[j]);
elmt->GetEdgePhysVals(boundary,bc,gradV[j],
fgradV[j]);
}
const Array<OneD, Array<OneD, NekDouble> > &normals
= elmt->GetEdgeNormal(boundary);
Vmath::Vadd(nbc,fgradU[1],1,fgradV[0],1,drag_t,1);
Vmath::Neg(nbc,drag_t,1);
Vmath::Vmul(nbc,drag_t,1,normals[1],1,drag_t,1);
Vmath::Smul(nbc,-2.0,fgradU[0],1,fgradU[0],1);
Vmath::Vmul(nbc,fgradU[0],1,normals[0],1,temp,1);
Vmath::Vadd(nbc,temp,1,drag_t,1,drag_t,1);
Vmath::Smul(nbc,mu,drag_t,1,drag_t,1);
Vmath::Vadd(nbc,fgradU[1],1,fgradV[0],1,lift_t,1);
Vmath::Neg(nbc,lift_t,1);
Vmath::Vmul(nbc,lift_t,1,normals[0],1,lift_t,1);
Vmath::Smul(nbc,-2.0,fgradV[1],1,fgradV[1],1);
Vmath::Vmul(nbc,fgradV[1],1,normals[1],1,temp,1);
Vmath::Vadd(nbc,temp,1,lift_t,1,lift_t,1);
Vmath::Smul(nbc,mu,lift_t,1,lift_t,1);
Vmath::Vvtvp(nbc,Pb,1,normals[0],1,
drag_p,1,drag_p,1);
Vmath::Vvtvp(nbc,Pb,1,normals[1],1,
lift_p,1,lift_p,1);
Fxp += bc->Integral(drag_p);
Fyp += bc->Integral(lift_p);
Fxv += bc->Integral(drag_t);
Fyp += bc->Integral(lift_t);
}
}
else
{
cnt += BndExp[n]->GetExpSize();
}
}
}
vComm->AllReduce(Fxp, LibUtilities::ReduceSum);
vComm->AllReduce(Fxv, LibUtilities::ReduceSum);
Fx = Fxp + Fxv;
vComm->AllReduce(Fyp, LibUtilities::ReduceSum);
vComm->AllReduce(Fyv, LibUtilities::ReduceSum);
Fy = Fyp + Fyv;
vComm->AllReduce(Fzp, LibUtilities::ReduceSum);
vComm->AllReduce(Fzv, LibUtilities::ReduceSum);
Fz = Fzp + Fzv;
if (vComm->GetRank() == 0)
{
m_outputStream.width(8);
m_outputStream << setprecision(6) << time;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fxp;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fxv;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fx;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fyp;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fyv;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fy;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fzp;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fzv;
m_outputStream.width(25);
m_outputStream << setprecision(8) << Fz;
m_outputStream << endl;
}
}
void ProcessWSS::Process(po::variables_map &vm)
{
if (m_f->m_verbose)
{
cout << "ProcessWSS: Calculating wall shear stress..." << endl;
}
m_f->m_addNormals = m_config["addnormals"].m_beenSet;
// Set up Field options to output boundary fld
string bvalues = m_config["bnd"].as<string>();
if(bvalues.compare("All") == 0)
{
Array<OneD, const MultiRegions::ExpListSharedPtr>
BndExp = m_f->m_exp[0]->GetBndCondExpansions();
for(int i = 0; i < BndExp.num_elements(); ++i)
{
m_f->m_bndRegionsToWrite.push_back(i);
}
}
else
{
ASSERTL0(ParseUtils::GenerateOrderedVector(bvalues.c_str(),
m_f->m_bndRegionsToWrite),"Failed to interpret range string");
}
NekDouble m_kinvis;
m_kinvis = m_f->m_session->GetParameter("Kinvis");
int i, j;
int spacedim = m_f->m_graph->GetSpaceDimension();
if ((m_f->m_fielddef[0]->m_numHomogeneousDir) == 1 ||
(m_f->m_fielddef[0]->m_numHomogeneousDir) == 2)
{
spacedim = 3;
}
int nfields = m_f->m_fielddef[0]->m_fields.size();
ASSERTL0(nfields == spacedim +1,"Implicit assumption that input is in incompressible format of (u,v,p) or (u,v,w,p)");
nfields = nfields - 1;
if (spacedim == 1)
{
ASSERTL0(false, "Error: wss for a 1D problem cannot "
"be computed");
}
int newfields = (spacedim == 2)? 3:4;
int nshear = (spacedim == 2)? 3:4;
int nstress = (spacedim == 2)? 3:6;
int ngrad = nfields*nfields;
int n, cnt, elmtid, nq, offset, boundary, nfq;
int npoints = m_f->m_exp[0]->GetNpoints();
Array<OneD, Array<OneD, NekDouble> > velocity(nfields), grad(ngrad), fgrad(ngrad);
Array<OneD, Array<OneD, NekDouble> > stress(nstress), fstress(nstress);
Array<OneD, Array<OneD, NekDouble> > outfield(newfields), fshear(nshear);
StdRegions::StdExpansionSharedPtr elmt;
StdRegions::StdExpansion2DSharedPtr bc;
Array<OneD, int> BoundarytoElmtID, BoundarytoTraceID;
Array<OneD, Array<OneD, MultiRegions::ExpListSharedPtr> > BndExp(newfields);
m_f->m_exp.resize(newfields);
string var = "u";
for(i = nfields+1; i < newfields; ++i)
{
m_f->m_exp[i] = m_f->AppendExpList(m_f->m_fielddef[0]->m_numHomogeneousDir, var);
}
m_f->m_fielddef[0]->m_fields.resize(newfields);
if(spacedim == 2)
{
m_f->m_fielddef[0]->m_fields[0] = "Shear_x";
m_f->m_fielddef[0]->m_fields[1] = "Shear_y";
m_f->m_fielddef[0]->m_fields[2] = "Shear_mag";
}
else
{
m_f->m_fielddef[0]->m_fields[0] = "Shear_x";
m_f->m_fielddef[0]->m_fields[1] = "Shear_y";
m_f->m_fielddef[0]->m_fields[2] = "Shear_z";
m_f->m_fielddef[0]->m_fields[3] = "Shear_mag";
}
for (i = 0; i < newfields; ++i)
{
outfield[i] = Array<OneD, NekDouble>(npoints);
}
for (i = 0; i < nfields; ++i)
{
velocity[i] = Array<OneD, NekDouble>(npoints);
}
m_f->m_exp[0]->GetBoundaryToElmtMap(BoundarytoElmtID, BoundarytoTraceID);
//get boundary expansions for each field
for(int j = 0; j < newfields; ++j)
{
BndExp[j] = m_f->m_exp[j]->GetBndCondExpansions();
}
// loop over the types of boundary conditions
for(cnt = n = 0; n < BndExp[0].num_elements(); ++n)
{
bool doneBnd = false;
// identify if boundary has been defined
for(int b = 0; b < m_f->m_bndRegionsToWrite.size(); ++b)
{
if(n == m_f->m_bndRegionsToWrite[b])
{
doneBnd = true;
for(int i = 0; i < BndExp[0][n]->GetExpSize(); ++i, cnt++)
{
// find element and face of this expansion.
elmtid = BoundarytoElmtID[cnt];
elmt = m_f->m_exp[0]->GetExp(elmtid);
nq = elmt->GetTotPoints();
offset = m_f->m_exp[0]->GetPhys_Offset(elmtid);
// Initialise local arrays for the velocity gradients, and stress components
// size of total number of quadrature points for each element (hence local).
for(int j = 0; j < ngrad; ++j)
{
grad[j] = Array<OneD, NekDouble>(nq);
}
for(int j = 0; j < nstress; ++j)
{
stress[j] = Array<OneD, NekDouble>(nq);
}
if(nfields == 2)
{
ASSERTL0(false, "Error: not implemented in 2D.");
}
else
{
// Get face 2D expansion from element expansion
bc = boost::dynamic_pointer_cast<StdRegions::StdExpansion2D> (BndExp[0][n]->GetExp(i));
nfq = bc->GetTotPoints();
//identify boundary of element looking at.
boundary = BoundarytoTraceID[cnt];
//Get face normals
const SpatialDomains::GeomFactorsSharedPtr m_metricinfo = bc->GetMetricInfo();
const Array<OneD, const Array<OneD, NekDouble> > normals
= elmt->GetFaceNormal(boundary);
// initialise arrays
for(int j = 0; j < nstress; ++j)
{
fstress[j] = Array<OneD, NekDouble>(nfq);
}
for(int j = 0; j < nfields*nfields; ++j)
{
fgrad[j] = Array<OneD, NekDouble>(nfq);
}
for(int j = 0; j < nshear; ++j)
{
fshear[j] = Array<OneD, NekDouble>(nfq);
}
//Extract Velocities
for(int j = 0; j < nfields; ++j)
{
velocity[j] = m_f->m_exp[j]->GetPhys() + offset;
}
//Compute gradients (velocity correction scheme method)
elmt->PhysDeriv(velocity[0],grad[0],grad[1],grad[2]);
elmt->PhysDeriv(velocity[1],grad[3],grad[4],grad[5]);
elmt->PhysDeriv(velocity[2],grad[6],grad[7],grad[8]);
//Compute stress component terms
// t_xx = 2.mu.Ux
Vmath::Smul (nq,(2*m_kinvis),grad[0],1,stress[0],1);
// tyy = 2.mu.Vy
Vmath::Smul (nq,(2*m_kinvis),grad[4],1,stress[1],1);
// tzz = 2.mu.Wz
Vmath::Smul (nq,(2*m_kinvis),grad[8],1,stress[2],1);
// txy = mu.(Uy+Vx)
Vmath::Vadd (nq,grad[1],1,grad[3],1,stress[3],1);
Vmath::Smul (nq,m_kinvis,stress[3],1,stress[3],1);
// txz = mu.(Uz+Wx)
Vmath::Vadd (nq,grad[2],1,grad[6],1,stress[4],1);
Vmath::Smul (nq,m_kinvis,stress[4],1,stress[4],1);
// tyz = mu.(Vz+Wy)
Vmath::Vadd (nq,grad[5],1,grad[7],1,stress[5],1);
Vmath::Smul (nq,m_kinvis,stress[5],1,stress[5],1);
// Get face stress values.
for(j = 0; j < nstress; ++j)
{
elmt->GetFacePhysVals(boundary,bc,stress[j],fstress[j]);
}
//calcuate wss, and update velocity coeffs in the elemental boundary expansion
for (j = 0; j< newfields; j++)
{
outfield[j] = BndExp[j][n]->UpdateCoeffs() + BndExp[j][n]->GetCoeff_Offset(i);
}
//surface curved
if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
{
// Sx
Vmath::Vvtvvtp(nfq,normals[0],1,fstress[0],1,
normals[1],1,fstress[3],1,fshear[0],1);
Vmath::Vvtvp (nfq,normals[2],1,fstress[4],1,fshear[0],1,fshear[0],1);
// Sy
Vmath::Vvtvvtp(nfq,normals[0],1,fstress[3],1,
normals[1],1,fstress[1],1,fshear[1],1);
Vmath::Vvtvp (nfq,normals[2],1,fstress[5],1,fshear[1],1,fshear[1],1);
// Sz
Vmath::Vvtvvtp(nfq,normals[0],1,fstress[4],1,
normals[1],1,fstress[5],1,fshear[2],1);
Vmath::Vvtvp (nfq,normals[2],1,fstress[2],1,fshear[2],1,fshear[2],1);
}
else
{
// Sx
Vmath::Svtsvtp(nfq,normals[0][0],fstress[0],1,
normals[1][0],fstress[3],1,fshear[0],1);
Vmath::Svtvp(nfq,normals[2][0],fstress[4],1,fshear[0],1,fshear[0],1);
// Sy
Vmath::Svtsvtp(nfq,normals[0][0],fstress[3],1,
normals[1][0],fstress[1],1,fshear[1],1);
Vmath::Svtvp(nfq,normals[2][0],fstress[5],1,fshear[1],1,fshear[1],1);
// Sz
Vmath::Svtsvtp(nfq,normals[0][0],fstress[4],1,
normals[1][0],fstress[5],1,fshear[2],1);
Vmath::Svtvp(nfq,normals[2][0],fstress[2],1,fshear[2],1,fshear[2],1);
}
// T = T - (T.n)n
if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
{
Vmath::Vvtvvtp(nfq,normals[0],1,fshear[0],1,
normals[1],1, fshear[1],1,fshear[3],1);
Vmath::Vvtvp (nfq,normals[2],1, fshear[2],1,fshear[3],1,fshear[3],1);
Vmath::Smul(nfq, -1.0, fshear[3], 1, fshear[3], 1);
for (j = 0; j < nfields; j++)
{
Vmath::Vvtvp(nfq,normals[j], 1, fshear[3], 1, fshear[j], 1, fshear[j], 1);
bc->FwdTrans(fshear[j], outfield[j]);
}
}
else
{
Vmath::Svtsvtp(nfq,normals[0][0],fshear[0],1,
normals[1][0],fshear[1],1,fshear[3],1);
Vmath::Svtvp(nfq,normals[2][0],fshear[2],1,fshear[3],1,fshear[3],1);
Vmath::Smul(nfq, -1.0, fshear[3], 1,fshear[3], 1);
for (j = 0; j < nfields; j++)
{
Vmath::Svtvp(nfq,normals[j][0],fshear[3],1,fshear[j],1,fshear[j],1);
bc->FwdTrans(fshear[j], outfield[j]);
}
}
// Tw
Vmath::Vvtvvtp(nfq, fshear[0], 1, fshear[0], 1, fshear[1], 1, fshear[1], 1, fshear[3], 1);
Vmath::Vvtvp(nfq, fshear[2], 1, fshear[2], 1, fshear[3], 1, fshear[3], 1);
Vmath::Vsqrt(nfq, fshear[3], 1, fshear[3], 1);
bc->FwdTrans(fshear[3], outfield[3]);
}
}
}
}
if(doneBnd == false)
{
cnt += BndExp[0][n]->GetExpSize();
}
}
for(int j = 0; j < newfields; ++j)
{
for(int b = 0; b < m_f->m_bndRegionsToWrite.size(); ++b)
{
m_f->m_exp[j]->UpdateBndCondExpansion(m_f->m_bndRegionsToWrite[b]) = BndExp[j][m_f->m_bndRegionsToWrite[b]];
}
}
}