void FilterElectrogram::v_Update(
const Array<OneD, const MultiRegions::ExpListSharedPtr> &pFields,
const NekDouble &time)
{
// Only output every m_outputFrequency.
if ((m_index++) % m_outputFrequency)
{
return;
}
const unsigned int nq = pFields[0]->GetNpoints();
const unsigned int npoints = m_electrogramPoints.size();
LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
unsigned int i = 0;
Array<OneD, NekDouble> e(npoints);
// Compute grad V
Array<OneD, NekDouble> grad_V_x(nq), grad_V_y(nq), grad_V_z(nq);
pFields[0]->PhysDeriv(pFields[0]->GetPhys(),
grad_V_x, grad_V_y, grad_V_z);
for (i = 0; i < npoints; ++i)
{
// Multiply together
Array<OneD, NekDouble> output(nq);
Vmath::Vvtvvtp(nq, m_grad_R_x[i], 1, grad_V_x, 1, m_grad_R_y[i], 1,
grad_V_y, 1, output, 1);
Vmath::Vvtvp (nq, m_grad_R_z[i], 1, grad_V_z, 1, output, 1,
output, 1);
e[i] = pFields[0]->Integral(output);
}
// Exchange history data
// This could be improved to reduce communication but works for now
vComm->AllReduce(e, LibUtilities::ReduceSum);
// Only the root process writes out electrogram data
if (vComm->GetRank() == 0)
{
m_outputStream.width(8);
m_outputStream << setprecision(6) << time;
// Write data values point by point
for (i = 0; i < m_electrogramPoints.size(); ++i)
{
m_outputStream.width(25);
m_outputStream << setprecision(16) << e[i];
}
m_outputStream << endl;
}
}
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 FilterAeroForces::v_Initialise(
const Array<OneD, const MultiRegions::ExpListSharedPtr> &pFields,
const NekDouble &time)
{
// Parse the boundary regions into a list.
std::string::size_type FirstInd =
m_BoundaryString.find_first_of('[') + 1;
std::string::size_type LastInd =
m_BoundaryString.find_last_of(']') - 1;
ASSERTL0(FirstInd <= LastInd,
(std::string("Error reading boundary region definition:") +
m_BoundaryString).c_str());
std::string IndString =
m_BoundaryString.substr(FirstInd, LastInd - FirstInd + 1);
bool parseGood = ParseUtils::GenerateSeqVector(IndString.c_str(),
m_boundaryRegionsIdList);
ASSERTL0(parseGood && !m_boundaryRegionsIdList.empty(),
(std::string("Unable to read boundary regions index "
"range for FilterAeroForces: ") + IndString).c_str());
// determine what boundary regions need to be considered
int cnt;
unsigned int numBoundaryRegions =
pFields[0]->GetBndConditions().num_elements();
m_boundaryRegionIsInList.insert(m_boundaryRegionIsInList.end(),
numBoundaryRegions, 0);
SpatialDomains::BoundaryConditions bcs(m_session,
pFields[0]->GetGraph());
const SpatialDomains::BoundaryRegionCollection &bregions =
bcs.GetBoundaryRegions();
SpatialDomains::BoundaryRegionCollection::const_iterator it;
for (cnt = 0, it = bregions.begin(); it != bregions.end();
++it, cnt++)
{
if ( std::find(m_boundaryRegionsIdList.begin(),
m_boundaryRegionsIdList.end(), it->first) !=
m_boundaryRegionsIdList.end() )
{
m_boundaryRegionIsInList[cnt] = 1;
}
}
LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
if (vComm->GetRank() == 0)
{
// Open output stream
m_outputStream.open(m_outputFile.c_str());
m_outputStream << "#";
m_outputStream.width(7);
m_outputStream << "Time";
m_outputStream.width(25);
m_outputStream << "Fx (press)";
m_outputStream.width(25);
m_outputStream << "Fx (visc)";
m_outputStream.width(25);
m_outputStream << "Fx (tot)";
m_outputStream.width(25);
m_outputStream << "Fy (press)";
m_outputStream.width(25);
m_outputStream << "Fy (visc)";
m_outputStream.width(25);
m_outputStream << "Fy (tot)";
m_outputStream.width(25);
m_outputStream << "Fz (press)";
m_outputStream.width(25);
m_outputStream << "Fz (visc)";
m_outputStream.width(25);
m_outputStream << "Fz (tot)";
m_outputStream << endl;
}
v_Update(pFields, time);
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
MultiRegions::DisContField3DSharedPtr Exp,Fce;
int i, nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
StdRegions::ConstFactorMap factors;
if(argc < 2)
{
fprintf(stderr,"Usage: PostProcHDG3D meshfile [solntype]\n");
exit(1);
}
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph3D = MemoryManager<SpatialDomains::MeshGraph3D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
factors[StdRegions::eFactorLambda] = vSession->GetParameter("Lambda");
factors[StdRegions::eFactorTau] = 1.0;
const SpatialDomains::ExpansionMap &expansions = graph3D->GetExpansions();
LibUtilities::BasisKey bkey0
= expansions.begin()->second->m_basisKeyVector[0];
//MAY NEED ADJUSTMENT FOR VARIOUS ELEMENT TYPES
int num_modes = bkey0.GetNumModes();
int num_points = bkey0.GetNumPoints();
if (vComm->GetRank() == 0)
{
cout << "Solving 3D Helmholtz:" << endl;
cout << " Lambda : " << factors[StdRegions::eFactorLambda] << endl;
cout << " No. modes : " << num_modes << endl;
cout << " No. points : " << num_points << endl;
cout << endl;
}
//----------------------------------------------
// Define Expansion
//----------------------------------------------
Exp = MemoryManager<MultiRegions::DisContField3D>::
AllocateSharedPtr(vSession,graph3D,vSession->GetVariable(0));
//----------------------------------------------
Timing("Read files and define exp ..");
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
xc0 = Array<OneD,NekDouble>(nq,0.0);
xc1 = Array<OneD,NekDouble>(nq,0.0);
xc2 = Array<OneD,NekDouble>(nq,0.0);
switch(coordim)
{
case 1:
Exp->GetCoords(xc0);
break;
case 2:
Exp->GetCoords(xc0,xc1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
}
//----------------------------------------------
//----------------------------------------------
// Define forcing function for first variable defined in file
fce = Array<OneD,NekDouble>(nq);
LibUtilities::EquationSharedPtr ffunc
= vSession->GetFunction("Forcing", 0);
ffunc->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::DisContField3D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
Timing("Define forcing ..");
//----------------------------------------------
// Helmholtz solution taking physical forcing
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
//----------------------------------------------
Timing("Helmholtz Solve ..");
//-----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//-----------------------------------------------
Timing("Backward Transform ..");
//-----------------------------------------------
// Write solution to file
//string out = vSession->GetSessionName() + ".fld";
//std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
// = Exp->GetFieldDefinitions();
//std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
//for(i = 0; i < FieldDef.size(); ++i)
//{
// FieldDef[i]->m_fields.push_back("u");
// Exp->AppendFieldData(FieldDef[i], FieldData[i]);
//}
//LibUtilities::Write(out, FieldDef, FieldData);
//--------------------------------------------
//-----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol =
vSession->GetFunction("ExactSolution", 0);
//----------------------------------------------
// evaluate exact solution
ex_sol->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//Tetrahedron
const LibUtilities::PointsKey PkeyT1(num_points+1,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyT2(num_points,LibUtilities::eGaussRadauMAlpha1Beta0);//need to doublecheck this one
const LibUtilities::PointsKey PkeyT3(num_points,LibUtilities::eGaussRadauMAlpha2Beta0);//need to doublecheck this one
LibUtilities::BasisKeyVector BkeyT;
BkeyT.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyT1));
BkeyT.push_back(LibUtilities::BasisKey(LibUtilities::eModified_B, num_modes+1, PkeyT2));
BkeyT.push_back(LibUtilities::BasisKey(LibUtilities::eModified_C, num_modes+1, PkeyT3));
//Prism
const LibUtilities::PointsKey PkeyP1(num_points+1,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyP2(num_points+1,LibUtilities::eGaussLobattoLegendre);
const LibUtilities::PointsKey PkeyP3(num_points,LibUtilities::eGaussRadauMAlpha1Beta0);//need to doublecheck this one
LibUtilities::BasisKeyVector BkeyP;
BkeyP.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyP1));
BkeyP.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyP2));
BkeyP.push_back(LibUtilities::BasisKey(LibUtilities::eModified_B, num_modes+1, PkeyP3));
//Hexahedron
const LibUtilities::PointsKey PkeyH(num_points+1,LibUtilities::eGaussLobattoLegendre);
LibUtilities::BasisKeyVector BkeyH;
BkeyH.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyH));
BkeyH.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyH));
BkeyH.push_back(LibUtilities::BasisKey(LibUtilities::eModified_A, num_modes+1, PkeyH));
graph3D->SetBasisKey(LibUtilities::eTetrahedron, BkeyT);
graph3D->SetBasisKey(LibUtilities::ePrism, BkeyP);
graph3D->SetBasisKey(LibUtilities::eHexahedron, BkeyH);
MultiRegions::DisContField3DSharedPtr PostProc =
MemoryManager<MultiRegions::DisContField3D>::AllocateSharedPtr(vSession,graph3D,vSession->GetVariable(0));
int ErrorCoordim = PostProc->GetCoordim(0);
int ErrorNq = PostProc->GetTotPoints();
Array<OneD,NekDouble> ErrorXc0(ErrorNq,0.0);
Array<OneD,NekDouble> ErrorXc1(ErrorNq,0.0);
Array<OneD,NekDouble> ErrorXc2(ErrorNq,0.0);
switch(ErrorCoordim)
{
case 1:
PostProc->GetCoords(ErrorXc0);
break;
case 2:
PostProc->GetCoords(ErrorXc0,ErrorXc1);
break;
case 3:
PostProc->GetCoords(ErrorXc0,ErrorXc1,ErrorXc2);
break;
}
// evaluate exact solution
Array<OneD,NekDouble> ppSol(ErrorNq);
ex_sol->Evaluate(ErrorXc0,ErrorXc1,ErrorXc2,ppSol);
// calcualte spectral/hp approximation on the quad points of this new
// expansion basis
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
std::string fieldstr = "u";
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back(fieldstr);
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
PostProc->ExtractDataToCoeffs(FieldDef[i],FieldData[i],fieldstr,PostProc->UpdateCoeffs());
}
// Interpolation of trace
std::vector<LibUtilities::FieldDefinitionsSharedPtr> TraceDef
= Exp->GetTrace()->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > TraceData(TraceDef.size());
for(i = 0; i < TraceDef.size(); ++i)
{
TraceDef[i]->m_fields.push_back(fieldstr);
Exp->GetTrace()->AppendFieldData(TraceDef[i], TraceData[i]);
PostProc->GetTrace()->ExtractDataToCoeffs(TraceDef[i],TraceData[i],fieldstr,PostProc->GetTrace()->UpdateCoeffs());
}
PostProc->BwdTrans_IterPerExp(PostProc->GetCoeffs(),PostProc->UpdatePhys());
PostProc->EvaluateHDGPostProcessing(PostProc->UpdateCoeffs());
PostProc->BwdTrans_IterPerExp(PostProc->GetCoeffs(),PostProc->UpdatePhys());
NekDouble vLinfError = Exp->Linf(Exp->GetPhys(), fce);
NekDouble vL2Error = Exp->L2 (Exp->GetPhys(), fce);
NekDouble L2ErrorPostProc = PostProc->L2(PostProc->GetPhys(), ppSol);
NekDouble LinfErrorPostProc = PostProc->Linf(PostProc->GetPhys(), ppSol);
if (vSession->GetComm()->GetRank() == 0)
{
cout << "L infinity error : " << vLinfError << endl;
cout << "L 2 error : " << vL2Error << endl;
cout << "Postprocessed L infinity error : " << LinfErrorPostProc << endl;
cout << "Postprocessed L 2 error : " << L2ErrorPostProc << endl;
}
vSession->Finalise();
return 0;
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
MultiRegions::DisContField3DSharedPtr Exp, Fce;
int i, nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
StdRegions::ConstFactorMap factors;
if(argc < 2)
{
fprintf(stderr,"Usage: HDGHelmholtz3D meshfile [solntype]\n");
exit(1);
}
LibUtilities::FieldIOSharedPtr fld = MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(vComm);
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph3D =
MemoryManager<SpatialDomains::MeshGraph3D>::AllocateSharedPtr(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
factors[StdRegions::eFactorLambda] = vSession->GetParameter("Lambda");
factors[StdRegions::eFactorTau] = 1.0;
const SpatialDomains::ExpansionMap &expansions = graph3D->GetExpansions();
LibUtilities::BasisKey bkey0
= expansions.begin()->second->m_basisKeyVector[0];
if (vComm->GetRank() == 0)
{
cout << "Solving 3D Helmholtz:" << endl;
cout << " - Communication: "
<< vSession->GetComm()->GetType() << " ("
<< vSession->GetComm()->GetSize()
<< " processes)" << endl;
cout << " - Solver type : "
<< vSession->GetSolverInfo("GlobalSysSoln") << endl;
cout << " - Lambda : "
<< factors[StdRegions::eFactorLambda] << endl;
cout << " - No. modes : "
<< bkey0.GetNumModes() << endl;
cout << endl;
}
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::DisContField3D>::
AllocateSharedPtr(vSession,graph3D,vSession->GetVariable(0));
//----------------------------------------------
Timing("Read files and define exp ..");
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
xc0 = Array<OneD,NekDouble>(nq,0.0);
xc1 = Array<OneD,NekDouble>(nq,0.0);
xc2 = Array<OneD,NekDouble>(nq,0.0);
switch(coordim)
{
case 1:
Exp->GetCoords(xc0);
break;
case 2:
Exp->GetCoords(xc0,xc1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
}
//----------------------------------------------
//----------------------------------------------
// Define forcing function for first variable defined in file
fce = Array<OneD,NekDouble>(nq);
LibUtilities::EquationSharedPtr ffunc = vSession->GetFunction("Forcing", 0);
ffunc->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::DisContField3D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
Timing("Define forcing ..");
//----------------------------------------------
// Helmholtz solution taking physical forcing
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
//----------------------------------------------
Timing("Helmholtz Solve ..");
#if 0
for(i = 0; i < 100; ++i)
{
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
}
Timing("100 Helmholtz Solves:... ");
#endif
//----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//----------------------------------------------
Timing("Backward Transform ..");
//-----------------------------------------------
// Write solution to file
string out = vSession->GetSessionName() + ".fld";
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back("u");
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
}
fld->Write(out, FieldDef, FieldData);
//-----------------------------------------------
//----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol =
vSession->GetFunction("ExactSolution", 0);
if(ex_sol)
{
//----------------------------------------------
// evaluate exact solution
ex_sol->Evaluate(xc0, xc1, xc2, fce);
//----------------------------------------------
//--------------------------------------------
// Calculate L_inf error
Fce->SetPhys(fce);
Fce->SetPhysState(true);
NekDouble vLinfError = Exp->Linf(Exp->GetPhys(), Fce->GetPhys());
NekDouble vL2Error = Exp->L2 (Exp->GetPhys(), Fce->GetPhys());
NekDouble vH1Error = Exp->H1 (Exp->GetPhys(), Fce->GetPhys());
if (vComm->GetRank() == 0)
{
cout << "L infinity error: " << vLinfError << endl;
cout << "L 2 error : " << vL2Error << endl;
cout << "H 1 error : " << vH1Error << endl;
}
//--------------------------------------------
}
Timing("Output ..");
//----------------------------------------------
vSession->Finalise();
return 0;
}
int main(int argc, char *argv[])
{
LibUtilities::SessionReaderSharedPtr vSession
= LibUtilities::SessionReader::CreateInstance(argc, argv);
LibUtilities::CommSharedPtr vComm = vSession->GetComm();
MultiRegions::ContField1DSharedPtr Exp,Fce;
int i, nq, coordim;
Array<OneD,NekDouble> fce;
Array<OneD,NekDouble> xc0,xc1,xc2;
StdRegions::ConstFactorMap factors;
if( (argc != 2) && (argc != 3) && (argc != 4))
{
fprintf(stderr,"Usage: Helmholtz1D meshfile \n");
exit(1);
}
try
{
LibUtilities::FieldIOSharedPtr fld =
MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr(vComm);
//----------------------------------------------
// Read in mesh from input file
SpatialDomains::MeshGraphSharedPtr graph1D =
SpatialDomains::MeshGraph::Read(vSession);
//----------------------------------------------
//----------------------------------------------
// Print summary of solution details
factors[StdRegions::eFactorLambda] = vSession->GetParameter("Lambda");
const SpatialDomains::ExpansionMap &expansions = graph1D->GetExpansions();
LibUtilities::BasisKey bkey0 = expansions.begin()->second->m_basisKeyVector[0];
if (vComm->GetRank() ==0)
{
cout << "Solving 1D Helmholtz: " << endl;
cout << " Communication: " << vComm->GetType() << endl;
cout << " Solver type : " << vSession->GetSolverInfo("GlobalSysSoln") << endl;
cout << " Lambda : " << factors[StdRegions::eFactorLambda] << endl;
cout << " No. modes : " << bkey0.GetNumModes() << endl;
}
//----------------------------------------------
//----------------------------------------------
// Define Expansion
Exp = MemoryManager<MultiRegions::ContField1D>::
AllocateSharedPtr(vSession,graph1D,vSession->GetVariable(0));
//----------------------------------------------
//----------------------------------------------
// Set up coordinates of mesh for Forcing function evaluation
coordim = Exp->GetCoordim(0);
nq = Exp->GetTotPoints();
xc0 = Array<OneD,NekDouble>(nq);
xc1 = Array<OneD,NekDouble>(nq);
xc2 = Array<OneD,NekDouble>(nq);
switch(coordim)
{
case 1:
Exp->GetCoords(xc0);
Vmath::Zero(nq,&xc1[0],1);
Vmath::Zero(nq,&xc2[0],1);
break;
case 2:
Exp->GetCoords(xc0,xc1);
Vmath::Zero(nq,&xc2[0],1);
break;
case 3:
Exp->GetCoords(xc0,xc1,xc2);
break;
}
//----------------------------------------------
//----------------------------------------------
// Define forcing function for first variable defined in file
fce = Array<OneD,NekDouble>(nq);
LibUtilities::EquationSharedPtr ffunc
= vSession->GetFunction("Forcing", 0);
ffunc->Evaluate(xc0,xc1,xc2, fce);
//----------------------------------------------
//----------------------------------------------
// Setup expansion containing the forcing function
Fce = MemoryManager<MultiRegions::ContField1D>::AllocateSharedPtr(*Exp);
Fce->SetPhys(fce);
//----------------------------------------------
//----------------------------------------------
//Helmholtz solution taking physical forcing after setting
//initial condition to zero
Vmath::Zero(Exp->GetNcoeffs(),Exp->UpdateCoeffs(),1);
Exp->HelmSolve(Fce->GetPhys(), Exp->UpdateCoeffs(), NullFlagList, factors);
//----------------------------------------------
//----------------------------------------------
// Backward Transform Solution to get solved values at
Exp->BwdTrans(Exp->GetCoeffs(), Exp->UpdatePhys());
//----------------------------------------------
//----------------------------------------------
// Write solution
string out(strtok(argv[1],"."));
string endfile(".fld");
out += endfile;
std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
= Exp->GetFieldDefinitions();
std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
for(i = 0; i < FieldDef.size(); ++i)
{
FieldDef[i]->m_fields.push_back("u");
Exp->AppendFieldData(FieldDef[i], FieldData[i]);
}
fld->Write(out, FieldDef, FieldData);
//----------------------------------------------
//----------------------------------------------
// See if there is an exact solution, if so
// evaluate and plot errors
LibUtilities::EquationSharedPtr ex_sol
= vSession->GetFunction("ExactSolution", 0);
if(ex_sol)
{
//----------------------------------------------
// evaluate exact solution
ex_sol->Evaluate(xc0,xc1,xc2, fce);
Fce->SetPhys(fce);
//----------------------------------------------
//--------------------------------------------
// Calculate errors
NekDouble vLinfError = Exp->Linf(Exp->GetPhys(), Fce->GetPhys());
NekDouble vL2Error = Exp->L2(Exp->GetPhys(), Fce->GetPhys());
NekDouble vH1Error = Exp->H1(Exp->GetPhys(), Fce->GetPhys());
if (vComm->GetRank() == 0)
{
cout << "L infinity error: " << vLinfError << endl;
cout << "L 2 error: " << vL2Error << endl;
cout << "H 1 error: " << vH1Error << endl;
}
//--------------------------------------------
}
//----------------------------------------------
}
catch (const std::runtime_error&)
{
cerr << "Caught exception." << endl;
return 1;
}
vComm->Finalise();
return 0;
}