Creating Multiple Source and Receiver Pairs in a 2D Cartesian Mesh and Saving its Information for Further Processing, In Electromagnetics

[cyasing]

I am trying to create multiple source-receiver pairs for the simulation based on example 25 of Electromagnetics for the inline-quad.mesh. I would like these sources to be in a circle around the centre with a specific radius. I have the function ready in normal coordinates, but I don't know how to translate it into MFEM's mesh based functions. This is what I have:

void eval_source_receivers_locations(
    const size_t num_antennas,
    const double radius,
    const size_t iteration,
    Points2D<double>& location_source, // Points2D is just a struct with 2 std::vectors x and y
    Points2D<double>& location_receivers)
{
    // Evaluate the source locations
    for (size_t i = 0; i < num_antennas; i++)
    {
        double angle = 2 * M_PI * i / num_antennas;
        if (i == iteration) // Based on iteration, one out of `num_antennas` points wll be source and other `num_antennas - 1` receivers
        {
            location_source.x.push_back(radius * cos(angle));
            location_source.y.push_back(radius * sin(angle));
        }
        else
        {
            location_receivers.x.push_back(radius * cos(angle));
            location_receivers.y.push_back(radius * sin(angle));
        }
    }
}

The example 25 just places the source at the centre using 0.5_r * (comp_domain_bdr(i, 0) + comp_domain_bdr(i, 1)). I would like to modify this to be able to calculate positions for source and receivers, and store them in some way, maybe as element numbers, or dofs, or coordinates.

At the receiver positions, I just want to be able to collect data x, which I think I can do using x.real().GetSubVector(dofs, e_r), where dofs correspond to dofs of elements at the receiver locations. Is this a good approach or can it be better?

[mlstowell]

HI, @cyasing,

Have you considered using VectorDeltaCoefficient? You could create one of these for each source and receiver location and pass them to a LinearForm object in the same way ex25 uses f with b. There are multiple ways to measure the fields at the receiver location but one would be to use a VectorDeltaCoefficient with a LinearForm and compute the inner product of the resulting LienarForm with the solution vector. Another would be to use FindPts similar to what is done in miniapps/tools/get-values.cpp.

Best wishes,
Mark

[cyasing]

I did look into VectorDeltaCoefficient briefly, but I will look into it again. Especially now that I know you can do the inner product with the solution, that sounds like a very good approach.

[cyasing]

Could you tell me how to set the source and receiver points in a circle like the function I have mentioned?

Specifically, I try setting it at a location within the mesh, and I print the information from GetDeltaCenter and I get 0.25 0, which is fine. But then I use b.Print(std::cout); and it shows just zeroes all throughout.

[cyasing]

Here's what I am trying instead of f:

	Vector delta_dir(dim+1); // since dim == 2
	delta_dir(0) = 0.0; delta_dir(1) = 0.0; delta_dir(2) = 1.0; // z directed current
        // intensity is the same as coeff from the source f, and location_source.x and location_source.y are numbers 0.25 and 0
	VectorDeltaCoefficient delta(delta_dir, location_source.x.at(0), location_source.y.at(0), intensity); 

        Vector delta_center(dim);
        delta.GetDeltaCenter(delta_center);
	delta_center.Print(std::cout); 

	LinearForm b2(fespace);
	b2.AddDomainIntegrator(new VectorFEDomainLFIntegrator(delta));
	b2.Vector::operator=(0.0);
	b2.Assemble();

	b2.Print(std::cout);

[mlstowell]

Hi, @cyasing,
This could be caused by a complication in 2D electromagnetic problems. The Nedelec basis functions you are using only have vector components in the xy-plane but your source only has a z-component. Consequently the projection of the source onto your 2D domain is zero.

You could reformulate the problem using a scalar H1 field to represent the z-component of the electric field but then I expect the PML would need some work. The easiest work-around is to use a 3D mesh. If your problem is effectively 2D you could use a mesh which is only one element thick in the z-direction. The problem here is that uniform refinement will also refine in the z-direction and give you far more degrees of freedom than you require. So, start with a thin mesh which has already been refined as much as you need. You can modify something like inline-hex.mesh to something like:

MFEM INLINE mesh v1.0

type = hex
nx = 100
ny = 100
nz = 1
sx = 1.0
sy = 1.0
sz = 0.01

As an example.

Best wishes,
Mark

[cyasing]

I see, that makes sense. Thanks, I will try these methods!