460 lines
14 KiB
C++
460 lines
14 KiB
C++
// MFEM Example 40 - Parallel Version
|
||
//
|
||
// Compile with: make ex40p
|
||
//
|
||
// Sample runs: mpirun -np 4 ex40p -step 10.0 -gr 2.0
|
||
// mpirun -np 4 ex40p -step 10.0 -gr 2.0 -o 3 -r 1
|
||
// mpirun -np 4 ex40p -step 10.0 -gr 2.0 -r 4 -m ../data/l-shape.mesh
|
||
// mpirun -np 4 ex40p -step 10.0 -gr 2.0 -r 2 -m ../data/fichera.mesh
|
||
//
|
||
// Description: This example code demonstrates how to use MFEM to solve the
|
||
// eikonal equation,
|
||
//
|
||
// |∇𝑢| = 1 in Ω, 𝑢 = 0 on ∂Ω.
|
||
//
|
||
// The viscosity solution of this problem coincides with the unique optimum
|
||
// of the nonlinear program
|
||
//
|
||
// maximize ∫_Ω 𝑢 d𝑥 subject to |∇𝑢| ≤ 1 in Ω, 𝑢 = 0 on ∂Ω, (⋆)
|
||
//
|
||
// which is the foundation for method implemented below.
|
||
//
|
||
// Following the proximal Galerkin methodology [1,2] (see also Example
|
||
// 36), we construct a Legendre function for the closed unit ball
|
||
// 𝐵₁ := {𝑥 ∈ Rⁿ | |𝑥| ≤ 1}. Our choice is the Hellinger entropy,
|
||
//
|
||
// R(𝑥) = −( 1 − |𝑥|² )^{1/2},
|
||
//
|
||
// although other choices are possible, each leading to a slightly
|
||
// different algorithm. We then adaptively regularize the optimization
|
||
// problem (⋆) with the Bregman divergence of the Hellinger entropy,
|
||
//
|
||
// maximize ∫_Ω 𝑢 d𝑥 - αₖ⁻¹ D(∇𝑢,∇𝑢ₖ₋₁) subject to 𝑢 = 0 on Ω.
|
||
//
|
||
// This results in a sequence of functions ( 𝜓ₖ , 𝑢ₖ ),
|
||
//
|
||
// 𝑢ₖ → 𝑢, 𝜓ₖ/|𝜓ₖ| → ∇𝑢 as k → ∞,
|
||
//
|
||
// defined by the nonlinear saddle-point problems
|
||
//
|
||
// Find 𝜓ₖ ∈ H(div,Ω) and 𝑢ₖ ∈ L²(Ω) such that
|
||
// ( (∇R)⁻¹(𝜓ₖ) , τ ) + ( 𝑢ₖ , ∇⋅τ ) = 0 ∀ τ ∈ H(div,Ω)
|
||
// ( ∇⋅𝜓ₖ , v ) = ( ∇⋅𝜓ₖ₋₁ - αₖ , v ) ∀ v ∈ L²(Ω)
|
||
//
|
||
// where (∇R)⁻¹(𝜓) = 𝜓 / ( 1 + |𝜓|² )^{1/2} and αₖ = α₀rᵏ, where r ≥ 1
|
||
// is a prescribed growth rate. (r = 1 is the most stable.) The
|
||
// saddle-point problems are solved using a damped quasi-Newton method
|
||
// with a tunable regularization parameter 0 ≤ ϵ << 1. The solver is
|
||
// also made more robust by additional safeguards described in the code.
|
||
//
|
||
// [1] Keith, B. and Surowiec, T. (2024) Proximal Galerkin: A structure-
|
||
// preserving finite element method for pointwise bound constraints.
|
||
// Foundations of Computational Mathematics, 1–97.
|
||
// [2] Dokken, J., Farrell, P., Keith, B., Papadopoulos, I., and
|
||
// Surowiec, T. (2025) The latent variable proximal point algorithm
|
||
// for variational problems with inequality constraints. (To appear.)
|
||
|
||
#include "mfem.hpp"
|
||
#include <fstream>
|
||
#include <iostream>
|
||
|
||
using namespace std;
|
||
using namespace mfem;
|
||
|
||
class IsomorphismCoefficient : public VectorCoefficient
|
||
{
|
||
protected:
|
||
ParGridFunction *psi;
|
||
|
||
public:
|
||
IsomorphismCoefficient(int vdim, ParGridFunction &psi_)
|
||
: VectorCoefficient(vdim), psi(&psi_) { }
|
||
|
||
using VectorCoefficient::Eval;
|
||
|
||
void Eval(Vector &V, ElementTransformation &T,
|
||
const IntegrationPoint &ip) override;
|
||
};
|
||
|
||
class DIsomorphismCoefficient : public MatrixCoefficient
|
||
{
|
||
protected:
|
||
ParGridFunction *psi;
|
||
real_t eps;
|
||
|
||
public:
|
||
DIsomorphismCoefficient(int height, ParGridFunction &psi_, real_t eps_ = 0.0)
|
||
: MatrixCoefficient(height), psi(&psi_), eps(eps_) { }
|
||
|
||
void Eval(DenseMatrix &K, ElementTransformation &T,
|
||
const IntegrationPoint &ip) override;
|
||
};
|
||
|
||
int main(int argc, char *argv[])
|
||
{
|
||
// 0. Initialize MPI and HYPRE.
|
||
Mpi::Init();
|
||
int num_procs = Mpi::WorldSize();
|
||
int myid = Mpi::WorldRank();
|
||
Hypre::Init();
|
||
|
||
// 1. Parse command-line options.
|
||
const char *mesh_file = "../data/star.mesh";
|
||
int order = 1;
|
||
int max_it = 5;
|
||
int ref_levels = 3;
|
||
real_t alpha = 1.0;
|
||
real_t growth_rate = 1.0;
|
||
real_t newton_scaling = 0.8;
|
||
real_t eps = 1e-6;
|
||
real_t tol = 1e-4;
|
||
real_t max_alpha = 1e2;
|
||
real_t max_psi = 1e2;
|
||
real_t eps2 = 1e-1;
|
||
bool visualization = true;
|
||
|
||
OptionsParser args(argc, argv);
|
||
args.AddOption(&mesh_file, "-m", "--mesh",
|
||
"Mesh file to use.");
|
||
args.AddOption(&order, "-o", "--order",
|
||
"Finite element order (polynomial degree).");
|
||
args.AddOption(&ref_levels, "-r", "--refs",
|
||
"Number of h-refinements.");
|
||
args.AddOption(&max_it, "-mi", "--max-it",
|
||
"Maximum number of iterations");
|
||
args.AddOption(&tol, "-tol", "--tol",
|
||
"Stopping criteria based on the difference between"
|
||
"successive solution updates");
|
||
args.AddOption(&alpha, "-step", "--step",
|
||
"Initial size alpha");
|
||
args.AddOption(&growth_rate, "-gr", "--growth-rate",
|
||
"Growth rate of the step size alpha");
|
||
args.AddOption(&visualization, "-vis", "--visualization", "-no-vis",
|
||
"--no-visualization",
|
||
"Enable or disable GLVis visualization.");
|
||
args.Parse();
|
||
if (!args.Good())
|
||
{
|
||
if (myid == 0)
|
||
{
|
||
args.PrintUsage(cout);
|
||
}
|
||
return 1;
|
||
}
|
||
if (myid == 0)
|
||
{
|
||
args.PrintOptions(cout);
|
||
}
|
||
|
||
// 2. Read the mesh from the mesh file.
|
||
Mesh mesh(mesh_file, 1, 1);
|
||
int dim = mesh.Dimension();
|
||
int sdim = mesh.SpaceDimension();
|
||
|
||
MFEM_ASSERT(mesh.bdr_attributes.Size(),
|
||
"This example does not support meshes"
|
||
" without boundary attributes."
|
||
)
|
||
|
||
// 3. Postprocess the mesh.
|
||
// 3A. Refine the mesh to increase the resolution.
|
||
for (int l = 0; l < ref_levels; l++)
|
||
{
|
||
mesh.UniformRefinement();
|
||
}
|
||
|
||
// 3B. Interpolate the geometry after refinement to control geometry error.
|
||
// NOTE: Minimum second-order interpolation is used to improve the accuracy.
|
||
int curvature_order = max(order,2);
|
||
mesh.SetCurvature(curvature_order);
|
||
|
||
// 3C. Compute the maximum mesh size.
|
||
real_t hmax = 0.0;
|
||
for (int i = 0; i < mesh.GetNE(); i++)
|
||
{
|
||
hmax = max(mesh.GetElementSize(i, 1), hmax);
|
||
}
|
||
|
||
ParMesh pmesh(MPI_COMM_WORLD, mesh);
|
||
mesh.Clear();
|
||
|
||
// 4. Define the necessary finite element spaces on the mesh.
|
||
RT_FECollection RTfec(order, dim);
|
||
ParFiniteElementSpace RTfes(&pmesh, &RTfec);
|
||
|
||
L2_FECollection L2fec(order, dim);
|
||
ParFiniteElementSpace L2fes(&pmesh, &L2fec);
|
||
|
||
int num_dofs_RT = RTfes.GlobalTrueVSize();
|
||
int num_dofs_L2 = L2fes.GlobalTrueVSize();
|
||
if (myid == 0)
|
||
{
|
||
cout << "Number of H(div) dofs: "
|
||
<< num_dofs_RT << endl;
|
||
cout << "Number of L² dofs: "
|
||
<< num_dofs_L2 << endl;
|
||
}
|
||
|
||
// 5. Define the offsets for the block matrices
|
||
Array<int> offsets(3);
|
||
offsets[0] = 0;
|
||
offsets[1] = RTfes.GetVSize();
|
||
offsets[2] = L2fes.GetVSize();
|
||
offsets.PartialSum();
|
||
|
||
Array<int> toffsets(3);
|
||
toffsets[0] = 0;
|
||
toffsets[1] = RTfes.GetTrueVSize();
|
||
toffsets[2] = L2fes.GetTrueVSize();
|
||
toffsets.PartialSum();
|
||
|
||
BlockVector x(offsets), rhs(offsets);
|
||
x = 0.0; rhs = 0.0;
|
||
|
||
BlockVector tx(toffsets), trhs(toffsets);
|
||
tx = 0.0; trhs = 0.0;
|
||
|
||
// 6. Define the solution vectors as a finite element grid functions
|
||
// corresponding to the fespaces.
|
||
ParGridFunction u_gf, delta_psi_gf;
|
||
delta_psi_gf.MakeRef(&RTfes,x,offsets[0]);
|
||
u_gf.MakeRef(&L2fes,x,offsets[1]);
|
||
|
||
ParGridFunction psi_old_gf(&RTfes);
|
||
ParGridFunction psi_gf(&RTfes);
|
||
ParGridFunction u_old_gf(&L2fes);
|
||
|
||
// 7. Define initial guesses for the solution variables.
|
||
delta_psi_gf = 0.0;
|
||
psi_gf = 0.0;
|
||
u_gf = 0.0;
|
||
psi_old_gf = psi_gf;
|
||
u_old_gf = u_gf;
|
||
|
||
// 8. Prepare for glvis output.
|
||
char vishost[] = "localhost";
|
||
int visport = 19916;
|
||
socketstream sol_sock;
|
||
if (visualization)
|
||
{
|
||
sol_sock.open(vishost,visport);
|
||
sol_sock.precision(8);
|
||
}
|
||
|
||
// 9. Coefficients to be used later.
|
||
ConstantCoefficient one_cf(1.0);
|
||
ConstantCoefficient zero_cf(0.0);
|
||
Vector zero_vec(sdim); zero_vec = 0.0;
|
||
VectorConstantCoefficient zero_vec_cf(zero_vec);
|
||
ConstantCoefficient neg_alpha_cf((real_t) -1.0*alpha);
|
||
IsomorphismCoefficient Z(sdim, psi_gf);
|
||
DIsomorphismCoefficient DZ(sdim, psi_gf, eps);
|
||
ScalarVectorProductCoefficient neg_Z(-1.0, Z);
|
||
DivergenceGridFunctionCoefficient div_psi_cf(&psi_gf);
|
||
DivergenceGridFunctionCoefficient div_psi_old_cf(&psi_old_gf);
|
||
SumCoefficient psi_old_minus_psi(div_psi_old_cf, div_psi_cf, 1.0, -1.0);
|
||
|
||
// 10. Assemble constant matrices/vectors to avoid reassembly in the loop.
|
||
ParLinearForm b0, b1;
|
||
b0.MakeRef(&RTfes,rhs.GetBlock(0),0);
|
||
b1.MakeRef(&L2fes,rhs.GetBlock(1),0);
|
||
|
||
b0.AddDomainIntegrator(new VectorFEDomainLFIntegrator(neg_Z));
|
||
b1.AddDomainIntegrator(new DomainLFIntegrator(neg_alpha_cf));
|
||
b1.AddDomainIntegrator(new DomainLFIntegrator(psi_old_minus_psi));
|
||
|
||
ParBilinearForm a00(&RTfes);
|
||
a00.AddDomainIntegrator(new VectorFEMassIntegrator(DZ));
|
||
|
||
ParMixedBilinearForm a10(&RTfes,&L2fes);
|
||
a10.AddDomainIntegrator(new VectorFEDivergenceIntegrator());
|
||
a10.Assemble();
|
||
a10.Finalize();
|
||
HypreParMatrix *A10 = a10.ParallelAssemble();
|
||
|
||
HypreParMatrix *A01 = A10->Transpose();
|
||
|
||
ParLinearForm vol_form(&L2fes);
|
||
ParGridFunction one_gf(&L2fes);
|
||
one_gf = 1.0;
|
||
vol_form.AddDomainIntegrator(new DomainLFIntegrator(one_cf));
|
||
vol_form.Assemble();
|
||
real_t domain_volume = vol_form(one_gf);
|
||
|
||
// 11. Iterate.
|
||
int k;
|
||
int total_iterations = 0;
|
||
real_t increment_u = 0.1;
|
||
ParGridFunction u_tmp(&L2fes);
|
||
for (k = 0; k < max_it; k++)
|
||
{
|
||
u_tmp = u_old_gf;
|
||
|
||
if (myid == 0)
|
||
{
|
||
mfem::out << "\nOUTER ITERATION " << k+1 << endl;
|
||
}
|
||
|
||
int j;
|
||
for ( j = 0; j < 5; j++)
|
||
{
|
||
total_iterations++;
|
||
|
||
b0.Assemble();
|
||
b0.ParallelAssemble(trhs.GetBlock(0));
|
||
|
||
b1.Assemble();
|
||
b1.ParallelAssemble(trhs.GetBlock(1));
|
||
|
||
a00.Assemble(false);
|
||
a00.Finalize(false);
|
||
HypreParMatrix *A00 = a00.ParallelAssemble();
|
||
|
||
// Construct Schur-complement preconditioner
|
||
HypreParVector A00_diag(MPI_COMM_WORLD, A00->GetGlobalNumRows(),
|
||
A00->GetRowStarts());
|
||
A00->GetDiag(A00_diag);
|
||
HypreParMatrix S_tmp(*A01);
|
||
S_tmp.InvScaleRows(A00_diag);
|
||
HypreParMatrix *S = ParMult(A10, &S_tmp, true);
|
||
|
||
BlockDiagonalPreconditioner prec(toffsets);
|
||
HypreBoomerAMG P00(*A00);
|
||
P00.SetPrintLevel(0);
|
||
HypreBoomerAMG P11(*S);
|
||
P11.SetPrintLevel(0);
|
||
prec.SetDiagonalBlock(0,&P00);
|
||
prec.SetDiagonalBlock(1,&P11);
|
||
|
||
BlockOperator A(toffsets);
|
||
A.SetBlock(0,0,A00);
|
||
A.SetBlock(1,0,A10);
|
||
A.SetBlock(0,1,A01);
|
||
|
||
MINRESSolver minres(MPI_COMM_WORLD);
|
||
minres.SetPrintLevel(-1);
|
||
minres.SetRelTol(1e-12);
|
||
minres.SetMaxIter(10000);
|
||
minres.SetOperator(A);
|
||
minres.SetPreconditioner(prec);
|
||
minres.Mult(trhs,tx);
|
||
delete S;
|
||
delete A00;
|
||
|
||
delta_psi_gf.SetFromTrueDofs(tx.GetBlock(0));
|
||
u_gf.SetFromTrueDofs(tx.GetBlock(1));
|
||
|
||
u_tmp -= u_gf;
|
||
real_t Newton_update_size = u_tmp.ComputeL2Error(zero_cf);
|
||
u_tmp = u_gf;
|
||
|
||
// Damped Newton update
|
||
psi_gf.Add(newton_scaling, delta_psi_gf);
|
||
a00.Update();
|
||
|
||
if (visualization)
|
||
{
|
||
sol_sock << "parallel " << num_procs << " " << myid << "\n";
|
||
sol_sock << "solution\n" << pmesh << u_gf << "window_title 'Discrete solution'"
|
||
<< flush;
|
||
}
|
||
|
||
if (myid == 0)
|
||
{
|
||
mfem::out << "Newton_update_size = " << Newton_update_size << endl;
|
||
}
|
||
|
||
if (newton_scaling*Newton_update_size < increment_u)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
u_tmp = u_gf;
|
||
u_tmp -= u_old_gf;
|
||
increment_u = u_tmp.ComputeL2Error(zero_cf);
|
||
|
||
if (myid == 0)
|
||
{
|
||
mfem::out << "Number of Newton iterations = " << j+1 << endl;
|
||
mfem::out << "Increment (|| uₕ - uₕ_prvs||) = " << increment_u << endl;
|
||
}
|
||
|
||
u_old_gf = u_gf;
|
||
psi_old_gf = psi_gf;
|
||
alpha *= max(growth_rate, 1_r);
|
||
|
||
// Safeguard 1: Stop alpha from growing too large
|
||
alpha = min(alpha, max_alpha);
|
||
|
||
// Safeguard 2: Stop |ψ| from growing too large
|
||
real_t norm_psi = psi_old_gf.ComputeL1Error(zero_vec_cf)/domain_volume;
|
||
if (norm_psi > max_psi)
|
||
{
|
||
// Additional entropy regularization
|
||
neg_alpha_cf.constant = -alpha/(1.0 + eps2 * alpha * hmax);
|
||
psi_old_minus_psi.SetAlpha(1.0/(1.0 + eps2 * alpha * hmax));
|
||
}
|
||
else
|
||
{
|
||
neg_alpha_cf.constant = -alpha;
|
||
}
|
||
|
||
if (increment_u < tol || k == max_it-1)
|
||
{
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
// 12. Print stats.
|
||
if (myid == 0)
|
||
{
|
||
mfem::out << "\n Outer iterations: " << k+1
|
||
<< "\n Total iterations: " << total_iterations
|
||
<< "\n Total dofs: " << RTfes.GetTrueVSize() + L2fes.GetTrueVSize()
|
||
<< endl;
|
||
}
|
||
|
||
// 13. Free the used memory.
|
||
delete A01;
|
||
delete A10;
|
||
return 0;
|
||
}
|
||
|
||
void IsomorphismCoefficient::Eval(Vector &V, ElementTransformation &T,
|
||
const IntegrationPoint &ip)
|
||
{
|
||
MFEM_ASSERT(psi != NULL, "grid function is not set");
|
||
|
||
Vector psi_vals(vdim);
|
||
psi->GetVectorValue(T, ip, psi_vals);
|
||
real_t norm = psi_vals.Norml2();
|
||
real_t phi = 1.0 / sqrt(1.0 + norm*norm);
|
||
|
||
V = psi_vals;
|
||
V *= phi;
|
||
}
|
||
|
||
void DIsomorphismCoefficient::Eval(DenseMatrix &K, ElementTransformation &T,
|
||
const IntegrationPoint &ip)
|
||
{
|
||
MFEM_ASSERT(psi != NULL, "grid function is not set");
|
||
MFEM_ASSERT(eps >= 0, "eps is negative");
|
||
|
||
Vector psi_vals(height);
|
||
psi->GetVectorValue(T, ip, psi_vals);
|
||
real_t norm = psi_vals.Norml2();
|
||
real_t phi = 1.0 / sqrt(1.0 + norm*norm);
|
||
|
||
K = 0.0;
|
||
for (int i = 0; i < height; i++)
|
||
{
|
||
K(i,i) = phi + eps;
|
||
for (int j = 0; j < height; j++)
|
||
{
|
||
K(i,j) -= psi_vals(i) * psi_vals(j) * pow(phi, 3);
|
||
}
|
||
}
|
||
}
|