1758 lines
54 KiB
C++
1758 lines
54 KiB
C++
|
|
//Diagonal Source Transfer Preconditioner
|
|
|
|
#include "DiagST.hpp"
|
|
|
|
DiagST::DiagST(SesquilinearForm * bf_, Array2D<double> & Pmllength_,
|
|
double omega_, Coefficient * ws_, int nrlayers_)
|
|
: Solver(2*bf_->FESpace()->GetTrueVSize(), 2*bf_->FESpace()->GetTrueVSize()),
|
|
bf(bf_), Pmllength(Pmllength_), omega(omega_), ws(ws_), nrlayers(nrlayers_)
|
|
{
|
|
Mesh * mesh = bf->FESpace()->GetMesh();
|
|
dim = mesh->Dimension();
|
|
|
|
// ----------------- Step 1 --------------------
|
|
// Introduce 2 layered partitios of the domain
|
|
//
|
|
int partition_kind;
|
|
|
|
// 1. Ovelapping partition with overlap = 2h
|
|
partition_kind = 2; // Non Overlapping partition
|
|
int nx=8;
|
|
int ny=1;
|
|
int nz=1;
|
|
ovlpnrlayers = 2;
|
|
povlp = new MeshPartition(mesh, partition_kind,nx,ny,nz,ovlpnrlayers);
|
|
nxyz[0] = povlp->nxyz[0];
|
|
nxyz[1] = povlp->nxyz[1];
|
|
nxyz[2] = povlp->nxyz[2];
|
|
nrpatch = povlp->nrpatch;
|
|
subdomains = povlp->subdomains;
|
|
|
|
//
|
|
// ----------------- Step 1a -------------------
|
|
// Save the partition for visualization
|
|
// SaveMeshPartition(povlp->patch_mesh, "output/mesh_ovlp.", "output/sol_ovlp.");
|
|
|
|
// // // ------------------Step 2 --------------------
|
|
// // // Construct the dof maps from subdomains to global (for the extended and not)
|
|
|
|
ovlp_prob = new DofMap(bf,povlp,nrlayers);
|
|
|
|
// ------------------Step 3 --------------------
|
|
// Assemble the PML Problem matrices and factor them
|
|
PmlMat.SetSize(nrpatch);
|
|
PmlMatInv.SetSize(nrpatch);
|
|
for (int ip=0; ip<nrpatch; ip++)
|
|
{
|
|
PmlMat[ip] = GetPmlSystemMatrix(ip);
|
|
PmlMatInv[ip] = new KLUSolver;
|
|
PmlMatInv[ip]->SetOperator(*PmlMat[ip]);
|
|
}
|
|
|
|
|
|
nsweeps = pow(2,dim);
|
|
sweeps.SetSize(nsweeps,dim);
|
|
// 2D
|
|
sweeps(0,0) = 1; sweeps(0,1) = 1;
|
|
sweeps(1,0) = -1; sweeps(1,1) = 1;
|
|
sweeps(2,0) = 1; sweeps(2,1) =-1;
|
|
sweeps(3,0) = -1; sweeps(3,1) =-1;
|
|
|
|
// Set up src arrays size
|
|
f_orig.SetSize(nrpatch);
|
|
f_transf.SetSize(nrpatch);
|
|
usol.SetSize(nrpatch);
|
|
|
|
|
|
// Construct a simple map used for directions of transfer
|
|
ConstructDirectionsMap();
|
|
for (int ip=0; ip<nrpatch; ip++)
|
|
{
|
|
int n = 2*ovlp_prob->fespaces[ip]->GetTrueVSize(); // (x 2 for complex )
|
|
int npml = 2*ovlp_prob->PmlFespaces[ip]->GetTrueVSize(); // (x 2 for complex )
|
|
f_orig[ip] = new Vector(n); *f_orig[ip] = 0.0;
|
|
f_transf[ip].SetSize(nsweeps);
|
|
usol[ip].SetSize(nsweeps);
|
|
for (int i=0;i<nsweeps; i++)
|
|
{
|
|
f_transf[ip][i] = new Vector(n);
|
|
usol[ip][i] = new Vector(npml);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
SparseMatrix * DiagST::GetPmlSystemMatrix(int ip)
|
|
{
|
|
double h = GetUniformMeshElementSize(ovlp_prob->PmlMeshes[ip]);
|
|
Array2D<double> length(dim,2);
|
|
length = h*(nrlayers);
|
|
|
|
CartesianPML pml(ovlp_prob->PmlMeshes[ip], length);
|
|
pml.SetOmega(omega);
|
|
|
|
Array <int> ess_tdof_list;
|
|
if (ovlp_prob->PmlMeshes[ip]->bdr_attributes.Size())
|
|
{
|
|
Array<int> ess_bdr(ovlp_prob->PmlMeshes[ip]->bdr_attributes.Max());
|
|
ess_bdr = 1;
|
|
ovlp_prob->PmlFespaces[ip]->GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
|
|
}
|
|
|
|
ConstantCoefficient one(1.0);
|
|
ConstantCoefficient sigma(-pow(omega, 2));
|
|
|
|
PmlMatrixCoefficient c1_re(dim,pml_detJ_JT_J_inv_Re,&pml);
|
|
PmlMatrixCoefficient c1_im(dim,pml_detJ_JT_J_inv_Im,&pml);
|
|
|
|
PmlCoefficient detJ_re(pml_detJ_Re,&pml);
|
|
PmlCoefficient detJ_im(pml_detJ_Im,&pml);
|
|
|
|
ProductCoefficient c2_re0(sigma, detJ_re);
|
|
ProductCoefficient c2_im0(sigma, detJ_im);
|
|
|
|
ProductCoefficient c2_re(c2_re0, *ws);
|
|
ProductCoefficient c2_im(c2_im0, *ws);
|
|
|
|
SesquilinearForm a(ovlp_prob->PmlFespaces[ip],ComplexOperator::HERMITIAN);
|
|
|
|
a.AddDomainIntegrator(new DiffusionIntegrator(c1_re),
|
|
new DiffusionIntegrator(c1_im));
|
|
a.AddDomainIntegrator(new MassIntegrator(c2_re),
|
|
new MassIntegrator(c2_im));
|
|
a.Assemble();
|
|
|
|
OperatorPtr Alocal;
|
|
a.FormSystemMatrix(ess_tdof_list,Alocal);
|
|
ComplexSparseMatrix * AZ_ext = Alocal.As<ComplexSparseMatrix>();
|
|
SparseMatrix * Mat = AZ_ext->GetSystemMatrix();
|
|
Mat->Threshold(0.0);
|
|
return Mat;
|
|
}
|
|
|
|
|
|
void DiagST::Mult(const Vector &r, Vector &z) const
|
|
{
|
|
// Step 0
|
|
// Restrict original sources to the patches
|
|
for (int ip=0; ip<nrpatch; ip++)
|
|
{
|
|
*f_orig[ip] = 0.0;
|
|
for (int i=0;i<nsweeps; i++)
|
|
{
|
|
*f_transf[ip][i] = 0.0;
|
|
*usol[ip][i] = 0.0;
|
|
}
|
|
}
|
|
for (int ip=0; ip<nrpatch; ip++)
|
|
{
|
|
Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
r.GetSubVector(*Dof2GlobalDof,*f_orig[ip]);
|
|
}
|
|
|
|
char vishost[] = "localhost";
|
|
int visport = 19916;
|
|
z = 0.0;
|
|
Vector znew(z);
|
|
Vector rnew(r);
|
|
Vector raux(r); raux = 0.0;
|
|
Vector z1(z);
|
|
Vector z2(z);
|
|
Vector z3(z);
|
|
Vector z4(z);
|
|
znew = 0.0;
|
|
|
|
// in 2D there are a total of 4 sweeps
|
|
// with nx + ny - 1 serial steps each
|
|
// --------------------------------------------
|
|
// Sweep in the direction (1,1)
|
|
// --------------------------------------------
|
|
int nx = nxyz[0];
|
|
int ny = nxyz[1];
|
|
|
|
int nsteps = nx + ny - 1;
|
|
// Sweep number
|
|
for (int l=0; l<4; l++)
|
|
{
|
|
for (int s = 0; s<nsteps; s++)
|
|
{
|
|
// the patches involved are the ones such that
|
|
// i+j = s
|
|
for (int i=0;i<nx; i++)
|
|
{
|
|
int j;
|
|
switch (l)
|
|
{
|
|
case 0: j = s-i; break;
|
|
case 1: j = s-nx+i+1; break;
|
|
case 2: j = nx+i-s-1; break;
|
|
default: j = nx+ny-i-s-2; break;
|
|
}
|
|
if (j<0 || j>=ny) continue;
|
|
|
|
// find patch id
|
|
Array<int> ij(2); ij[0] = i; ij[1]=j;
|
|
int ip = GetPatchId(ij);
|
|
|
|
// Solve the PML problem in patch ip with all sources
|
|
// Original and all transfered (maybe some of them)
|
|
Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
Array<int> * Dof2PmlDof = &ovlp_prob->Dof2PmlDof[ip];
|
|
int ndofs = Dof2GlobalDof->Size();
|
|
Vector sol_local(ndofs);
|
|
Vector res_local(ndofs); res_local = 0.0;
|
|
if (l==0) res_local += *f_orig[ip];
|
|
|
|
res_local += *f_transf[ip][l];
|
|
// if (res_local.Norml2() < 1e-12) continue;
|
|
// Extend by zero to the PML mesh
|
|
int nrdof_ext = PmlMat[ip]->Height();
|
|
Vector res_ext(nrdof_ext); res_ext = 0.0;
|
|
Vector sol_ext(nrdof_ext); sol_ext = 0.0;
|
|
|
|
res_ext.SetSubVector(*Dof2PmlDof,res_local);
|
|
PmlMatInv[ip]->Mult(res_ext, sol_ext);
|
|
// Multiply with the cutoff functions, find the new sources and
|
|
// and propagate to all neighboring subdomains
|
|
// (possible 8 in 2D, 26 in 3D)
|
|
TransferSources(l,ip, sol_ext);
|
|
Vector cfsol_ext(sol_ext.Size());
|
|
|
|
// cut off the ip solution to all possible directions
|
|
Array<int>directions(2); directions = 0;
|
|
|
|
// switch (l)
|
|
// {
|
|
// case 0:
|
|
if (i+1<nx) directions[0] = 1;
|
|
if (j+1<ny) directions[1] = 1;
|
|
// break;
|
|
// case 1:
|
|
// if (i>0) directions[0] = -1;
|
|
// if (j+1<ny) directions[1] = 1;
|
|
|
|
// break;
|
|
// case 2:
|
|
// if (i+1<nx) directions[0] = 1;
|
|
// if (j>0) directions[1] = -1;
|
|
// break;
|
|
// default:
|
|
// if (i>0) directions[0] = -1;
|
|
// if (j>0) directions[1] = -1;
|
|
// break;
|
|
// }
|
|
|
|
GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,ovlpnrlayers,true);
|
|
sol_ext = cfsol_ext;
|
|
directions = 0.0;
|
|
if (i>0) directions[0] = -1;
|
|
if (j>0) directions[1] = -1;
|
|
GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,ovlpnrlayers,true);
|
|
cfsol_ext.GetSubVector(*Dof2PmlDof, sol_local);
|
|
znew = 0.0;
|
|
znew.SetSubVector(*Dof2GlobalDof, sol_local);
|
|
z+=znew;
|
|
socketstream zsock(vishost, visport);
|
|
PlotSolution(z,zsock,0); cin.get();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DiagST::PlotSolution(Vector & sol, socketstream & sol_sock, int ip) const
|
|
{
|
|
FiniteElementSpace * fespace = bf->FESpace();
|
|
Mesh * mesh = fespace->GetMesh();
|
|
GridFunction gf(fespace);
|
|
double * data = sol.GetData();
|
|
// gf.SetData(&data[fespace->GetTrueVSize()]);
|
|
gf.SetData(data);
|
|
|
|
string keys;
|
|
if (ip == 0) keys = "keys mrRljc\n";
|
|
sol_sock << "solution\n" << *mesh << gf << keys << "valuerange -0.1 0.1 \n" << flush;
|
|
// sol_sock << "solution\n" << *mesh << gf << keys << flush;
|
|
}
|
|
|
|
void DiagST::GetCutOffSolution(const Vector & sol, Vector & cfsol,
|
|
int ip, Array<int> directions, int ovlpnlayers, bool local) const
|
|
{
|
|
// int l,k;
|
|
int d = directions.Size();
|
|
int directx = directions[0]; // 1,0,-1
|
|
int directy = directions[1]; // 1,0,-1
|
|
int directz;
|
|
if (d ==3) directz = directions[2];
|
|
|
|
Mesh * mesh = ovlp_prob->fespaces[ip]->GetMesh();
|
|
|
|
Vector pmin, pmax;
|
|
mesh->GetBoundingBox(pmin, pmax);
|
|
double h = GetUniformMeshElementSize(mesh);
|
|
|
|
Array2D<double> pmlh(dim,2); pmlh = 0.0;
|
|
|
|
if (directions[0]==1)
|
|
{
|
|
pmlh[0][1] = h*ovlpnlayers;
|
|
}
|
|
if (directions[0]==-1)
|
|
{
|
|
pmlh[0][0] = h*ovlpnlayers;
|
|
}
|
|
if (directions[1]==1)
|
|
{
|
|
pmlh[1][1] = h*ovlpnlayers;
|
|
}
|
|
if (directions[1]==-1)
|
|
{
|
|
pmlh[1][0] = h*ovlpnlayers;
|
|
}
|
|
|
|
CutOffFnCoefficient cf(CutOffFncn, pmin, pmax, pmlh);
|
|
|
|
double * data = sol.GetData();
|
|
|
|
FiniteElementSpace * fespace;
|
|
if (!local)
|
|
{
|
|
fespace = bf->FESpace();
|
|
}
|
|
else
|
|
{
|
|
fespace = ovlp_prob->PmlFespaces[ip];
|
|
}
|
|
|
|
int n = fespace->GetTrueVSize();
|
|
|
|
GridFunction solgf_re(fespace, data);
|
|
GridFunction solgf_im(fespace, &data[n]);
|
|
|
|
GridFunctionCoefficient coeff1_re(&solgf_re);
|
|
GridFunctionCoefficient coeff1_im(&solgf_im);
|
|
|
|
ProductCoefficient prod_re(coeff1_re, cf);
|
|
ProductCoefficient prod_im(coeff1_im, cf);
|
|
|
|
ComplexGridFunction gf(fespace);
|
|
gf.ProjectCoefficient(prod_re,prod_im);
|
|
|
|
cfsol.SetSize(sol.Size());
|
|
cfsol = gf;
|
|
}
|
|
|
|
|
|
void DiagST::GetChiRes(const Vector & res, Vector & cfres,
|
|
int ip, Array<int> directions, int nlayers) const
|
|
{
|
|
// int l,k;
|
|
int d = directions.Size();
|
|
int directx = directions[0]; // 1,0,-1
|
|
int directy = directions[1]; // 1,0,-1
|
|
int directz;
|
|
if (d ==3) directz = directions[2];
|
|
|
|
Mesh * mesh = ovlp_prob->fespaces[ip]->GetMesh();
|
|
double h = GetUniformMeshElementSize(mesh);
|
|
|
|
Vector pmin, pmax;
|
|
mesh->GetBoundingBox(pmin, pmax);
|
|
|
|
Array2D<double> pmlh(dim,2); pmlh = 0.0;
|
|
|
|
if (directions[0]==1)
|
|
{
|
|
pmlh[0][1] = h*nlayers;
|
|
}
|
|
if (directions[0]==-1)
|
|
{
|
|
pmlh[0][0] = h*nlayers;
|
|
}
|
|
if (directions[1]==1)
|
|
{
|
|
pmlh[1][1] = h*nlayers;
|
|
}
|
|
if (directions[1]==-1)
|
|
{
|
|
pmlh[1][0] = h*nlayers;
|
|
}
|
|
|
|
CutOffFnCoefficient cf(CutOffFncn, pmin, pmax, pmlh);
|
|
|
|
double * data = res.GetData();
|
|
|
|
FiniteElementSpace * fespace;
|
|
fespace = ovlp_prob->PmlFespaces[ip];
|
|
|
|
int n = fespace->GetTrueVSize();
|
|
|
|
GridFunction solgf_re(fespace, data);
|
|
GridFunction solgf_im(fespace, &data[n]);
|
|
|
|
GridFunctionCoefficient coeff1_re(&solgf_re);
|
|
GridFunctionCoefficient coeff1_im(&solgf_im);
|
|
|
|
ProductCoefficient prod_re(coeff1_re, cf);
|
|
ProductCoefficient prod_im(coeff1_im, cf);
|
|
|
|
ComplexGridFunction gf(fespace);
|
|
gf.ProjectCoefficient(prod_re,prod_im);
|
|
|
|
cfres.SetSize(res.Size());
|
|
cfres = gf;
|
|
}
|
|
|
|
DiagST::~DiagST()
|
|
{
|
|
for (int ip = 0; ip<nrpatch; ++ip)
|
|
{
|
|
delete PmlMatInv[ip];
|
|
delete PmlMat[ip];
|
|
}
|
|
PmlMat.DeleteAll();
|
|
PmlMatInv.DeleteAll();
|
|
for (int ip=0; ip<nrpatch; ip++)
|
|
{
|
|
delete f_orig[ip];
|
|
for (int i=0;i<nsweeps; i++)
|
|
{
|
|
delete f_transf[ip][i];
|
|
}
|
|
}
|
|
}
|
|
|
|
void DiagST::Getijk(int ip, int & i, int & j, int & k) const
|
|
{
|
|
k = ip/(nxyz[0]*nxyz[1]);
|
|
j = (ip-k*nxyz[0]*nxyz[1])/nxyz[0];
|
|
i = (ip-k*nxyz[0]*nxyz[1])%nxyz[0];
|
|
}
|
|
|
|
int DiagST::GetPatchId(const Array<int> & ijk) const
|
|
{
|
|
int d=ijk.Size();
|
|
if (d==2)
|
|
{
|
|
return subdomains(ijk[0],ijk[1],0);
|
|
}
|
|
else
|
|
{
|
|
return subdomains(ijk[0],ijk[1],ijk[2]);
|
|
}
|
|
}
|
|
|
|
int DiagST::SourceTransfer(const Vector & Psi0, Array<int> direction, int ip0, Vector & Psi1) const
|
|
{
|
|
// For now 2D problems only
|
|
// Directions
|
|
// direction (1,1)
|
|
int i0,j0,k0;
|
|
Getijk(ip0,i0,j0,k0);
|
|
|
|
int i1 = i0+direction[0];
|
|
int j1 = j0+direction[1];
|
|
Array<int> ij(2); ij[0]=i1; ij[1]=j1;
|
|
int ip1 = GetPatchId(ij);
|
|
|
|
MFEM_VERIFY(i1 < nxyz[0] && i1>=0, "SourceTransfer: i1 out of bounds");
|
|
MFEM_VERIFY(j1 < nxyz[1] && j1>=0, "SourceTransfer: j1 out of bounds");
|
|
|
|
Array<int> * Dof2GlobalDof0 = &ovlp_prob->Dof2GlobalDof[ip0];
|
|
Array<int> * Dof2GlobalDof1 = &ovlp_prob->Dof2GlobalDof[ip1];
|
|
Psi1.SetSize(Dof2GlobalDof1->Size()); Psi1=0.0;
|
|
Vector r(2*bf->FESpace()->GetTrueVSize());
|
|
r = 0.0;
|
|
r.SetSubVector(*Dof2GlobalDof0,Psi0);
|
|
|
|
// if (direction[0] == 1 && direction[1] == 1)
|
|
// {
|
|
// Vector zloc(Psi1.Size());
|
|
// r.GetSubVector(*Dof2GlobalDof1,zloc);
|
|
// // extend
|
|
// Vector psi_ext(PmlMat[ip1]->Height());
|
|
// Vector zloc_ext(PmlMat[ip1]->Height());
|
|
// Array<int> * Dof2PmlDof1 = &ovlp_prob->Dof2PmlDof[ip1];
|
|
// zloc_ext.SetSubVector(*Dof2PmlDof1,zloc);
|
|
// PmlMat[ip1]->Mult(zloc_ext,psi_ext);
|
|
// psi_ext *=-1.0;
|
|
// psi_ext.GetSubVector(*Dof2PmlDof1,Psi1);
|
|
// // }
|
|
// else
|
|
// {
|
|
r.GetSubVector(*Dof2GlobalDof1,Psi1);
|
|
// }
|
|
return ip1;
|
|
}
|
|
|
|
void DiagST::ConstructDirectionsMap()
|
|
{
|
|
// total of 8 possible directions of transfer (2D)
|
|
// form left ( 1 , 0)
|
|
// form left-above ( 1 , -1)
|
|
// form left-below ( 1 , 1)
|
|
// form right (-1 , 0)
|
|
// form right-below (-1 , 1)
|
|
// form right-above (-1 , -1)
|
|
// form above ( 0 , -1)
|
|
// form below ( 0 , 1)
|
|
ntransf_directions = pow(3,dim);
|
|
|
|
dirx.SetSize(ntransf_directions);
|
|
diry.SetSize(ntransf_directions);
|
|
int n=3;
|
|
Array<int> ijk(dim);
|
|
if (dim==2)
|
|
{
|
|
for (int i=-1; i<=1; i++) // directions x
|
|
{
|
|
for (int j=-1; j<=1; j++) // directions y
|
|
{
|
|
ijk[0]=i;
|
|
ijk[1]=j;
|
|
int k=GetDirectionId(ijk);
|
|
dirx[k]=i;
|
|
diry[k]=j;
|
|
}
|
|
}
|
|
}
|
|
else if (dim==3)
|
|
{
|
|
dirz.SetSize(ntransf_directions);
|
|
for (int i=-1; i<=1; i++) // directions x
|
|
{
|
|
for (int j=-1; j<=1; j++) // directions y
|
|
{
|
|
for (int k=-1; k<=1; k++) // directions zß
|
|
{
|
|
ijk[0]=i;
|
|
ijk[1]=j;
|
|
ijk[2]=k;
|
|
int l=GetDirectionId(ijk);
|
|
dirx[l]=i;
|
|
diry[l]=j;
|
|
dirz[l]=k;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// cout << "dirx = " << endl;
|
|
// dirx.Print(cout,ntransf_directions);
|
|
// cout << "diry = " << endl;
|
|
// diry.Print(cout,ntransf_directions);
|
|
|
|
// if (dim==2)
|
|
// {
|
|
// for (int id=0; id<9; id++)
|
|
// {
|
|
// GetDirectionijk(id,ijk);
|
|
// // cout << "for id = " << id << ": (" <<ijk[0] << ", " << ijk[1] << ")" << endl;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// cout << "dirz = " << endl;
|
|
// dirz.Print(cout,ntransf_directions);
|
|
// for (int id=0; id<27; id++)
|
|
// {
|
|
// GetDirectionijk(id,ijk);
|
|
// // cout << "for id = " << id << ": (" <<ijk[0] << ", " <<ijk[1] << ", " << ijk[2] << ")" << endl;
|
|
// }
|
|
// }
|
|
}
|
|
|
|
int DiagST::GetDirectionId(const Array<int> & ijk) const
|
|
{
|
|
int d = ijk.Size();
|
|
int n=3;
|
|
if (d==2)
|
|
{
|
|
return (ijk[0]+1)*n+(ijk[1]+1);
|
|
}
|
|
else
|
|
{
|
|
return (ijk[0]+1)*n*n+(ijk[1]+1)*n+ijk[2]+1;
|
|
}
|
|
}
|
|
|
|
void DiagST::GetDirectionijk(int id, Array<int> & ijk) const
|
|
{
|
|
int d = ijk.Size();
|
|
int n=3;
|
|
if (d==2)
|
|
{
|
|
ijk[0]=id/n - 1;
|
|
ijk[1]=id%n - 1;
|
|
}
|
|
else
|
|
{
|
|
ijk[0]=id/(n*n)-1;
|
|
ijk[1]=(id-(ijk[0]+1)*n*n)/n - 1;
|
|
ijk[2]=(id-(ijk[0]+1)*n*n)%n - 1;
|
|
}
|
|
// cout << "ijk = " ; ijk.Print();
|
|
}
|
|
|
|
|
|
|
|
|
|
void DiagST::TransferSources(int sweep, int ip0, Vector & sol_ext) const
|
|
{
|
|
// Find all neighbors of patch ip
|
|
int nx = nxyz[0];
|
|
int ny = nxyz[1];
|
|
int i0, j0, k0;
|
|
Getijk(ip0, i0,j0,k0);
|
|
// cout << "Transfer to : " << endl;
|
|
// loop through possible directions
|
|
for (int i=-1; i<2; i++)
|
|
{
|
|
int i1 = i0 + i;
|
|
if (i1 <0 || i1>=nx) continue;
|
|
for (int j=-1; j<2; j++)
|
|
{
|
|
if (i==0 && j==0) continue;
|
|
int j1 = j0 + j;
|
|
if (j1 <0 || j1>=ny) continue;
|
|
// cout << "(" << i1 << "," << j1 <<"), ";
|
|
// Find ip 1
|
|
Array<int> ij1(2); ij1[0] = i1; ij1[1]=j1;
|
|
int ip1 = GetPatchId(ij1);
|
|
// cout << "ip1 = " << ip1;
|
|
// cout << " in the direction of (" << i <<", " <<j <<")" << endl;
|
|
Array<int> directions(2);
|
|
directions[0] = i;
|
|
directions[1] = j;
|
|
Vector cfsol_ext;
|
|
Vector res_ext(sol_ext.Size());
|
|
GetCutOffSolution(sol_ext,cfsol_ext,ip0,directions,ovlpnrlayers,true);
|
|
// sol_ext = cfsol_ext;
|
|
PmlMat[ip0]->Mult(cfsol_ext, res_ext);
|
|
|
|
//---------------------------------------
|
|
// FiniteElementSpace * fes = ovlp_prob->PmlFespaces[ip0];
|
|
// Mesh * mesh = fes->GetMesh();
|
|
// GridFunction gf(fes);
|
|
// double * data = res_ext.GetData();
|
|
// // gf.SetData(&data[fespace->GetTrueVSize()]);
|
|
// gf.SetData(data);
|
|
// char vishost[] = "localhost";
|
|
// int visport = 19916;
|
|
// socketstream pmlsock(vishost, visport);
|
|
|
|
// string keys;
|
|
// keys = "keys mrRljc\n";
|
|
// pmlsock << "solution\n" << *mesh << gf << keys << "valuerange -0.1 0.1 \n" << flush;
|
|
// // sol_sock << "solution\n" << *mesh << gf << keys << flush;
|
|
// cin.get();
|
|
//---------------------------------------
|
|
|
|
|
|
|
|
res_ext*= -1.0;
|
|
Array<int> *Dof2PmlDof = &ovlp_prob->Dof2PmlDof[ip0];
|
|
Vector res_local(Dof2PmlDof->Size()); res_local = 0.0;
|
|
res_ext.GetSubVector(*Dof2PmlDof,res_local);
|
|
|
|
|
|
// Vector sol_local(Dof2PmlDof->Size()); sol_local = 0.0;
|
|
// cfsol_ext.GetSubVector(*Dof2PmlDof,sol_local);
|
|
// Vector znew(A->Height()); znew = 0.0;
|
|
// Vector rnew(A->Height()); rnew = 0.0;
|
|
// Array<int> *Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip0];
|
|
// znew.SetSubVector(*Dof2GlobalDof,sol_local);
|
|
// A->Mult(znew,rnew); rnew *=-1.0;
|
|
// rnew.GetSubVector(*Dof2GlobalDof, res_local);
|
|
|
|
//-----------------------------
|
|
// pass to ip1 and calculate residual there
|
|
// Vector sol_local(Dof2PmlDof->Size()); sol_local = 0.0;
|
|
// cfsol_ext.GetSubVector(*Dof2PmlDof,sol_local);
|
|
//-----------------------------
|
|
|
|
|
|
|
|
|
|
|
|
// Find the minumum sweep number that to transfer the source that
|
|
// satisfies the two rules
|
|
for (int l=sweep; l<nsweeps; l++)
|
|
{
|
|
// Conditions on sweeps
|
|
// Rule 1: the transfer source direction has to be similar with
|
|
// the sweep direction
|
|
int is = sweeps(l,0);
|
|
int js = sweeps(l,1);
|
|
int ddot = is*i + js * j;
|
|
// cout << "(i,j) = (" << i <<"," <<j <<")" << endl;
|
|
// cout << "(is,js) = (" << is <<"," <<js <<")" << endl;
|
|
// cout << "ip0 , ip1 = " << ip0 << ", " << ip1 << endl;
|
|
if (ddot <= 0) continue;
|
|
|
|
// Rule 2: The horizontal or vertical transfer source cannot be used
|
|
// in a later sweep that with opposite directions
|
|
|
|
if (i==0 || j == 0) // Case of horizontal or vertical transfer source
|
|
{
|
|
int il = sweeps(l,0);
|
|
int jl = sweeps(l,1);
|
|
// skip if the two sweeps have opposite direction
|
|
if (is == -il && js == -jl) continue;
|
|
}
|
|
// cout << "Passing ip0 = " << ip0 << " to ip1 = " << ip1
|
|
// << " to sweep no l = " << l << endl;
|
|
Vector raux;
|
|
// if (directions[0] == 1 && directions[1] == 1)
|
|
// {
|
|
// res_local = sol_local;
|
|
// }
|
|
// cout << res_local.Norml2() << endl;
|
|
|
|
int jp1 = SourceTransfer(res_local,directions,ip0,raux);
|
|
MFEM_VERIFY(ip1 == jp1, "Check SourceTransfer patch id");
|
|
MFEM_VERIFY(f_transf[ip1][l]->Size()==raux.Size(),
|
|
"Transfer Sources: inconsistent size");
|
|
*f_transf[ip1][l]+=raux;
|
|
|
|
|
|
// FiniteElementSpace * fes1 = ovlp_prob->fespaces[ip1];
|
|
// Mesh * mesh1 = fes1->GetMesh();
|
|
// GridFunction gf1(fes1);
|
|
// double * data1 = raux.GetData();
|
|
// gf1.SetData(data1);
|
|
// socketstream sock(vishost, visport);
|
|
// sock << "solution\n" << *mesh1 << gf1 << keys << "valuerange -0.1 0.1 \n" << flush;
|
|
// // sol_sock << "solution\n" << *mesh << gf << keys << flush;
|
|
// cin.get();
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// //Diagonal Source Transfer Preconditioner
|
|
|
|
// #include "DiagST.hpp"
|
|
|
|
// DiagST::DiagST(SesquilinearForm * bf_, Array2D<double> & Pmllength_,
|
|
// double omega_, Coefficient * ws_, int nrlayers_)
|
|
// : Solver(2*bf_->FESpace()->GetTrueVSize(), 2*bf_->FESpace()->GetTrueVSize()),
|
|
// bf(bf_), Pmllength(Pmllength_), omega(omega_), ws(ws_), nrlayers(nrlayers_)
|
|
// {
|
|
// Mesh * mesh = bf->FESpace()->GetMesh();
|
|
// dim = mesh->Dimension();
|
|
|
|
// // ----------------- Step 1 --------------------
|
|
// // Introduce 2 layered partitios of the domain
|
|
// //
|
|
// int partition_kind;
|
|
|
|
// // 1. Ovelapping partition with overlap = 2h
|
|
// partition_kind = 2; // Non Overlapping partition
|
|
// int nx=2;
|
|
// int ny=2;
|
|
// int nz=1;
|
|
// povlp = new MeshPartition(mesh, partition_kind,nx,ny,nz,2);
|
|
// nxyz[0] = povlp->nxyz[0];
|
|
// nxyz[1] = povlp->nxyz[1];
|
|
// nxyz[2] = povlp->nxyz[2];
|
|
// nrpatch = povlp->nrpatch;
|
|
// subdomains = povlp->subdomains;
|
|
|
|
// //
|
|
// // ----------------- Step 1a -------------------
|
|
// // Save the partition for visualization
|
|
// // SaveMeshPartition(povlp->patch_mesh, "output/mesh_ovlp.", "output/sol_ovlp.");
|
|
|
|
// // // // ------------------Step 2 --------------------
|
|
// // // // Construct the dof maps from subdomains to global (for the extended and not)
|
|
|
|
// ovlp_prob = new DofMap(bf,povlp,nrlayers);
|
|
|
|
// // ------------------Step 3 --------------------
|
|
// // Assemble the PML Problem matrices and factor them
|
|
// PmlMat.SetSize(nrpatch);
|
|
// PmlMatInv.SetSize(nrpatch);
|
|
// for (int ip=0; ip<nrpatch; ip++)
|
|
// {
|
|
// PmlMat[ip] = GetPmlSystemMatrix(ip);
|
|
// PmlMatInv[ip] = new KLUSolver;
|
|
// PmlMatInv[ip]->SetOperator(*PmlMat[ip]);
|
|
// }
|
|
|
|
|
|
// nsweeps = pow(2,dim);
|
|
// sweeps.SetSize(nsweeps,dim);
|
|
// // 2D
|
|
// sweeps(0,0) = 1; sweeps(0,1) = 1;
|
|
// sweeps(1,0) = -1; sweeps(1,1) = 1;
|
|
// sweeps(2,0) = 1; sweeps(2,1) =-1;
|
|
// sweeps(3,0) = -1; sweeps(3,1) =-1;
|
|
|
|
// // Set up src arrays size
|
|
// f_orig.SetSize(nrpatch);
|
|
// f_transf.SetSize(nrpatch);
|
|
// usol.SetSize(nrpatch);
|
|
|
|
|
|
// // Construct a simple map used for directions of transfer
|
|
// ConstructDirectionsMap();
|
|
// for (int ip=0; ip<nrpatch; ip++)
|
|
// {
|
|
// int n = 2*ovlp_prob->fespaces[ip]->GetTrueVSize(); // (x 2 for complex )
|
|
// int npml = 2*ovlp_prob->PmlFespaces[ip]->GetTrueVSize(); // (x 2 for complex )
|
|
// f_orig[ip] = new Vector(n); *f_orig[ip] = 0.0;
|
|
// f_transf[ip].SetSize(nsweeps);
|
|
// usol[ip].SetSize(nsweeps);
|
|
// for (int i=0;i<nsweeps; i++)
|
|
// {
|
|
// f_transf[ip][i] = new Vector(n);
|
|
// usol[ip][i] = new Vector(npml);
|
|
// }
|
|
// }
|
|
|
|
// }
|
|
|
|
// SparseMatrix * DiagST::GetPmlSystemMatrix(int ip)
|
|
// {
|
|
// double h = GetUniformMeshElementSize(ovlp_prob->PmlMeshes[ip]);
|
|
// Array2D<double> length(dim,2);
|
|
// length = h*(nrlayers);
|
|
|
|
// CartesianPML pml(ovlp_prob->PmlMeshes[ip], length);
|
|
// pml.SetOmega(omega);
|
|
|
|
// Array <int> ess_tdof_list;
|
|
// if (ovlp_prob->PmlMeshes[ip]->bdr_attributes.Size())
|
|
// {
|
|
// Array<int> ess_bdr(ovlp_prob->PmlMeshes[ip]->bdr_attributes.Max());
|
|
// ess_bdr = 1;
|
|
// ovlp_prob->PmlFespaces[ip]->GetEssentialTrueDofs(ess_bdr, ess_tdof_list);
|
|
// }
|
|
|
|
// ConstantCoefficient one(1.0);
|
|
// ConstantCoefficient sigma(-pow(omega, 2));
|
|
|
|
// PmlMatrixCoefficient c1_re(dim,pml_detJ_JT_J_inv_Re,&pml);
|
|
// PmlMatrixCoefficient c1_im(dim,pml_detJ_JT_J_inv_Im,&pml);
|
|
|
|
// PmlCoefficient detJ_re(pml_detJ_Re,&pml);
|
|
// PmlCoefficient detJ_im(pml_detJ_Im,&pml);
|
|
|
|
// ProductCoefficient c2_re0(sigma, detJ_re);
|
|
// ProductCoefficient c2_im0(sigma, detJ_im);
|
|
|
|
// ProductCoefficient c2_re(c2_re0, *ws);
|
|
// ProductCoefficient c2_im(c2_im0, *ws);
|
|
|
|
// SesquilinearForm a(ovlp_prob->PmlFespaces[ip],ComplexOperator::HERMITIAN);
|
|
|
|
// a.AddDomainIntegrator(new DiffusionIntegrator(c1_re),
|
|
// new DiffusionIntegrator(c1_im));
|
|
// a.AddDomainIntegrator(new MassIntegrator(c2_re),
|
|
// new MassIntegrator(c2_im));
|
|
// a.Assemble();
|
|
|
|
// OperatorPtr Alocal;
|
|
// a.FormSystemMatrix(ess_tdof_list,Alocal);
|
|
// ComplexSparseMatrix * AZ_ext = Alocal.As<ComplexSparseMatrix>();
|
|
// SparseMatrix * Mat = AZ_ext->GetSystemMatrix();
|
|
// Mat->Threshold(0.0);
|
|
// return Mat;
|
|
// }
|
|
|
|
|
|
// void DiagST::Mult(const Vector &r, Vector &z) const
|
|
// {
|
|
// // Step 0
|
|
// // Restrict original sources to the patches
|
|
// for (int ip=0; ip<nrpatch; ip++)
|
|
// {
|
|
// *f_orig[ip] = 0.0;
|
|
// for (int i=0;i<nsweeps; i++)
|
|
// {
|
|
// *f_transf[ip][i] = 0.0;
|
|
// *usol[ip][i] = 0.0;
|
|
// }
|
|
// }
|
|
// for (int ip=0; ip<nrpatch; ip++)
|
|
// {
|
|
// Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// r.GetSubVector(*Dof2GlobalDof,*f_orig[ip]);
|
|
// }
|
|
|
|
// char vishost[] = "localhost";
|
|
// int visport = 19916;
|
|
// z = 0.0;
|
|
// Vector znew(z);
|
|
// Vector rnew(r);
|
|
// Vector raux(r); raux = 0.0;
|
|
// Vector z1(z);
|
|
// Vector z2(z);
|
|
// Vector z3(z);
|
|
// Vector z4(z);
|
|
// znew = 0.0;
|
|
|
|
// // in 2D there are a total of 4 sweeps
|
|
// // with nx + ny - 1 serial steps each
|
|
// // --------------------------------------------
|
|
// // Sweep in the direction (1,1)
|
|
// // --------------------------------------------
|
|
// int nx = nxyz[0];
|
|
// int ny = nxyz[1];
|
|
|
|
// int nsteps = nx + ny - 1;
|
|
// // Sweep number
|
|
// for (int l=0; l<1; l++)
|
|
// {
|
|
// for (int s = 0; s<nsteps; s++)
|
|
// {
|
|
// // the patches involved are the ones such that
|
|
// // i+j = s
|
|
// for (int i=0;i<nx; i++)
|
|
// {
|
|
// int j = s-i;
|
|
// if (j<0 || j>=ny) continue;
|
|
|
|
// // find patch id
|
|
// Array<int> ij(2); ij[0] = i; ij[1]=j;
|
|
// int ip = GetPatchId(ij);
|
|
|
|
// // Solve the PML problem in patch ip with all sources
|
|
// // Original and all transfered (maybe some of them)
|
|
// Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// Array<int> * Dof2PmlDof = &ovlp_prob->Dof2PmlDof[ip];
|
|
// int ndofs = Dof2GlobalDof->Size();
|
|
// Vector sol_local(ndofs);
|
|
// Vector res_local(ndofs);
|
|
// res_local = *f_orig[ip];
|
|
|
|
// res_local += *f_transf[ip][l];
|
|
// // Extend by zero to the PML mesh
|
|
// int nrdof_ext = PmlMat[ip]->Height();
|
|
|
|
// Vector res_ext(nrdof_ext); res_ext = 0.0;
|
|
// Vector sol_ext(nrdof_ext); sol_ext = 0.0;
|
|
|
|
// res_ext.SetSubVector(*Dof2PmlDof,res_local);
|
|
// PmlMatInv[ip]->Mult(res_ext, sol_ext);
|
|
// // *usol[l][ip] = sol_ext;
|
|
// // Multiply with the cutoff functions, find the new sources and
|
|
// // and propagate to all neighboring subdomains
|
|
// // (possible 8 in 2D, 26 in 3D)
|
|
// TransferSources(l,ip, sol_ext);
|
|
// Vector cfsol_ext(sol_ext.Size());
|
|
|
|
// // cut off the ip solution to all possible directions
|
|
// Array<int>directions(2); directions = 0;
|
|
// if (i+1<nx) directions[0] = 1;
|
|
// if (j+1<ny) directions[1] = 1;
|
|
// GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
// // sol_ext = cfsol_ext;
|
|
// // directions = 0.0;
|
|
// // if (i>0) directions[0] = -1;
|
|
// // if (j>0) directions[1] = -1;
|
|
// // GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
// cfsol_ext.GetSubVector(*Dof2PmlDof, sol_local);
|
|
// znew = 0.0;
|
|
// znew.SetSubVector(*Dof2GlobalDof, sol_local);
|
|
// // z1.AddElementVector(*Dof2GlobalDof, sol_local);
|
|
// z1+=znew;
|
|
// socketstream sub1_sock1(vishost, visport);
|
|
// PlotSolution(z1,sub1_sock1,0); cin.get();
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// // PlotSolution(z1,sub_sock1, 0);
|
|
// // cin.get();
|
|
|
|
// z +=z1;
|
|
// // A->Mult(z,raux); rnew = r; rnew -=raux;
|
|
|
|
// // for (int ip=0; ip<nrpatch; ip++)
|
|
// // {
|
|
// // *f_orig[ip] = 0.0;
|
|
// // for (int i=0;i<nsweeps; i++)
|
|
// // {
|
|
// // *f_transf[ip][i] = 0.0;
|
|
// // }
|
|
// // }
|
|
// // for (int ip=0; ip<nrpatch; ip++)
|
|
// // {
|
|
// // Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// // rnew.GetSubVector(*Dof2GlobalDof,*f_orig[ip]);
|
|
// // }
|
|
|
|
|
|
// // for (int l=1; l<2; l++)
|
|
// // {
|
|
// // for (int s = 0; s<nsteps; s++)
|
|
// // {
|
|
// // // the patches involved are the ones such that
|
|
// // // i+j = s
|
|
// // // cout << "Step no: " << s << endl;
|
|
// // for (int i=0;i<nx; i++)
|
|
// // {
|
|
// // int j = s-nx+i+1;
|
|
// // // cout << "1:Patch no: (" << i <<"," << j << ")" << endl;
|
|
// // if (j<0 || j>=ny) continue;
|
|
// // // cout << "2:Patch no: (" << i <<"," << j << ")" << endl;
|
|
// // // cin.get();
|
|
// // // find patch id
|
|
// // Array<int> ij(2); ij[0] = i; ij[1]=j;
|
|
// // int ip = GetPatchId(ij);
|
|
// // // cout << "ip = " << ip << endl;
|
|
|
|
// // // Solve the PML problem in patch ip with all sources
|
|
// // // Original and all transfered (maybe some of them)
|
|
// // Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// // Array<int> * Dof2PmlDof = &ovlp_prob->Dof2PmlDof[ip];
|
|
// // int ndofs = Dof2GlobalDof->Size();
|
|
// // Vector sol_local(ndofs);
|
|
// // Vector res_local(ndofs);
|
|
// // res_local = *f_orig[ip];
|
|
// // // res_local = 0.0;
|
|
// // res_local += *f_transf[ip][l];
|
|
// // // Extend by zero to the PML mesh
|
|
// // int nrdof_ext = PmlMat[ip]->Height();
|
|
|
|
// // Vector res_ext(nrdof_ext); res_ext = 0.0;
|
|
// // Vector sol_ext(nrdof_ext); sol_ext = 0.0;
|
|
|
|
// // res_ext.SetSubVector(*Dof2PmlDof,res_local);
|
|
// // PmlMatInv[ip]->Mult(res_ext, sol_ext);
|
|
|
|
// // // Multiply with the cutoff functions, find the new sources and
|
|
// // // and propagate to all neighboring subdomains
|
|
// // // (possible 8 in 2D, 26 in 3D)
|
|
// // TransferSources(l,ip, sol_ext);
|
|
// // Vector cfsol_ext(sol_ext.Size());
|
|
|
|
// // // cut off the ip solution to all possible directions
|
|
// // Array<int>directions(2); directions = 0;
|
|
// // if (i>0) directions[0] = -1;
|
|
// // if (j+1<ny) directions[1] = 1;
|
|
// // GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
// // // sol_ext = cfsol_ext;
|
|
// // // directions = 0;
|
|
// // // if (i+1<nx) directions[0] = 1;
|
|
// // // if (j>0) directions[1] = -1;
|
|
// // // GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
|
|
// // cfsol_ext.GetSubVector(*Dof2PmlDof, sol_local);
|
|
// // znew = 0.0;
|
|
// // znew.SetSubVector(*Dof2GlobalDof, sol_local);
|
|
// // // z2.AddElementVector(*Dof2GlobalDof, sol_local);
|
|
// // z2+=znew;
|
|
// // }
|
|
// // }
|
|
// // }
|
|
|
|
// // // // // socketstream sub_sock2(vishost, visport);
|
|
// // // // // PlotSolution(z2,sub_sock2, 0);
|
|
// // // // // cin.get();
|
|
|
|
|
|
// // z +=z2;
|
|
// // A->Mult(z,raux); rnew = r; rnew -=raux;
|
|
// // for (int ip=0; ip<nrpatch; ip++)
|
|
// // {
|
|
// // *f_orig[ip] = 0.0;
|
|
// // for (int i=0;i<nsweeps; i++)
|
|
// // {
|
|
// // *f_transf[ip][i] = 0.0;
|
|
// // }
|
|
// // }
|
|
// // for (int ip=0; ip<nrpatch; ip++)
|
|
// // {
|
|
// // Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// // rnew.GetSubVector(*Dof2GlobalDof,*f_orig[ip]);
|
|
// // }
|
|
|
|
// // for (int l=2; l<3; l++)
|
|
// // {
|
|
// // for (int s = 0; s<nsteps; s++)
|
|
// // {
|
|
// // // the patches involved are the ones such that
|
|
// // // i+j = s
|
|
// // // cout << "Step no: " << s << endl;
|
|
// // for (int i=0;i<nx; i++)
|
|
// // {
|
|
// // int j = nx+i-s-1;
|
|
// // // cout << "1:Patch no: (" << i <<"," << j << ")" << endl;
|
|
// // if (j<0 || j>=ny) continue;
|
|
// // // cout << "2:Patch no: (" << i <<"," << j << ")" << endl;
|
|
// // // cin.get();
|
|
// // // find patch id
|
|
// // Array<int> ij(2); ij[0] = i; ij[1]=j;
|
|
// // int ip = GetPatchId(ij);
|
|
// // // cout << "ip = " << ip << endl;
|
|
|
|
// // // Solve the PML problem in patch ip with all sources
|
|
// // // Original and all transfered (maybe some of them)
|
|
// // Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// // Array<int> * Dof2PmlDof = &ovlp_prob->Dof2PmlDof[ip];
|
|
// // int ndofs = Dof2GlobalDof->Size();
|
|
// // Vector sol_local(ndofs);
|
|
// // Vector res_local(ndofs);
|
|
// // res_local = *f_orig[ip];
|
|
// // // res_local = 0.0;
|
|
// // res_local += *f_transf[ip][l];
|
|
// // // Extend by zero to the PML mesh
|
|
// // int nrdof_ext = PmlMat[ip]->Height();
|
|
|
|
// // Vector res_ext(nrdof_ext); res_ext = 0.0;
|
|
// // Vector sol_ext(nrdof_ext); sol_ext = 0.0;
|
|
|
|
// // res_ext.SetSubVector(*Dof2PmlDof,res_local);
|
|
// // PmlMatInv[ip]->Mult(res_ext, sol_ext);
|
|
|
|
// // // Multiply with the cutoff functions, find the new sources and
|
|
// // // and propagate to all neighboring subdomains
|
|
// // // (possible 8 in 2D, 26 in 3D)
|
|
// // TransferSources(l,ip, sol_ext);
|
|
// // Vector cfsol_ext(sol_ext.Size());
|
|
|
|
// // // cut off the ip solution to all possible directions
|
|
// // Array<int>directions(2); directions = 0;
|
|
// // if (i+1<nx) directions[0] = 1;
|
|
// // if (j>0) directions[1] = -1;
|
|
// // GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
// // // sol_ext = cfsol_ext;
|
|
// // // directions = 0;
|
|
// // // if (i>0) directions[0] = -1;
|
|
// // // if (j+1<ny) directions[1] = 1;
|
|
// // // GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
|
|
// // cfsol_ext.GetSubVector(*Dof2PmlDof, sol_local);
|
|
// // znew = 0.0;
|
|
// // znew.SetSubVector(*Dof2GlobalDof, sol_local);
|
|
// // // z3.AddElementVector(*Dof2GlobalDof, sol_local);
|
|
// // z3+=znew;
|
|
// // }
|
|
// // }
|
|
// // }
|
|
|
|
// // z +=z3;
|
|
// // A->Mult(z,raux); rnew=r; rnew -=raux;
|
|
|
|
// // for (int ip=0; ip<nrpatch; ip++)
|
|
// // {
|
|
// // *f_orig[ip] = 0.0;
|
|
// // for (int i=0;i<nsweeps; i++)
|
|
// // {
|
|
// // *f_transf[ip][i] = 0.0;
|
|
// // }
|
|
// // }
|
|
// // for (int ip=0; ip<nrpatch; ip++)
|
|
// // {
|
|
// // Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// // rnew.GetSubVector(*Dof2GlobalDof,*f_orig[ip]);
|
|
// // }
|
|
|
|
|
|
// // for (int l=3; l<4; l++)
|
|
// // {
|
|
// // for (int s = 0; s<nsteps; s++)
|
|
// // {
|
|
// // // the patches involved are the ones such that
|
|
// // // i+j = s
|
|
// // // cout << "Step no: " << s << endl;
|
|
// // for (int i=0;i<nx; i++)
|
|
// // {
|
|
// // int j = nx+ny-i-s-2;
|
|
// // // cout << "1:Patch no: (" << i <<"," << j << ")" << endl;
|
|
// // if (j<0 || j>=ny) continue;
|
|
// // // cout << "2:Patch no: (" << i <<"," << j << ")" << endl;
|
|
// // // cin.get();
|
|
// // // find patch id
|
|
// // Array<int> ij(2); ij[0] = i; ij[1]=j;
|
|
// // int ip = GetPatchId(ij);
|
|
// // // cout << "ip = " << ip << endl;
|
|
|
|
// // // Solve the PML problem in patch ip with all sources
|
|
// // // Original and all transfered (maybe some of them)
|
|
// // Array<int> * Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip];
|
|
// // Array<int> * Dof2PmlDof = &ovlp_prob->Dof2PmlDof[ip];
|
|
// // int ndofs = Dof2GlobalDof->Size();
|
|
// // Vector sol_local(ndofs);
|
|
// // Vector res_local(ndofs);
|
|
// // res_local = *f_orig[ip];
|
|
// // // res_local = 0.0;
|
|
// // res_local += *f_transf[ip][l];
|
|
// // // Extend by zero to the PML mesh
|
|
// // int nrdof_ext = PmlMat[ip]->Height();
|
|
|
|
// // Vector res_ext(nrdof_ext); res_ext = 0.0;
|
|
// // Vector sol_ext(nrdof_ext); sol_ext = 0.0;
|
|
|
|
// // res_ext.SetSubVector(*Dof2PmlDof,res_local);
|
|
// // PmlMatInv[ip]->Mult(res_ext, sol_ext);
|
|
|
|
// // // Multiply with the cutoff functions, find the new sources and
|
|
// // // and propagate to all neighboring subdomains
|
|
// // // (possible 8 in 2D, 26 in 3D)
|
|
// // TransferSources(l,ip, sol_ext);
|
|
// // Vector cfsol_ext(sol_ext.Size());
|
|
|
|
// // // cut off the ip solution to all possible directions
|
|
// // Array<int>directions(2); directions = 0;
|
|
// // if (i>0) directions[0] = -1;
|
|
// // if (j>0) directions[1] = -1;
|
|
// // GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
// // // sol_ext = cfsol_ext;
|
|
// // // directions = 0;
|
|
// // // if (i+1<nx) directions[0] = 1;
|
|
// // // if (j+1<ny) directions[1] = 1;
|
|
// // // GetCutOffSolution(sol_ext,cfsol_ext,ip,directions,true);
|
|
|
|
// // cfsol_ext.GetSubVector(*Dof2PmlDof, sol_local);
|
|
// // znew = 0.0;
|
|
// // znew.SetSubVector(*Dof2GlobalDof, sol_local);
|
|
// // // z4.AddElementVector(*Dof2GlobalDof, sol_local);
|
|
// // z4+=znew;
|
|
// // }
|
|
// // }
|
|
// // }
|
|
|
|
// // z+=z4;
|
|
// // socketstream sock(vishost, visport);
|
|
// // PlotSolution(z,sock, 0);
|
|
// }
|
|
|
|
// void DiagST::PlotSolution(Vector & sol, socketstream & sol_sock, int ip) const
|
|
// {
|
|
// FiniteElementSpace * fespace = bf->FESpace();
|
|
// Mesh * mesh = fespace->GetMesh();
|
|
// GridFunction gf(fespace);
|
|
// double * data = sol.GetData();
|
|
// // gf.SetData(&data[fespace->GetTrueVSize()]);
|
|
// gf.SetData(data);
|
|
|
|
// string keys;
|
|
// if (ip == 0) keys = "keys mrRljc\n";
|
|
// sol_sock << "solution\n" << *mesh << gf << keys << "valuerange -0.1 0.1 \n" << flush;
|
|
// // sol_sock << "solution\n" << *mesh << gf << keys << flush;
|
|
// }
|
|
|
|
// void DiagST::GetCutOffSolution(const Vector & sol, Vector & cfsol,
|
|
// int ip0, Array<int> directions, bool local) const
|
|
// {
|
|
// // int l,k;
|
|
// int d = directions.Size();
|
|
// int directx = directions[0]; // 1,0,-1
|
|
// int directy = directions[1]; // 1,0,-1
|
|
// int directz;
|
|
// if (d ==3) directz = directions[2];
|
|
|
|
// // cout << "ip0 = " << ip0 << endl;
|
|
|
|
// int i0, j0, k0;
|
|
// Getijk(ip0,i0, j0, k0);
|
|
// // cout << "(i0,j0) = " << "(" <<i0 <<","<<j0<<")" << endl;
|
|
|
|
// // 2D for now...
|
|
// // Find the id of the neighboring patch
|
|
// int i1 = i0 + directx;
|
|
// int j1 = j0 + directy;
|
|
// MFEM_VERIFY(i1 < nxyz[0] && i1>=0, "GetCutOffSolution: i1 out of bounds");
|
|
// MFEM_VERIFY(j1 < nxyz[1] && j1>=0, "GetCutOffSolution: j1 out of bounds");
|
|
|
|
// Array<int> ijk(d);
|
|
// ijk[0] = i1;
|
|
// ijk[1] = j1;
|
|
// int ip1 = GetPatchId(ijk);
|
|
|
|
// // cout << "ip1 = " << ip1 << endl;
|
|
// // cout << "(i1,j1) = " << "(" << i1 <<","<<j1<<")" << endl;
|
|
|
|
// Mesh * mesh0 = ovlp_prob->fespaces[ip0]->GetMesh();
|
|
// Mesh * mesh1 = ovlp_prob->fespaces[ip1]->GetMesh();
|
|
|
|
// Vector pmin0, pmax0;
|
|
// Vector pmin1, pmax1;
|
|
// mesh0->GetBoundingBox(pmin0, pmax0);
|
|
// mesh1->GetBoundingBox(pmin1, pmax1);
|
|
|
|
// Array2D<double> h(dim,2); h = 0.0;
|
|
|
|
// if (directions[0]==1)
|
|
// {
|
|
// h[0][1] = pmax0[0] - pmin1[0];
|
|
// }
|
|
// if (directions[0]==-1)
|
|
// {
|
|
// h[0][0] = pmax1[0] - pmin0[0];
|
|
// }
|
|
// if (directions[1]==1)
|
|
// {
|
|
// h[1][1] = pmax0[1] - pmin1[1];
|
|
// }
|
|
// if (directions[1]==-1)
|
|
// {
|
|
// h[1][0] = pmax1[1] - pmin0[1];
|
|
// }
|
|
|
|
// pmin0.Print();
|
|
// pmax0.Print();
|
|
// h.Print();
|
|
|
|
// CutOffFnCoefficient cf(CutOffFncn, pmin0, pmax0, h);
|
|
|
|
// double * data = sol.GetData();
|
|
|
|
// FiniteElementSpace * fespace;
|
|
// if (!local)
|
|
// {
|
|
// fespace = bf->FESpace();
|
|
// }
|
|
// else
|
|
// {
|
|
// fespace = ovlp_prob->PmlFespaces[ip0];
|
|
// }
|
|
|
|
// int n = fespace->GetTrueVSize();
|
|
// // GridFunction cutF(fespace);
|
|
// // cutF.ProjectCoefficient(cf);
|
|
// // char vishost[] = "localhost";
|
|
// // int visport = 19916;
|
|
|
|
// // socketstream sub_sock1(vishost, visport);
|
|
// // sub_sock1 << "solution\n" << *fespace->GetMesh() << cutF << flush;
|
|
// // cin.get();
|
|
|
|
|
|
// GridFunction solgf_re(fespace, data);
|
|
// GridFunction solgf_im(fespace, &data[n]);
|
|
|
|
// // socketstream sub_sock(vishost, visport);
|
|
// // sub_sock << "solution\n" << *fespace->GetMesh() << solgf_re << flush;
|
|
// // cin.get();
|
|
|
|
|
|
// GridFunctionCoefficient coeff1_re(&solgf_re);
|
|
// GridFunctionCoefficient coeff1_im(&solgf_im);
|
|
|
|
// ProductCoefficient prod_re(coeff1_re, cf);
|
|
// ProductCoefficient prod_im(coeff1_im, cf);
|
|
|
|
// ComplexGridFunction gf(fespace);
|
|
// gf.ProjectCoefficient(prod_re,prod_im);
|
|
|
|
// cfsol.SetSize(sol.Size());
|
|
// cfsol = gf;
|
|
// // socketstream sub_sock2(vishost, visport);
|
|
// // sub_sock2 << "solution\n" << *fespace->GetMesh() << gf.real() << flush;
|
|
// // cin.get();
|
|
// }
|
|
|
|
|
|
// void DiagST::GetChiRes(const Vector & res, Vector & cfres,
|
|
// int ip, Array<int> directions, int nlayers) const
|
|
// {
|
|
// // int l,k;
|
|
// int d = directions.Size();
|
|
// int directx = directions[0]; // 1,0,-1
|
|
// int directy = directions[1]; // 1,0,-1
|
|
// int directz;
|
|
// if (d ==3) directz = directions[2];
|
|
|
|
// Mesh * mesh = ovlp_prob->fespaces[ip]->GetMesh();
|
|
// double h = GetUniformMeshElementSize(mesh);
|
|
|
|
// Vector pmin, pmax;
|
|
// mesh->GetBoundingBox(pmin, pmax);
|
|
|
|
// Array2D<double> pmlh(dim,2); pmlh = 0.0;
|
|
|
|
// if (directions[0]==1)
|
|
// {
|
|
// pmlh[0][1] = h*nlayers;
|
|
// }
|
|
// if (directions[0]==-1)
|
|
// {
|
|
// pmlh[0][0] = h*nlayers;
|
|
// }
|
|
// if (directions[1]==1)
|
|
// {
|
|
// pmlh[1][1] = h*nlayers;
|
|
// }
|
|
// if (directions[1]==-1)
|
|
// {
|
|
// pmlh[1][0] = h*nlayers;
|
|
// }
|
|
|
|
// CutOffFnCoefficient cf(CutOffFncn, pmin, pmax, pmlh);
|
|
|
|
// double * data = res.GetData();
|
|
|
|
// FiniteElementSpace * fespace;
|
|
// fespace = ovlp_prob->PmlFespaces[ip];
|
|
|
|
// int n = fespace->GetTrueVSize();
|
|
|
|
// GridFunction solgf_re(fespace, data);
|
|
// GridFunction solgf_im(fespace, &data[n]);
|
|
|
|
// GridFunctionCoefficient coeff1_re(&solgf_re);
|
|
// GridFunctionCoefficient coeff1_im(&solgf_im);
|
|
|
|
// ProductCoefficient prod_re(coeff1_re, cf);
|
|
// ProductCoefficient prod_im(coeff1_im, cf);
|
|
|
|
// ComplexGridFunction gf(fespace);
|
|
// gf.ProjectCoefficient(prod_re,prod_im);
|
|
|
|
// cfres.SetSize(res.Size());
|
|
// cfres = gf;
|
|
// }
|
|
|
|
// DiagST::~DiagST()
|
|
// {
|
|
// for (int ip = 0; ip<nrpatch; ++ip)
|
|
// {
|
|
// delete PmlMatInv[ip];
|
|
// delete PmlMat[ip];
|
|
// }
|
|
// PmlMat.DeleteAll();
|
|
// PmlMatInv.DeleteAll();
|
|
// for (int ip=0; ip<nrpatch; ip++)
|
|
// {
|
|
// delete f_orig[ip];
|
|
// for (int i=0;i<nsweeps; i++)
|
|
// {
|
|
// delete f_transf[ip][i];
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// void DiagST::Getijk(int ip, int & i, int & j, int & k) const
|
|
// {
|
|
// k = ip/(nxyz[0]*nxyz[1]);
|
|
// j = (ip-k*nxyz[0]*nxyz[1])/nxyz[0];
|
|
// i = (ip-k*nxyz[0]*nxyz[1])%nxyz[0];
|
|
// }
|
|
|
|
// int DiagST::GetPatchId(const Array<int> & ijk) const
|
|
// {
|
|
// int d=ijk.Size();
|
|
// if (d==2)
|
|
// {
|
|
// return subdomains(ijk[0],ijk[1],0);
|
|
// }
|
|
// else
|
|
// {
|
|
// return subdomains(ijk[0],ijk[1],ijk[2]);
|
|
// }
|
|
// }
|
|
|
|
// int DiagST::SourceTransfer(const Vector & Psi0, Array<int> direction, int ip0, Vector & Psi1) const
|
|
// {
|
|
// // For now 2D problems only
|
|
// // Directions
|
|
// // direction (1,1)
|
|
// int i0,j0,k0;
|
|
// Getijk(ip0,i0,j0,k0);
|
|
|
|
// int i1 = i0+direction[0];
|
|
// int j1 = j0+direction[1];
|
|
// Array<int> ij(2); ij[0]=i1; ij[1]=j1;
|
|
// int ip1 = GetPatchId(ij);
|
|
|
|
// MFEM_VERIFY(i1 < nxyz[0] && i1>=0, "SourceTransfer: i1 out of bounds");
|
|
// MFEM_VERIFY(j1 < nxyz[1] && j1>=0, "SourceTransfer: j1 out of bounds");
|
|
|
|
// Array<int> * Dof2GlobalDof0 = &ovlp_prob->Dof2GlobalDof[ip0];
|
|
// Array<int> * Dof2GlobalDof1 = &ovlp_prob->Dof2GlobalDof[ip1];
|
|
// Psi1.SetSize(Dof2GlobalDof1->Size()); Psi1=0.0;
|
|
// Vector r(2*bf->FESpace()->GetTrueVSize());
|
|
// r = 0.0;
|
|
// r.SetSubVector(*Dof2GlobalDof0,Psi0);
|
|
|
|
// // if (direction[0] == 1 && direction[1] == 1)
|
|
// // {
|
|
// // Vector zloc(Psi1.Size());
|
|
// // r.GetSubVector(*Dof2GlobalDof1,zloc);
|
|
// // // extend
|
|
// // Vector psi_ext(PmlMat[ip1]->Height());
|
|
// // Vector zloc_ext(PmlMat[ip1]->Height());
|
|
// // Array<int> * Dof2PmlDof1 = &ovlp_prob->Dof2PmlDof[ip1];
|
|
// // zloc_ext.SetSubVector(*Dof2PmlDof1,zloc);
|
|
// // PmlMat[ip1]->Mult(zloc_ext,psi_ext);
|
|
// // psi_ext *=-1.0;
|
|
// // psi_ext.GetSubVector(*Dof2PmlDof1,Psi1);
|
|
// // // }
|
|
// // else
|
|
// // {
|
|
// r.GetSubVector(*Dof2GlobalDof1,Psi1);
|
|
// // }
|
|
// return ip1;
|
|
// }
|
|
|
|
// void DiagST::ConstructDirectionsMap()
|
|
// {
|
|
// // total of 8 possible directions of transfer (2D)
|
|
// // form left ( 1 , 0)
|
|
// // form left-above ( 1 , -1)
|
|
// // form left-below ( 1 , 1)
|
|
// // form right (-1 , 0)
|
|
// // form right-below (-1 , 1)
|
|
// // form right-above (-1 , -1)
|
|
// // form above ( 0 , -1)
|
|
// // form below ( 0 , 1)
|
|
// ntransf_directions = pow(3,dim);
|
|
|
|
// dirx.SetSize(ntransf_directions);
|
|
// diry.SetSize(ntransf_directions);
|
|
// int n=3;
|
|
// Array<int> ijk(dim);
|
|
// if (dim==2)
|
|
// {
|
|
// for (int i=-1; i<=1; i++) // directions x
|
|
// {
|
|
// for (int j=-1; j<=1; j++) // directions y
|
|
// {
|
|
// ijk[0]=i;
|
|
// ijk[1]=j;
|
|
// int k=GetDirectionId(ijk);
|
|
// dirx[k]=i;
|
|
// diry[k]=j;
|
|
// }
|
|
// }
|
|
// }
|
|
// else if (dim==3)
|
|
// {
|
|
// dirz.SetSize(ntransf_directions);
|
|
// for (int i=-1; i<=1; i++) // directions x
|
|
// {
|
|
// for (int j=-1; j<=1; j++) // directions y
|
|
// {
|
|
// for (int k=-1; k<=1; k++) // directions zß
|
|
// {
|
|
// ijk[0]=i;
|
|
// ijk[1]=j;
|
|
// ijk[2]=k;
|
|
// int l=GetDirectionId(ijk);
|
|
// dirx[l]=i;
|
|
// diry[l]=j;
|
|
// dirz[l]=k;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// // cout << "dirx = " << endl;
|
|
// // dirx.Print(cout,ntransf_directions);
|
|
// // cout << "diry = " << endl;
|
|
// // diry.Print(cout,ntransf_directions);
|
|
|
|
// // if (dim==2)
|
|
// // {
|
|
// // for (int id=0; id<9; id++)
|
|
// // {
|
|
// // GetDirectionijk(id,ijk);
|
|
// // // cout << "for id = " << id << ": (" <<ijk[0] << ", " << ijk[1] << ")" << endl;
|
|
// // }
|
|
// // }
|
|
// // else
|
|
// // {
|
|
// // cout << "dirz = " << endl;
|
|
// // dirz.Print(cout,ntransf_directions);
|
|
// // for (int id=0; id<27; id++)
|
|
// // {
|
|
// // GetDirectionijk(id,ijk);
|
|
// // // cout << "for id = " << id << ": (" <<ijk[0] << ", " <<ijk[1] << ", " << ijk[2] << ")" << endl;
|
|
// // }
|
|
// // }
|
|
// }
|
|
|
|
// int DiagST::GetDirectionId(const Array<int> & ijk) const
|
|
// {
|
|
// int d = ijk.Size();
|
|
// int n=3;
|
|
// if (d==2)
|
|
// {
|
|
// return (ijk[0]+1)*n+(ijk[1]+1);
|
|
// }
|
|
// else
|
|
// {
|
|
// return (ijk[0]+1)*n*n+(ijk[1]+1)*n+ijk[2]+1;
|
|
// }
|
|
// }
|
|
|
|
// void DiagST::GetDirectionijk(int id, Array<int> & ijk) const
|
|
// {
|
|
// int d = ijk.Size();
|
|
// int n=3;
|
|
// if (d==2)
|
|
// {
|
|
// ijk[0]=id/n - 1;
|
|
// ijk[1]=id%n - 1;
|
|
// }
|
|
// else
|
|
// {
|
|
// ijk[0]=id/(n*n)-1;
|
|
// ijk[1]=(id-(ijk[0]+1)*n*n)/n - 1;
|
|
// ijk[2]=(id-(ijk[0]+1)*n*n)%n - 1;
|
|
// }
|
|
// // cout << "ijk = " ; ijk.Print();
|
|
// }
|
|
|
|
|
|
|
|
|
|
// void DiagST::TransferSources(int sweep, int ip0, Vector & sol_ext) const
|
|
// {
|
|
// // Find all neighbors of patch ip
|
|
// int nx = nxyz[0];
|
|
// int ny = nxyz[1];
|
|
// int i0, j0, k0;
|
|
// Getijk(ip0, i0,j0,k0);
|
|
// // cout << "Transfer to : " << endl;
|
|
// // loop through possible directions
|
|
// for (int i=-1; i<2; i++)
|
|
// {
|
|
// int i1 = i0 + i;
|
|
// if (i1 <0 || i1>=nx) continue;
|
|
// for (int j=-1; j<2; j++)
|
|
// {
|
|
// if (i==0 && j==0) continue;
|
|
// int j1 = j0 + j;
|
|
// if (j1 <0 || j1>=ny) continue;
|
|
// // cout << "(" << i1 << "," << j1 <<"), ";
|
|
// // Find ip 1
|
|
// Array<int> ij1(2); ij1[0] = i1; ij1[1]=j1;
|
|
// int ip1 = GetPatchId(ij1);
|
|
// // cout << "ip1 = " << ip1;
|
|
// // cout << " in the direction of (" << i <<", " <<j <<")" << endl;
|
|
// Array<int> directions(2);
|
|
// directions[0] = i;
|
|
// directions[1] = j;
|
|
// Vector cfsol_ext;
|
|
// Vector res_ext(sol_ext.Size());
|
|
// GetCutOffSolution(sol_ext,cfsol_ext,ip0,directions,true);
|
|
// // sol_ext = cfsol_ext;
|
|
// // Calculate source to be transfered
|
|
|
|
|
|
|
|
|
|
|
|
// PmlMat[ip0]->Mult(cfsol_ext, res_ext);
|
|
|
|
// //---------------------------------------
|
|
// // FiniteElementSpace * fes = ovlp_prob->PmlFespaces[ip0];
|
|
// // Mesh * mesh = fes->GetMesh();
|
|
// // GridFunction gf(fes);
|
|
// // double * data = res_ext.GetData();
|
|
// // // gf.SetData(&data[fespace->GetTrueVSize()]);
|
|
// // gf.SetData(data);
|
|
// // char vishost[] = "localhost";
|
|
// // int visport = 19916;
|
|
// // socketstream pmlsock(vishost, visport);
|
|
|
|
// // string keys;
|
|
// // keys = "keys mrRljc\n";
|
|
// // pmlsock << "solution\n" << *mesh << gf << keys << "valuerange -0.1 0.1 \n" << flush;
|
|
// // // sol_sock << "solution\n" << *mesh << gf << keys << flush;
|
|
// // cin.get();
|
|
// //---------------------------------------
|
|
|
|
|
|
|
|
// res_ext*= -1.0;
|
|
// Array<int> *Dof2PmlDof = &ovlp_prob->Dof2PmlDof[ip0];
|
|
// Vector res_local(Dof2PmlDof->Size()); res_local = 0.0;
|
|
// res_ext.GetSubVector(*Dof2PmlDof,res_local);
|
|
|
|
|
|
// // Vector sol_local(Dof2PmlDof->Size()); sol_local = 0.0;
|
|
// // cfsol_ext.GetSubVector(*Dof2PmlDof,sol_local);
|
|
// // Vector znew(A->Height()); znew = 0.0;
|
|
// // Vector rnew(A->Height()); rnew = 0.0;
|
|
// // Array<int> *Dof2GlobalDof = &ovlp_prob->Dof2GlobalDof[ip0];
|
|
// // znew.SetSubVector(*Dof2GlobalDof,sol_local);
|
|
// // A->Mult(znew,rnew); rnew *=-1.0;
|
|
// // rnew.GetSubVector(*Dof2GlobalDof, res_local);
|
|
|
|
// //-----------------------------
|
|
// // pass to ip1 and calculate residual there
|
|
// // Vector sol_local(Dof2PmlDof->Size()); sol_local = 0.0;
|
|
// // cfsol_ext.GetSubVector(*Dof2PmlDof,sol_local);
|
|
// //-----------------------------
|
|
|
|
|
|
|
|
|
|
|
|
// // Find the minumum sweep number that to transfer the source that
|
|
// // satisfies the two rules
|
|
// for (int l=sweep; l<nsweeps; l++)
|
|
// {
|
|
// // Conditions on sweeps
|
|
// // Rule 1: the transfer source direction has to be similar with
|
|
// // the sweep direction
|
|
// int is = sweeps(l,0);
|
|
// int js = sweeps(l,1);
|
|
// int ddot = is*i + js * j;
|
|
// // cout << "(i,j) = (" << i <<"," <<j <<")" << endl;
|
|
// // cout << "(is,js) = (" << is <<"," <<js <<")" << endl;
|
|
// // cout << "ip0 , ip1 = " << ip0 << ", " << ip1 << endl;
|
|
// if (ddot <= 0) continue;
|
|
|
|
// // Rule 2: The horizontal or vertical transfer source cannot be used
|
|
// // in a later sweep that with opposite directions
|
|
|
|
// if (i==0 || j == 0) // Case of horizontal or vertical transfer source
|
|
// {
|
|
// int il = sweeps(l,0);
|
|
// int jl = sweeps(l,1);
|
|
// // skip if the two sweeps have opposite direction
|
|
// if (is == -il && js == -jl) continue;
|
|
// }
|
|
// // cout << "Passing ip0 = " << ip0 << " to ip1 = " << ip1
|
|
// // << " to sweep no l = " << l << endl;
|
|
// Vector raux;
|
|
// // if (directions[0] == 1 && directions[1] == 1)
|
|
// // {
|
|
// // res_local = sol_local;
|
|
// // }
|
|
// // cout << res_local.Norml2() << endl;
|
|
|
|
// int jp1 = SourceTransfer(res_local,directions,ip0,raux);
|
|
// MFEM_VERIFY(ip1 == jp1, "Check SourceTransfer patch id");
|
|
// MFEM_VERIFY(f_transf[ip1][l]->Size()==raux.Size(),
|
|
// "Transfer Sources: inconsistent size");
|
|
// *f_transf[ip1][l]+=raux;
|
|
|
|
|
|
// // FiniteElementSpace * fes1 = ovlp_prob->fespaces[ip1];
|
|
// // Mesh * mesh1 = fes1->GetMesh();
|
|
// // GridFunction gf1(fes1);
|
|
// // double * data1 = raux.GetData();
|
|
// // gf1.SetData(data1);
|
|
// // socketstream sock(vishost, visport);
|
|
// // sock << "solution\n" << *mesh1 << gf1 << keys << "valuerange -0.1 0.1 \n" << flush;
|
|
// // // sol_sock << "solution\n" << *mesh << gf << keys << flush;
|
|
// // cin.get();
|
|
// break;
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|