/**
* @brief The function is used to return the next row by the SRF..
**/
AnyType lda_unnest::SRF_next(void *user_fctx, bool *is_last_call)
{
sr_ctx * ctx = (sr_ctx *) user_fctx;
if (ctx->maxcall == ctx->curcall) {
*is_last_call = true;
return Null();
}
MutableArrayHandle<int32_t> outarray(
madlib_construct_array(
NULL, ctx->dim, INT4TI.oid, INT4TI.len, INT4TI.byval,
INT4TI.align));
for (int i = 0; i < ctx->dim; i ++) {
outarray[i] = ctx->inarray[ctx->curcall * (ctx->dim + 1) + i];
}
ctx->curcall++;
*is_last_call = false;
return outarray;
}
/**
* @brief The function is used to return the next row by the SRF..
**/
AnyType lda_unnest::SRF_next(void *user_fctx, bool *is_last_call)
{
sr_ctx * ctx = (sr_ctx *) user_fctx;
if (ctx->maxcall == 0) {
*is_last_call = true;
return Null();
}
MutableArrayHandle<int64_t> outarray(
madlib_construct_array(
NULL, ctx->dim, INT8TI.oid, INT8TI.len, INT8TI.byval,
INT8TI.align));
memcpy(
outarray.ptr(), ctx->inarray + ctx->curcall * ctx->dim, ctx->dim *
sizeof(int64_t));
ctx->curcall++;
ctx->maxcall--;
*is_last_call = false;
return outarray;
}
void EigenValuesAdvection::v_DoSolve()
{
int nvariables = 1;
int i,dofs = GetNcoeffs();
//bool UseContCoeffs = false;
Array<OneD, Array<OneD, NekDouble> > inarray(nvariables);
Array<OneD, Array<OneD, NekDouble> > tmp(nvariables);
Array<OneD, Array<OneD, NekDouble> > outarray(nvariables);
Array<OneD, Array<OneD, NekDouble> > WeakAdv(nvariables);
int npoints = GetNpoints();
int ncoeffs = GetNcoeffs();
switch (m_projectionType)
{
case MultiRegions::eDiscontinuous:
{
dofs = ncoeffs;
break;
}
case MultiRegions::eGalerkin:
case MultiRegions::eMixed_CG_Discontinuous:
{
//dofs = GetContNcoeffs();
//UseContCoeffs = true;
break;
}
}
cout << endl;
cout << "Num Phys Points = " << npoints << endl; // phisical points
cout << "Num Coeffs = " << ncoeffs << endl; //
cout << "Num Cont Coeffs = " << dofs << endl;
inarray[0] = Array<OneD, NekDouble>(npoints,0.0);
outarray[0] = Array<OneD, NekDouble>(npoints,0.0);
tmp[0] = Array<OneD, NekDouble>(npoints,0.0);
WeakAdv[0] = Array<OneD, NekDouble>(ncoeffs,0.0);
Array<OneD, NekDouble> MATRIX(npoints*npoints,0.0);
for (int j = 0; j < npoints; j++)
{
inarray[0][j] = 1.0;
/// Feeding the weak Advection oprator with a vector (inarray)
/// Looping on inarray and changing the position of the only non-zero entry
/// we simulate the multiplication by the identity matrix.
/// The results stored in outarray is one of the columns of the weak advection oprators
/// which are then stored in MATRIX for the futher eigenvalues calculation.
switch (m_projectionType)
{
case MultiRegions::eDiscontinuous:
{
WeakDGAdvection(inarray, WeakAdv,true,true,1);
m_fields[0]->MultiplyByElmtInvMass(WeakAdv[0],WeakAdv[0]);
m_fields[0]->BwdTrans(WeakAdv[0],outarray[0]);
Vmath::Neg(npoints,outarray[0],1);
break;
}
case MultiRegions::eGalerkin:
case MultiRegions::eMixed_CG_Discontinuous:
{
// Calculate -V\cdot Grad(u);
for(i = 0; i < nvariables; ++i)
{
//Projection
m_fields[i]->FwdTrans(inarray[i],WeakAdv[i]);
m_fields[i]->BwdTrans_IterPerExp(WeakAdv[i],tmp[i]);
//Advection operator
AdvectionNonConservativeForm(m_velocity,tmp[i],outarray[i]);
Vmath::Neg(npoints,outarray[i],1);
//m_fields[i]->MultiplyByInvMassMatrix(WeakAdv[i],WeakAdv[i]);
//Projection
m_fields[i]->FwdTrans(outarray[i],WeakAdv[i]);
m_fields[i]->BwdTrans_IterPerExp(WeakAdv[i],outarray[i]);
}
break;
}
}
/// The result is stored in outarray (is the j-th columns of the weak advection operator).
/// We now store it in MATRIX(j)
Vmath::Vcopy(npoints,&(outarray[0][0]),1,&(MATRIX[j]),npoints);
/// Set the j-th entry of inarray back to zero
inarray[0][j] = 0.0;
}
////////////////////////////////////////////////////////////////////////////////
/// Calulating the eigenvalues of the weak advection operator stored in (MATRIX)
/// using Lapack routines
char jobvl = 'N';
char jobvr = 'N';
int info = 0, lwork = 3*npoints;
NekDouble dum;
Array<OneD, NekDouble> EIG_R(npoints);
Array<OneD, NekDouble> EIG_I(npoints);
Array<OneD, NekDouble> work(lwork);
Lapack::Dgeev(jobvl,jobvr,npoints,MATRIX.get(),npoints,EIG_R.get(),EIG_I.get(),&dum,1,&dum,1,&work[0],lwork,info);
////////////////////////////////////////////////////////
//Print Matrix
FILE *mFile;
mFile = fopen ("WeakAdvMatrix.txt","w");
for(int j = 0; j<npoints; j++)
{
for(int k = 0; k<npoints; k++)
{
fprintf(mFile,"%e ",MATRIX[j*npoints+k]);
}
fprintf(mFile,"\n");
}
fclose (mFile);
////////////////////////////////////////////////////////
//Output of the EigenValues
FILE *pFile;
pFile = fopen ("Eigenvalues.txt","w");
for(int j = 0; j<npoints; j++)
{
fprintf(pFile,"%e %e\n",EIG_R[j],EIG_I[j]);
}
fclose (pFile);
cout << "\nEigenvalues : " << endl;
for(int j = 0; j<npoints; j++)
{
cout << EIG_R[j] << "\t" << EIG_I[j] << endl;
}
cout << endl;
}
