Processing math: 100%
Research article Special Issues

Two arbitrary-order constraint-preserving schemes for the Yang–Mills equations on polyhedral meshes

  • Two numerical schemes are proposed and investigated for the Yang–Mills equations, which can be seen as a nonlinear generalisation of the Maxwell equations set on Lie algebra-valued functions, with similarities to certain formulations of General Relativity. Both schemes are built on the Discrete de Rham (DDR) method, and inherit from its main features: an arbitrary order of accuracy, and applicability to generic polyhedral meshes. They make use of the complex property of the DDR, together with a Lagrange-multiplier approach, to preserve, at the discrete level, a nonlinear constraint associated with the Yang–Mills equations. We also show that the schemes satisfy a discrete energy dissipation (the dissipation coming solely from the implicit time stepping). Issues around the practical implementations of the schemes are discussed; in particular, the assembly of the local contributions in a way that minimises the price we pay in dealing with nonlinear terms, in conjunction with the tensorisation coming from the Lie algebra. Numerical tests are provided using a manufactured solution, and show that both schemes display a convergence in L2-norm of the potential and electrical fields in O(hk+1) (provided that the time step is of that order), where k is the polynomial degree chosen for the DDR complex. We also numerically demonstrate the preservation of the constraint.

    Citation: Jérôme Droniou, Jia Jia Qian. Two arbitrary-order constraint-preserving schemes for the Yang–Mills equations on polyhedral meshes[J]. Mathematics in Engineering, 2024, 6(3): 468-493. doi: 10.3934/mine.2024019

    Related Papers:

    [1] Carlo Danieli, Bertin Many Manda, Thudiyangal Mithun, Charalampos Skokos . Computational efficiency of numerical integration methods for the tangent dynamics of many-body Hamiltonian systems in one and two spatial dimensions. Mathematics in Engineering, 2019, 1(3): 447-488. doi: 10.3934/mine.2019.3.447
    [2] Andrea Borio, Martina Busetto, Francesca Marcon . SUPG-stabilized stabilization-free VEM: a numerical investigation. Mathematics in Engineering, 2024, 6(1): 173-191. doi: 10.3934/mine.2024008
    [3] Zaffar Mehdi Dar, M. Arrutselvi, Chandru Muthusamy, Sundararajan Natarajan, Gianmarco Manzini . Virtual element approximations of the time-fractional nonlinear convection-diffusion equation on polygonal meshes. Mathematics in Engineering, 2025, 7(2): 96-129. doi: 10.3934/mine.2025005
    [4] Simon Lemaire, Julien Moatti . Structure preservation in high-order hybrid discretisations of potential-driven advection-diffusion: linear and nonlinear approaches. Mathematics in Engineering, 2024, 6(1): 100-136. doi: 10.3934/mine.2024005
    [5] Lina Zhao, Eun-Jae Park . A locally conservative staggered least squares method on polygonal meshes. Mathematics in Engineering, 2024, 6(2): 339-362. doi: 10.3934/mine.2024014
    [6] Claudio Canuto, Davide Fassino . Higher-order adaptive virtual element methods with contraction properties. Mathematics in Engineering, 2023, 5(6): 1-33. doi: 10.3934/mine.2023101
    [7] Ansgar Jüngel, Ulisse Stefanelli, Lara Trussardi . A minimizing-movements approach to GENERIC systems. Mathematics in Engineering, 2022, 4(1): 1-18. doi: 10.3934/mine.2022005
    [8] Thomas J. Radley, Paul Houston, Matthew E. Hubbard . Quadrature-free polytopic discontinuous Galerkin methods for transport problems. Mathematics in Engineering, 2024, 6(1): 192-220. doi: 10.3934/mine.2024009
    [9] Luca Azzolin, Luca Dedè, Antonello Gerbi, Alfio Quarteroni . Effect of fibre orientation and bulk modulus on the electromechanical modelling of human ventricles. Mathematics in Engineering, 2020, 2(4): 614-638. doi: 10.3934/mine.2020028
    [10] Paola F. Antonietti, Chiara Facciolà, Marco Verani . Unified analysis of discontinuous Galerkin approximations of flows in fractured porous media on polygonal and polyhedral grids. Mathematics in Engineering, 2020, 2(2): 340-385. doi: 10.3934/mine.2020017
  • Two numerical schemes are proposed and investigated for the Yang–Mills equations, which can be seen as a nonlinear generalisation of the Maxwell equations set on Lie algebra-valued functions, with similarities to certain formulations of General Relativity. Both schemes are built on the Discrete de Rham (DDR) method, and inherit from its main features: an arbitrary order of accuracy, and applicability to generic polyhedral meshes. They make use of the complex property of the DDR, together with a Lagrange-multiplier approach, to preserve, at the discrete level, a nonlinear constraint associated with the Yang–Mills equations. We also show that the schemes satisfy a discrete energy dissipation (the dissipation coming solely from the implicit time stepping). Issues around the practical implementations of the schemes are discussed; in particular, the assembly of the local contributions in a way that minimises the price we pay in dealing with nonlinear terms, in conjunction with the tensorisation coming from the Lie algebra. Numerical tests are provided using a manufactured solution, and show that both schemes display a convergence in L2-norm of the potential and electrical fields in O(hk+1) (provided that the time step is of that order), where k is the polynomial degree chosen for the DDR complex. We also numerically demonstrate the preservation of the constraint.



    In this paper we investigate two arbitrary-order numerical methods for the Yang–Mills equations on general polyhedral meshes, based on the fully discrete serendipity Discrete de Rham (SDDR) complex [1]. The first method was proposed (but not tested) in [2] for the non-serendipity version of the Discrete de Rham (DDR) sequence, while the second method is novel to this paper. The two discretisations differ in the treatment of one of the nonlinearities present in these equations. In contrast to conforming methods, the discrete structure of the SDDR spaces means that there is no obvious construction of the nonlinear terms, and this can be problematic when specific algebraic manipulations need to be reproduced, for instance to prove consistency estimates. The implementation cost is another important factor to the viability of each approach, which is explored with accompanying numerical results on the convergence and discrete conservation properties of each scheme.

    The classical Yang–Mills equations come from a class of non-abelian gauge theories, generalising the abelian U(1) group of electromagnetism to certain non-abelian gauge groups. Once quantised, this theory forms the foundation of the current Standard Model of particle physics. In the classical setting, the non-commutativity of the group manifests as the appearance of nonlinear quantities in addition to the linear Maxwell terms. Analogous to Maxwell, the Yang–Mills equations can be formulated as a set of evolution equations preserving particular constraints (e.g., the conservation of charge), given that the initial data satisfies these constraints. In the linear case, the preservation of these constraints is a direct consequence of the calculus formula div curl = 0, which is linked to the complex property of the de Rham sequence. Designing numerical methods that replicate this property is essential to maintaining constraint preservation at the discrete level, and thus to obtaining stable schemes. Much work has been done in the Finite Element framework to design discrete versions of the de Rham complex, see, e.g., [3,4,5,6,7,8] and references therein. Finite Element methods are, however, limited to meshes made of specific elements (mostly tetrahedra and hexahedra in 3D), which limits their flexibility in terms of mesh refinement or agglomeration. Recently, discrete polytopal complexes – discrete versions of continuous complexes, that are applicable on meshes made of generic polyhedra – have been introduced, see, e.g., [9,10,11,12]. The discrete complex property enabled the design of stable and robust schemes, in particular for magnetostatics [10,13], plate problems [14,15,16,17], and the Stokes equations [18,19]).

    Given the importance, for the stability of schemes, of preserving constraints at the discrete level, similar techniques have been explored for the Yang–Mills equations, using either Finite Element or polytopal approaches [2,20,21]. For these equations, however, the nonlinearity has proven to be troublesome, and required additional techniques (e.g., the introduction of Lagrange multipliers) beyond a discrete version of the formula div curl = 0. The interest in developing our understanding of such methods is in the application to numerical schemes for Einstein's equations, where the absence of this constraint propagation can cause disastrous error growth [22,23,24] in the numerical simulations. Current techniques to control this error include constraint damping [22,23,25], where specific terms are added to the evolution equations to suppress the growth of the constraint violations, but methods for exact preservation remain limited. The link with the Yang–Mills equations is that in certain formulations of General Relativity (GR), such as the Einstein-Bianchi system [26,27], these equations can resemble greatly those of electromagnetism with additional nonlinear terms. Therefore it is natural to expect that these ideas will aid in designing a constraint preserving scheme for GR based on the framework of discrete polytopal complexes.

    An equally important aspect of the design of numerical methods is the feasibility of the implementation and testing under real world conditions. We find more commonly, for the Yang–Mills equations, numerical tests run in only low-order 2D settings [20,21]. Any increase in the dimension or the order of the approximation generally leads to schemes that are vastly more expensive to run, and this is compounded by the nonlinearity of the model. Hence working with spaces that are smaller and more refined is an effective way to cut the cost of the simulations. The SDDR complex, introduced in [1], is a variant of the DDR complex [11,12], where the spaces have undergone a serendipity reduction, eliminating many unknowns, while retaining the complex and consistency properties of the original sequence. This enables the seamless transfer of any DDR scheme and results to the SDDR version, with all the flexibility of the general-order polytopal method at a lower cost. Additionally, this can be combined with other reduction techniques such as static condensation to further increase the efficiency.

    The issue with the nonlinearity in the practical implementation is the computations involving 'high dimensional' arrays that are required to deal with all the coefficients. This number grows exponentially with the degree of the multilinearity, and thus takes up majority of the time in the assembly phase of the runtime. For matrices (2-dimensional arrays), there exists many specialised algorithms to speed up calculations, as well as efficient storage structures in the case that it is sparse. The libraries for higher dimensional arrays are less advanced, and often incomplete in their features; as a consequence, operations need to be done manually, introducing another source of possible inefficiencies. Simply rearranging the order of calculations can lead to sizeable differences in the space and time complexities, therefore finding the optimal trade-off is key to measuring the actual performance of the scheme.

    The paper is organised as follows: In Section 2, we give a presentation of the SDDR complex and its Lie algebra extension, that is independent of the DDR framework. Section 3 starts with the constrained formulation of the continuous Yang–Mills equations. Based on that, we introduce the two schemes that are considered in the paper and the differing approaches on the nonlinear terms. This is followed by a proof of the preservation of a discrete constraint functional, as well as energy estimates. Section 4 covers the major steps in the implementation of the scheme, showing the impact of Lie algebra tensorisation on the physical data structures, and also highlighting how the trilinear and quadrilinear forms and sums are managed in the tensorised situation. Numerical results for these implementations are found in Section 5, where we test both the convergence and the discrete constraint preservation on three different mesh families in the 3D setting. Expected convergence rates of k+1 are mostly seen, as well as the preservation of the initial constraint up to machine precision. We also report on the differences in the results and runtimes, which turned out to be very minor between the two methods. A brief conclusion is provided in Section 6.

    We present here the serendipity version of the arbitrary-order Lie Algebra-valued DDR complex, originally sketched in [2, Section 6]. This complex consists in tensorising the SDDR complex of [1], which is built in this reference from the (regular) DDR complex; such a presentation relies on a complete description of the latter complex, together with "extension" and "reduction" maps that link the two complexes. In the following, we adopt a stand-alone description of the SDDR complex, directly translating the formulas resulting from the links with the DDR complex. For this reason, the notations adopted below differ slightly from [1]: there, the serendipity spaces and operators are denoted using a hat (the non-hat version referring to the regular DDR spaces and operators, which are not needed here).

    We use the same mesh and polynomial space notations as in [12]. Let U be a polygonal domain of R3. A mesh Mh=ThFhEhVh is a collection of polyhedral elements (gathered in Th, and partitioning U), of polygonal faces (gathered in Fh), of edges (gathered in Eh) and vertices (gathered in Vh). Each PMh is assumed to be topologically trivial (simply connected with connected boundary), and we denote by hP the diameter of P; we set h=maxTThhT. When applicable, the sets FP (resp. EP, resp. VP) gather the faces (resp. edges, resp. vertices) of P. Each face FFh is oriented by the choice of a unit normal nF, and each edge EEh is oriented by the choice of a unit tangent tE. If TTh and FFT, ωTF is the relative orientation of F with respect to T: ωTF=+1 if nF points outside T, ωTF=1 otherwise. For FFh and EEF, ωFE denotes the relative orientation of E with respect to F: ωFE=+1 if, along F, tE points counter-clockwise with respect to the orientation of F induced by nF, and ωFE=1 otherwise; we also denote by nFE the unit vector such that (tE,nFE,nF) defines a right-handed system in R3. The final orientation is that of the vertices of each edge: for EEh and VVE, ωEV=+1 if tE points towards V on E, and ωEV=1 otherwise.

    We assume that ThFh satisfies the regularity assumption of [28, Definition 1.9] with regularity parameter ϱ, and we write AB when ACB for some C depending only on U, ϱ and the possible polynomial degrees involved in A,B.

    For any mesh face FFh and smooth enough function r:FR, gradFr is the gradient of r on F and rotFr its 2-dimensional vector curl (rotation of gradFr by π/2 in the plane spanned by F). For a smooth function z on F with values in the tangent plane of F, the divergence of z on F is divFz, and its scalar curl (divergence of the rotated by π/2 of z) is rotFz.

    If PMh and 0 is an integer, P(P) denotes the space of restrictions to P of three-variate polynomials on R3 of total degree , and P0,(P) is its subspace of polynomials with vanishing integral over P. We adopt the convention P(P)={0} if <0. If TTh, we set P(T)=P(T)3 and, for FFh, P(F) is the subspace of P(F)3 which take value in the tangent space of F. The L2-orthogonal projector on P(P) is denoted by πP,P. Selecting, for each PThFh, a point xPP such that P contains a ball centered at xP and of radius hP, we recall the following decompositions of vector-valued polynomial spaces: For all FFh,

    P(F)=R(F)Rc,(F) with R(F)=rotFP+1(F) and Rc,(F)=(xxF)P1(F)

    and, for TTh,

    P(T)=R(T)Rc,(T) with R(T)=curlP+1(T) and Rc,(T)=(xxT)P1(T),P(T)=G(T)Gc,(T) with G(T)=gradP+1(T) and Gc,(T)=(xxT)×P1(T),

    (here and in the following, when used between two vectors or a vector and a space, × denotes the cross product in R3). The L2-orthogonal projectors on these spaces are, with obvious notations, πR,F, πc,R,F, πR,T, πc,R,T, πG,T and πc,G,T.

    For each element or face PThFh, we select on the boundary of the element (resp. face) a set BP of ηP2 faces (resp. edges) that are not pairwise coplanar (resp. aligned) and such that, for each bBP, P lies entirely on one side of the affine space spanned by b. From here on, we fix a polynomial degree k0, measuring the accuracy of the discrete complex, and we set

    P=k+1ηP,PThFh.

    The SDDR versions of the H1(U), H(curl;U), H(div;U) and L2(U) spaces appearing in the continuous de Rham complex are the following spaces.

    X_kgrad,h:={q_h=((qT)TTh,(qF)FFh,(qE)EEh,(qV)VVh):qTPT(T) for all TTh,qFPF(F) for all FFh,qEPk1(E) for all EEh, and qVR for all VVh},X_kcurl,h:={v_h=((vR,T,vcR,T)TTh,(vR,F,vcR,F)FFh,(vE)EEh):vR,TRk1(T) and vcR,TRc,T+1(T) for all TTh,vR,FRk1(F) and vcR,FRc,F+1(F) for all FFh,and vEPk(E) for all EEh},X_kdiv,h:={w_h=((wG,T,wcG,T)TTh,(wF)FFh):wG,TGk1(T) and wcG,TGc,k(T) for all TTh,and vFPk(F) for all FFh},Pk(Th):={rhL2(U):(rh)|TPk(T) for all TTh}.

    The interpolators on these spaces consist in projecting continuous scalar/vector fields (or some of their traces) onto the polynomial components of the spaces. Specifically,

    I_kgrad,h:C(¯U)X_kgrad,h,
    I_kcurl,h:C(¯U)X_kcurl,h

    and

    I_kdiv,h:C(¯U)X_kdiv,h

    are defined as:

    I_kgrad,hq=((πTP,Tq)TTh,(πFP,Fq)FFh,(πk1P,Eq)EEh,(q(xV))VVh),qC(¯U),I_kcurl,hv=((πk1R,Tv,πc,T+1R,Tv)TTh,(πk1R,Fvt,F,πc,F+1R,Fvt,F)FFh,(πkP,E(vtE))EEh),vC(¯U),I_kdiv,hw=((πk1G,Tw,πc,kG,Tw)TTh,(πkP,F(wnE))EEh),wC(¯U),

    where vt,F=nF×(v|F×nF) is the tangential trace of v on F.

    As usual in fully discrete complexes, we adopt the underlined notation for vectors of polynomial components, and we replace the index h with P to denote the restriction of these spaces (and the operators defined on them) to a mesh entity PThFhEh and its boundary entities. So, for example, a vector v_FX_kcurl,F corresponds to v_F=(vR,F,vcR,F,(vE)EEF).

    The DDR spaces correspond to the spaces above with the choice F=T=k1 (that is, ηF=ηP=2). This implies in particular that, for k=0 (which forces P<0 for all PThFh), the standard and serendipity DDR spaces are identical. However, as soon as k1, the SDDR spaces have lower dimensions, while still encoding the same level of polynomial consistency as the DDR spaces. This is due to the existence of two families of key operators, the serendipity gradient and curl operators. Specifically, for PThFh, the role of the gradient serendipity operator Skgrad,P:X_kgrad,PPk(P) is to reconstruct a consistent gradient, while the curl serendipity operator Skcurl,P:X_kcurl,PPk(P) reconstructs a consistent vector potential. The consistencies in questions are expressed by the following relations (see [1, Proposition 18]):

    Skgrad,PI_kgrad,Pq=gradPq,qPk+1(P)
    Skcurl,PI_kcurl,Pv=v,vPk(P).

    We do not present the precise definitions of these operators, which are not essential to describe the SDDR complex, and refer the reader to [1].

    In the next three sections we define operators acting on these spaces, with values in full polynomial spaces, mimicking the gradient, curl, and divergence. It should be noted that, in the original presentation of the SDDR complex in [1], these operators were not explicitly defined – only the discrete operators (projections on the complex spaces, see Section 2.2) and discrete inner products were detailed, based on those of the DDR complex. The polynomial operators below correspond to those of the DDR complex composed with the extension operators linking the DDR and SDDR complex; for ease of reference, we indicate which formulas from [1] yield the definitions presented here.

    For each edge EEh we define the edge gradient GkE:X_kgrad,EPk(E) and potential reconstruction γk+1E:X_kgrad,EPk+1(E) by: For all q_E=(qE,(qV)VVE)X_kgrad,E,

    EGkEq_ErE=EqErE+VVEωEVqVrE(xV),rEPk(E),γk+1Eq_E(xV)=qVVVE and πk1P,E(γk+1Eq_E)=qE.

    The definition of GkEq_E, in which the derivative rE is taken in the direction tE, mimics an integration-by-parts formula; it can be checked that

    GkEq_E=(γk+1Eq_E).

    For each FFh, combining [1, Eqs (4.2), (5.18) and (6.6)] together with divFrotF=0 yields the following definition of the face gradient GkF:X_kgrad,FPk(F): For all q_FX_kgrad,F,

    FGkFq_F(w+τ)=EEFωFEEγk+1Eq_E(wnFE)+FSkgrad,Fq_Fτ,(w,τ)Rk(F)×Rc,k(F).

    Using this face gradient and [1, Eqs (4.3) and (5.18)], the scalar potential reconstruction on FFh is then γk+1F:X_kgrad,FPk+1(F) defined by: For all q_FX_kgrad,F,

    Fγk+1Fq_FdivFw=FGkFq_Fw+EEFωFEEγk+1Eq_E(wnFE),wRc,k+2(F).

    Finally, for TTh, we use [1, Eqs (4.4),(5.32) and (6.6)] to write the element gradient GkT:X_kgrad,TPk(T) as: For all q_TX_kgrad,T,

    TGkTq_T(w+τ)=FFTωTFFγk+1Fq_F(wnTF)+TSkgrad,Tq_Tτ,(w,τ)Rk(T)×Rc,k(T).

    The potential reconstruction Pk+1grad,T:X_kgrad,TPk+1(T) is such that: For all q_TX_kgrad,T,

    TPk+1grad,Tq_Tdiv w=TGkTq_Tw+FFTωTFFγk+1Fq_F(wnTF),wRc,k+2(T).

    Remark 1 (Approximation properties of the potential reconstructions in X_kgrad,T). As demonstrated by [12, Theorem 6], the potential reconstructions on the space X_kgrad,T have optimal approximation properties of degree k+1. This is however an exception to the rule of spaces and potential reconstructions in the DDR complex; the reasons for this exception are better understood when translating this complex in the language of differential forms (see [29], especially Remarks 7 and 18 therein).

    For FFh, using [1, Eqs (4.6), (5.19) and (6.7)] we define the face curl CkF:X_kcurl,FPk(F) by: For all v_FX_kcurl,F,

    FCkFv_Fr=FvR,FrotFrEEFωFEEvEr,rPk(F).

    This definition is actually identical to the face curl in the DDR complex and does not invoke Skcurl,F, as the extension operators between the SDDR and DDR curl face space do not modify the components on Rk1(F) and on ×EEFPk(E). The curl serendipity operator is however involved in the definition of the component on Rc,k(F) of the extension (see [1, Eq (5.19)]), and therefore in the vector potential reconstruction γkt,F:X_kcurl,FPk(F) on F, defined as: For all v_FX_kcurl,F,

    Fγkt,Fv_F(rotFr+τ)=FCkFv_Fr+EEFωFEEvEr+FSkcurl,Fv_Fτ,(r,τ)P0,k+1(F)×Rc,k(F).

    Similar considerations apply to the element curl and vector potential. For TTh, the element curl CkT:X_kcurl,TPk(T) is defined by: For all v_TX_kcurl,T,

    TCkTv_Tw=TvR,Tcurl w+FFTωTFFγkt,Fv_F(w×nF),wPk(T).

    The vector potential Pkcurl,T:X_kcurl,TPk(T) is given by: For all v_TX_kcurl,T,

    TPkcurl,Tv_T(curl w+τ)=TCkTv_TwFFTωTFFγkt,Fv_F(w×nF)+TSkcurl,Tv_Tτ,(w,τ)Gc,k+1(T)×Rc,k(T).

    The discrete divergence and potential on X_kdiv,T, for TTh, are identical to those of the DDR complex since no serendipity reduction is actually possible on this space (see [1, Section 6.5]): DkT:X_kdiv,TPk(T) and Pkdiv,T:X_kdiv,TPk(T) are such that, for all w_TX_kdiv,T,

    TDkTw_Tq=TwG,Tgrad q+FFTωTFFwFq,qPk(T),TPkdiv,Tw_T(grad r+τ)=TDkTw_Tr+FFTωTFFwFr+TwcG,Tτ,(r,τ)P0,k+1(T)×Gc,k(T).

    The serendipity DDR complex is

    RI_kgrad,hX_kgrad,hG_khX_kcurl,hC_khX_kdiv,hDkhPk(Th)0{0},

    where the discrete differential operators G_kh, C_kh and Dkh are obtained projecting the edge/face/element operators onto the proper spaces (dictated by the co-domains):

    G_khq_h:=((πk1R,TGkTq_T,πc,T+1R,TGkTq_T)TTh,(πk1R,FGkFq_F,πc,F+1R,FGkFq_F)FFh,(GkEq_E)EEh),C_khv_h:=((πk1G,TCkTv_T,πc,kG,TCkTv_T)TTh,(CkFv_F)FFh),Dkhw_h:=(DkTw_T)TTh.

    It was proved that this sequence is indeed a complex [11,12], and has the same cohomology as the de Rham complex [30].

    To design numerical schemes based on the SDDR complex, an essential ingredient, besides the discrete differential operators, are consistent L2-inner products on the spaces of the complex. A scheme can then be designed by replacing, in the weak formulation of the PDE, the continuous differential operators and L2-products by the discrete operators of the complex and the L2-inner products on its spaces.

    The design of these discrete L2-inner products rely on the element potential reconstructions defined in the previous sections. Specifically, if X_k,h is one of the space X_kgrad,h, X_kcurl,h or X_kdiv,h and Pk,T is the associated potential in the element T, the discrete L2-product on X_k,h is defined by

    (x_h,y_h),h:=TTh(x_T,y_T),Twith(x_T,y_T),T:=[TPk,Tx_TPk,Ty_T+s,T(x_T,y_T)],

    where the dot product in the integral is replaced by a multiplication if =grad , and the stabilisation term s,T penalises the difference between traces of the element potential and potential reconstructions on the face/edges (where relevant). The precise definition of the stabilisation term therefore depends on the space, and the available traces:

    sgrad,T(r_T,q_T):=FFThFF(Pk+1grad,Tr_Tγk+1Fr_F)(Pk+1grad,Tq_Tγk+1Fq_F)+EETh2EE(Pk+1grad,Tr_Tγk+1Er_E)(Pk+1grad,Tq_Tγk+1Eq_E),r_T,q_TX_kgrad,T,scurl,T(w_T,v_T):=FFThFF((Pkcurl,Tw_T)t,Fγkt,Fw_F)((Pkcurl,Tv_T)t,Fγkt,Fv_F)+EETh2EE(Pkcurl,Tw_TtEwE)(Pkcurl,Tv_TtEvE),w_T,v_TX_kcurl,T,sdiv,T(w_T,v_T):=FFThFF(Pkdiv,Tw_TnFwF)(Pkdiv,Tv_TnFvF),w_T,v_TX_kdiv,T. (2.1)

    An important property of the potential reconstruction on each mesh entity is their polynomial consistency: Applied to interpolates of polynomials of the correct degree (=k+1 for the gradient space, =k for the curl and divergence spaces), they return the polynomial itself. This translates into the following polynomial consistency of the L2-inner products:

    (I_k,Tf,I_k,Tg),T=Tfg,f,gP(T).

    Since the Yang–Mills equations involve Lie algebra-valued functions, a Lie algebra-valued complex is required to discretise them. This complex is simply obtained by tensorisation of the real-valued complex, as in [2]: the spaces are made of Lie algebra-valued polynomials, and the operators of the complex act component by component on the Lie algebra.

    In the following, we consider a Lie algebra g, that is, a finite-dimensional vector space endowed with a bilinear bracket [,]:g×gg and an inner product ,:g×gR which satisfy the Jacobi identity

    [a,[b,c]]+[b,[c,a]]+[c,[a,b]]=0,a,b,cg

    and the Ad-invariance property, which implies

    [a,b],c=a,[b,c],a,b,cg.

    We denote the Lie algebra-valued SDDR spaces by appending an exponent g after the degree k. So, for example, the gradient space in the LASDDR (Lie algebra SDDR) complex is

    X_k,ggrad,h:=(X_kgrad,hg){q_h=((qT)TTh,(qF)FFh,(qE)EEh,(qV)VVh):qTPT(T)g for all TTh,qFPF(F)g for all FFh,qEPk1(E)g for all EEh, and qVRg for all VVh}.

    We note that, selecting a basis (eI)I of g, for any PMh we have

    P(P)gP(P;g):={ϕIeI:ϕIP(P)}.

    Here and in the following we use the implicit summation convention so, for example, ϕIeI=IϕIeI. For a general space X, an element vXg can be uniquely decomposed as v=vIeI. Any linear operator L:XY acting between two SDDR spaces X,Y (or an SDDR space and a polynomial space) – such as a discrete differential operator, a potential reconstruction, etc. – then gives rise to the corresponding LASDDR operator Lg:XgYg defined as Lg(v)=(L(vI))eIYg; this definition is independent of the choice of the basis in g. With these notations, the LASDDR complex is

    RgI_k,ggrad,hX_k,ggrad,hG_k,ghX_k,gcurl,hC_k,ghX_k,gdiv,hDk,ghPk(Th)g0{0}.

    In each space an inner product is obtained by tensorising the inner product of the corresponding SDDR space and of the Lie algebra. So, if {grad,curl,div},

    (x_h,y_h),g,h=(x_Ih,y_Jh),heI,eJ,x_h=x_IheIX_k,g,h,y_h=y_JheJX_k,g,h.

    Practical implementations of the LASDDR complex and related schemes can be easily done, in principle, by tensorising the operators and inner products of an SDDR implementation. Early tensorisation can however lead to unduly expensive calculations, especially when nonlinear terms are involved. We discuss in Section 4 the main considerations that must be taken into account to limit the assembly cost in implementations of LASDDR-based schemes.

    We propose two schemes for the Yang–Mills equations, which only differ in the handling of the nonlinear terms appearing in the equations. The first was introduced at the lowest order in [2], in which a discrete 'bracket' was constructed to approximate the value in the X_k,gdiv,h space. This term is used in the discrete L2-products, and the exact preservation of a discrete constraint, as well as energy estimates, are proven. Numerical tests in [2] however only considered the lowest-order k=0 of the method.

    The second method we present here is new, and leverages instead the continuous L2-product and nonlinear bracket, as well as the elemental potential reconstructions, to achieve the same goal.

    Deriving from the bracket on the Lie algebra, the following two bilinear maps are defined:

    [,]:(X(U)g)×(C(U)g)X(U)g,[v,q]vIqJ[eI,eJ], (3.1)
    [,]:(X(U)g)×(X(U)g)X(U)g,[v,w](vI×wJ)[eI,eJ]. (3.2)

    We use in the discretisation a weak constrained formulation of the Yang–Mills equations, appearing previously in [20]: Find (A,E,λ):[0,T](H(curl;U)g)2×(H1(U)g) such that

    4tA=E, (3.3a)
    UtE,v+Ugrad λ+[A,λ],v=Ucurl A,curl v+Ucurl A,[A,v]+U12[A,A],curl v+[A,v],vH(curl;U)g, (3.3b)
    UtE,grad q+[A,q]=0,qH1(U)g. (3.3c)

    Note that the right-hand side of (3.3b) is equal to UB,curl v+[A,v], where the magnetic field is defined as B:=curl A+12[A,A]. We have developed this expression as it will drive different choices of discretisations. Solutions to these equations preserve the quantity

    UE,grad q+[A,q],qH1(U)g. (3.4)

    The use of this particular constrained form facilitates the preservation of a discrete counterpart in the numerical scheme; discussions on the derivation and implications of these continuous equations can be found in [2,20].

    We consider a time discretisation 0=t0<t1<<tN=T of [0,T] and denote the step in time between n and n+1 as δtn+12:=tn+1tn. Then define for a family v=(vn)n, δn+1tv=vn+1vnδtn+12.

    Starting from initial conditions (A_0h,E_0h)(X_k,gcurl,h)2, the constrained scheme based on (3.3) is: Find families (A_nh)n, (E_nh)n, (λ_nh)n such that for all n, (A_nh,E_nh,λ_nh)(X_k,gcurl,h)2×(X_k,ggrad,h) and

    4δn+1tA_h=E_n+1h, (3.5a)
    (δn+1tE_h,v_h)curl,g,h+(G_k,ghλ_n+1h,v_h)curl,g,h+U[Pk,gcurl,hA_n+1h,Pk+1,ggrad,hλ_n+1h],Pk,gcurl,hv_h=(C_k,ghA_n+1h,C_k,ghv_h)div,g,h+N(A_nh,A_n+1h;v_h),v_hX_k,gcurl,h, (3.5b)
    (δn+1tE_h,G_k,ghq_h)curl,g,h+UPk,gcurl,h(δn+1tE_h),[Pk,gcurl,hA_nh,Pk+1,ggrad,hq_h]=0,q_hX_k,ggrad,h. (3.5c)

    We refer the reader to [2, Section 4] for a discussion on the choice of the initial conditions (A_0h,E_0h), and also for alternative choices to the fully implicit time stepping selected here.

    In (3.5b), N{N1,N2} is one of the following two discretisations of the nonlinear terms in the right-hand side of (3.3b):

    N1(A_nh,A_n+1h;v_h):=(C_k,ghA_n+1h,[A_n+12h,v_h]div,k,h)div,g,h+(12[A_n+1h,A_n+1h]div,k,h,C_k,ghv_h+[A_n+12h,v_h]div,k,h)div,g,h, (3.6)
    N2(A_nh,A_n+1h;v_h):=UCk,ghA_n+1h,[Pk,gcurl,hA_n+12h,Pk,gcurl,hv_h]+U12[Pk,gcurl,hA_n+1h,Pk,gcurl,hA_n+1h],Ck,ghv_h+[Pk,gcurl,hA_n+12h,Pk,gcurl,hv_h]. (3.7)

    Above, we have set A_n+12h=12(A_nh+A_n+1h). Moreover, in N1, we have made use of the discrete version [,]div,k,h:(X_k,gcurl,h)2X_k,gdiv,h of the map (3.2), defined for all v_h,w_hX_k,gcurl,h through its components by:

    2([v_h,w_h]div,k,h)F=πkP,F([γk,gt,Fv_F,γk,gt,Fw_F]nF)Pk(F)g,FFh, (3.8a)
    ([v_h,w_h]div,k,h)G,T=πk1G,T([Pk,gcurl,Tv_T,Pk,gcurl,Tw_T])Gk1(T)g,TTh, (3.8b)
    ([v_h,w_h]div,k,h)cG,T=πc,kG,T([Pk,gcurl,Tv_T,Pk,gcurl,Tw_T])Gc,k(T)g,TTh. (3.8c)

    In N2 we have used the global piecewise polynomial curl Ck,gh defined by patching the element curls: (Ck,ghv_h)|T=Ck,gTv_T for all TTh and v_hX_k,gcurl,h.

    Remark 2 (Motivation for the discretisation of the nonlinear terms). The nonlinear terms in the right-hand side of (3.3b) are

    Ucurl A,[A,v]+U12[A,A],curl v+[A,v]. (3.9)

    When discretising these terms, the continuous fields A,vH(curl;U)g are replaced by fully discrete objects A_h,v_hX_k,gcurl,h, and we have to give meaning to the terms in (3.9) after this substitution – which is not straightforward since X_k,gcurl,h is not a subspace of H(curl;U)g.

    Applying the standard DDR procedure on (3.9), we build these terms by replacing the inner product U, and differential curl  by the corresponding discrete notions found in the LASDDR complex. The only missing element is a discrete version of the bracket [,] on X_k,gcurl,h×X_k,gcurl,h which produces consistent discrete approximations in X_k,gdiv,h. This is what (3.8) provides, and this approach leads to N1.

    Another approach to discretising (3.9) is in a sense more straightforward (but only works because none of these terms, in the weak formulation, comes from integrating-by-parts the strong form of the model): Since we can reconstruct piecewise polynomial reconstructions and curls from elements in X_k,gcurl,h, we can decide to simply substitute all the terms A,v by these polynomial reconstruction based on A_h,v_h and keep the other elements (integrals, brackets) exactly the same. This idea leads to N2.

    Remark 3 (Discretisation of the linear terms). The same way we used, in N2, the piecewise polynomial potentials and element curl, we could consider replacing, in (3.5b), the term (C_k,ghA_n+1h,C_k,ghv_h)div,g,h with UCk,ghA_n+1h,Ck,ghv_h. This would however not lead to a suitable scheme, for the following reason.

    Consider the pure Maxwell model, discretised using a linear unconstrained scheme (that is, (3.5a)–(3.5b) without the terms involving λ_h, without the nonlinear terms and with g=R with the trivial Lie bracket):

    4δn+1tA_h=E_n+1h, (3.10a)
    (δn+1tE_h,v_h)curl,g,h=(C_k,ghA_n+1h,C_k,ghv_h)div,g,h. (3.10b)

    Using the results in [12, Section 6] it can easily be shown that, for a smooth enough potential A, solution of the continuous model, the consistency error (as defined in [31]) of the scheme satisfies

    Eh(A;v_h)CA(δt+hk+1)(v_hcurl,g,h+C_khv_hdiv,g,h), (3.11)

    where curl,g,h and div,g,h denote the norms respectively associated with the inner products (,)curl,g,h and (,)div,g,h. The scheme (3.10) is stable for the norm curl,g,h+C_khdiv,g,h, so (3.11) and the 3rd Strang Lemma [31] provide an O(δt+hk+1) error estimate.

    However, replacing (C_k,ghA_n+1h,C_k,ghv_h)div,g,h with UCk,ghA_n+1h,Ck,ghv_h in (3.10b) results in a scheme that is stable for the weaker norm curl,g,h+Ck,ghL2(U) (which does not control, in particular, the face curls). On the other hand, the consistency estimate remains (3.11), in the stronger norm. As a consequence, this estimate and the weaker stability cannot be combined together to obtain error estimates on the scheme. As a matter of fact, numerical tests (not reported in this paper) show that, on some mesh families, this alternative scheme does not converge as the mesh size and time step are refined.

    We define the discrete conserved quantity through the constraint functional Cn:X_k,ggrad,hR:

    Cn(q_h):=(E_nh,G_k,ghq_h)curl,g,h+UPk,gcurl,hE_nh,[Pk,gcurl,hA_nh,Pk+1,ggrad,hq_h],q_hX_k,ggrad,h. (3.12)

    Proposition 4 (Constraint preservation). For any choice of N, if (A_nh,E_nh,λ_nh) solve (3.5) then, for all q_hX_k,ggrad,h, the quantity Cn(q_h) is independent of n.

    Proof. We note that the proof for the preservation of constraint in [2, Proposition 7] is in fact independent of the discretisation of the second equation (3.5b), and also applies in the case for general k (see [2, Section 6.2]).

    To state the energy dissipation property, we introduce the discrete magnetic fields based on B. Their nature depends on the chosen discretisation of the nonlinear terms in (3.3b). If N=N1, exploiting the discrete bracket [,]div,k,h we can define the discrete magnetic field as an element of X_k,gcurl,h:

    B_nh,1:=C_k,ghA_nh+12[A_nh,A_nh]div,k,hX_k,gcurl,h.

    If N=N2, the nonlinear terms being discretised as piecewise polynomial functions, the discrete magnetic field has the same nature:

    Bnh,2:=Ck,ghA_nh+12[Pk,gcurl,hA_nh,Pk,gcurl,hA_nh]Pk(Th)g. (3.13)

    Proposition 5 (Energy dissipation). If the initial conditions (A_0h,E_0h) are such that C00, then we have the decay of energy in the sense that, for all n,

    12E_n+1h2curl,g,h+Bn+112E_nh2curl,g,h+Bn, (3.14)

    where

    Bn:={12B_nh,12div,g,hifN=N1,12Bnh,22L2(U)g+12sgdiv,h(C_k,ghA_nh,C_k,ghA_nh)ifN=N2,

    where sgdiv,h is the stabilisation form involved in the definition of the inner product (,)div,g,h (that is, the tensorisation of sdiv,h defined by (2.1)).

    Proof. The proof for N=N1 is identical to the one for k=0 done in [2, Proposition 8] (see also [2, Section 6.2]).

    Let us consider the case N=N2. Choosing v_h=E_n+1h in (3.5b) and multiplying by δtn+12, the first term in the LHS is

    (E_n+1hE_nh,E_n+1h)curl,g,h=12E_n+1h2curl,g,h12E_nh2curl,g,h+12E_n+1hE_nh2curl,g,h,

    while the remaining two form the constraint Cn+1(λ_n+1h), that vanishes by Proposition 4 and the assumption that C00.

    On the RHS, we use (3.5a) to substitute instead v_h=δn+1tA_h, noting the cancellation of δtn+12 after multiplying. Expanding the discrete L2-product by its definition and invoking [12, Proposition 7] (which can easily be extended to the SDDR complex using [1, Eq (2.2)]) to write Pk,gdiv,hC_k,gh=Ck,gh, the first term is

    (C_k,ghA_n+1h,C_k,gh(A_nhA_n+1h))div,g,h=UCk,ghA_n+1h,Ck,gh(A_nhA_n+1h)+sgdiv,h(C_k,ghA_nh,C_k,gh(A_nhA_n+1h)).

    Combining with the integrals in N2 (see (3.7)), expanding A_n+12h=12(A_nh+A_n+1h), recalling the definition (3.13) of Bh,2, then using the symmetry and bilinearity of the bracket (3.2), the RHS becomes

    (C_k,ghA_n+1h,C_k,gh(A_nhA_n+1h))div,g,h+N2(A_nh,A_n+1h;A_nhA_n+1h)=UBn+1h,Ck,gh(A_nhA_n+1h)+[Pk,gcurl,h12(A_nh+A_n+1h),Pk,gcurl,h(A_nhA_n+1h)]+sgdiv,h(C_k,ghA_n+1h,C_k,gh(A_nhA_n+1h))=UBn+1h,Ck,ghA_nh+12[Pk,gcurl,hA_nh,Pk,gcurl,hA_nh]Ck,ghA_n+1h12[Pk,gcurl,hA_n+1h,Pk,gcurl,hA_n+1h]+sgdiv,h(C_k,ghA_n+1h,C_k,gh(A_nhA_n+1h))=UBn+1h,BnhBn+1h+sgdiv,h(C_k,ghA_n+1h,C_k,gh(A_nhA_n+1h))=12(Bnh2L2(U)gBn+1h2L2(U)gBn+1hBnh2L2(U)g+sgdiv,h(C_k,ghA_nh,C_k,ghA_nh)sgdiv,h(C_k,ghA_n+1h,C_k,ghA_n+1h)sgdiv,h(C_k,ghA_n+1hC_k,ghA_nh,C_k,ghA_n+1hC_k,ghA_nh)),

    where the conclusion follows by applying the relation b(x,yx)=12b(y,y)12b(x,x)12b(yx,yx) to the symmetric bilinear forms b=(,)L2(U)g and b=sgdiv,h.

    Finally arranging both side of the equation, moving the pure n+1 terms to the left and the rest to the right, we get

    12E_n+1h2curl,g,h+Bn+1=12E_nh2curl,g,h+Bn12E_n+1hE_nh2curl,g,h12Bn+1hBnh2L2(U)g12sgdiv,h(C_k,ghA_n+1hC_k,ghA_nh,C_k,ghA_n+1hC_k,ghA_nh),

    proving the statement, since the norm and sgdiv,h are both positive semidefinite.

    We cover in this section the broad mechanisms of how the schemes are implemented. For our numerical simulations, this implementation was done in the HArDCore3D library (see https://github.com/jdroniou/HArDCore) starting from the serendipity DDR spaces and operators described in Section 2. This library contains a fully automated construction of these objects, including the computation of the degree depletions P defined at the start of Section 2.2.

    We first eliminate A_n+1h by using the first equation (3.5a) to write A_n+1h=A_nhδtn+12E_n+1h. Denoting the resulting equation by F(Xn+1)=b, where Xn+1 represents the combined vector of E_n+1h,λn+1h, we then employ the iterative Newton method to find a solution up to an accuracy of ϵ. The quantity A_n+1h, which is required at the next time step, is finally recovered via back substitution.

    At a single time step n, the most costly part of this process lies in the repeated assembly and resolution of the linear Newton problem: Find vectors (Xn+1,i+1)iN such that

    DFXn+1,i(Xn+1,i+1Xn+1,i)=bF(Xn+1,i) until F(Xn+1,i+1)bl2bl2ϵ.

    Although the derivative matrix DFXn+1,i is simple to determine because F is multilinear, it must be rebuilt at every iteration, with terms stemming from bilinear, trilinear, and even quadrilinear forms (see the product of bilinear brackets in the last terms of (3.6) and (3.7)). In the rest of this section, we discuss how to perform these calculations without it becoming too expensive in either memory space or computational time.

    The other major expense is resolving the linear system, for which we use the Intel MKL PARADISO library (see https://software.intel.com/en-us/mkl), which provides a multi-threaded direct solver. An efficient technique to reduce this solver cost is to apply to the linear systems the static condensation process, which eliminates all elemental unknowns of the system prior to solving. This is made possible by the specific stencil resulting from a hybrid method like (S)DDR, which couples the unknowns inside one element only with the unknowns on the faces, edges and vertices of that element (inter-element unknowns are never directly coupled). We emphasize here the difference between static condensation and the serendipity DDR process. Both reduce the number of degrees of freedom, but the SDDR spaces and operators are leaner from the start; as a result, any scheme built from it will see an improved performance in every aspect of the implementation at no additional cost. In contrast, static condensation reduces the number of unknowns only after all contributions are assembled, and thus its effect is more limited as it only reduces the cost of solving the global system, not the cost of assembling that system. Additionally, it must be repeated every iteration, with some overhead (solving a smaller linear system in each element) each time. Finally, we should highlight that, since static condensation only eliminates unknowns in the elements while serendipity also eliminates degrees of freedom on the edges/faces, the linear systems resulting from a statically condensed DDR scheme remain larger in general than the linear systems resulting from a statically condensed SDDR scheme.

    The numerical construction of the LASDDR complex primarily consists of wrapping a layer of matrix tensorisation around the existing SDDR code. For a code like HArDCore3D based on the Eigen3 library (see http://eigen.tuxfamily.org), this is easily achieved using the KroneckerProduct functionality.

    Fixing a basis (eI)I of the d-dimensional Lie algebra g, each Lie algebra-valued degree of freedom can by expressed by d real values. In other words, we can think of an element of an LASDDR space as being made up of d SDDR vectors, one for each basis eI; i.e., v_hv_IheI. Fixing an ordering that combines everything into a single vector fixes the physical interpretation of all the remaining operators. We choose to store the values associated to each mesh entity (vertex, edge, face, element) sequentially, but for ease of distinguishing the significance of each entry, they are doubly indexed: (v_ih)I. The lowercase letter numbers the mesh entity it originates from, and the capital letter labels the Lie algebra basis it is attached to. As an example, if d=3, we have the following structures:

    v_h=[(v_1h)1(v_1h)2(v_1h)3(v_2h)1],v_ih=[(v_ih)1(v_ih)2(v_ih)3],v_Ih=[(v_1h)I(v_2h)I(v_3h)I(v_4h)I].

    Then, considering a linear LASDDR operator Lg, the matrix representation Lg must by definition act as Lg(v_h)L(v_Ih)eI, where L is the corresponding SDDR matrix operator. From some basic arithmetic, we can conclude that Lg has the form

    Lg=LId=[L11IdL12IdL21IdL22Id],

    where Id is the d×d identity matrix. For bilinear operators such as the discrete inner products (,),g,h, and the bracket terms which we deal with in the next section, the idea is very much the same; the difference lies in the usage of a more general d×d matrix M in place of Id, indicating an interaction of the Lie algebra bases. For example, denoting the LASDDR (resp. SDDR) product matrix by Bg (resp. B), with action previously defined as (v_h)TBg(w_h)=((v_Ih)TB(w_Jh))eI,eJ, the M becomes evidently the mass matrix of the Lie algebra:

    M=[e1,e1e1,e2e2,e1e2,e2],Bg=BM=[B11MB12MB21MB22M]. (4.1)

    The nonlinear terms in both schemes create operators which can not be encoded by a single matrix, but rather (local or global) 3 or 4-dimensional arrays:

    TPk,gcurl,T,[Pk,gcurl,T,Pk+1,ggrad,T],(,[,]div,k,h)div,g,h,([,]div,k,h,[,]div,k,h)div,g,h,TCk,gT,[Pk,gcurl,T,Pk,gcurl,T],T[Pk,gcurl,T,Pk,gcurl,T],[Pk,gcurl,T,Pk,gcurl,T].

    The tools available in Eigen3 for dealing with these objects are not nearly as developed as the ones for matrices. In most cases, the multidimensional storage is done using the Boost.MultiArray library (see https://www.boost.org/doc/libs/1_61_0/libs/multi_array/doc/index.html), but the Eigen::Map function is used to interpret the data, so that we can still perform the usual matrix operations.

    These generic objects are independent of time, so seemingly the most time efficient method would be to pre-compute them once and for all, and recall them when necessary. Unfortunately, the extra dimensionalities mean these operators are much larger than the (bi)linear ones appearing in LASDDR; in fact the memory usage to store these terms grows exponentially with the number of entries. The Lie algebra tensorisation only exacerbates this problem, even accounting for the many symmetries that could be exploited. This memory issue is particularly sensitive in an implementation – such as ours (which follows the HArDCore general strategy) – that assumes that each element can have its own geometry, which forces the local arrays to be computed/stored independently for each element (in a situation where the mesh elements can be classified using a few reference elements, all memory issues disappear as only local multilinear maps in reference elements need to be stored). In this context, the immense amount of memory required to store just a single one of these global maps means that there is no choice but to recalculate them at each time step and locally (mesh entity by mesh entity) as needed.

    Another important effect on the runtime lies in the order in which some tensorisation-related computations are performed. Taking the sum of smaller matrices multiple times is sometimes preferable to doing it once with larger matrices (which often have lots of zeros). Therefore, delaying the tensorisation until after the vectors have been evaluated can improve both the memory usage and the speed, even though some calculations and the tensorisation have to be repeated.

    We furnish these ideas with an example for the nonlinear terms of the form

    TPk,gcurl,T,[Pk,gcurl,Tv_T,Pk+1,ggrad,T],

    in which v_T is a given vector in X_k,gcurl,T. This term is represented by a coefficient matrix with entries (doubly indexed by ((i,I),(k,K))) given by:

    TPk,gcurl,T(ϕi)I,[Pk,gcurl,Tv_T,Pk+1,ggrad,T(ψk)K],

    where the rows and columns range over the basis vectors, that are defined as (ϕi)IϕieI (resp. (ψk)K) where (ϕi)i is a basis for X_kcurl,T (resp. (ψk)k a basis of X_kgrad,T). Pulling the vector out (recall that we use implicit summation), and using the definition of the L2-product, this can be viewed as

    (v_jT)Jvector(TPkcurl,TϕiPkcurl,TϕjPk+1grad,Tψk)eI,[eJ,eK]trilinear form M(i,I),(j,J),(k,K),

    where M is indeed a trilinear form (indices ((i,I),(j,J),(k,K))), represented by a 3-dimension block of d3×(dim(X_kcurl,T))×(dim(X_kcurl,T))×(dim(X_kgrad,T)) coefficients. As mentioned, although M would be useful to calculate in itself, since it can then be used to find other terms in the scheme, performing the contraction with each vector v_T is actually quite slow because of the large matrix sums.

    Instead we do something less intuitive, by combining the vector with the integral portion of the product first:

    (v_jT)J(TPkcurl,TϕiPkcurl,TϕjPk+1grad,Tψk)MJi,keI,[eJ,eK]NI,J,K. (4.2)

    These integral coefficients represent the smaller SDDR trilinear form T(Pkcurl,T)(Pkcurl,T)(Pk+1grad,T); this term is first combined (through the sum over j) with the vector (v_T)J, before performing the tensorisation with NI,J,K (on (i,I),(k,K)), and finally taking the much shorter matrix sum over J. This delay in combining the Lie algebra indices initially seems like extra work, as this MJi,k sum is unique to each vector (v_T)J, and so the tensorisation must be re-done each time, but testing showed that the tradeoff for smaller matrix sums is worth it in this case.

    The [,] bracket is dealt with differently because it can appear twice in a single product. In this double bracket case, if we use the same summation methods as in (4.2), then we have the appearance of quadrilinear forms instead of trilinear forms, that would require the computation of a 4-dimensional array. To avoid the extra dimension, we treat the bracket terms as independent objects, that can be manipulated separately to the product matrix. For example, in the first discretisation N1 described in (3.6), two terms involve this bracket, which we compute the following way (underbrace denotes the dimension of the array representation with the implied transposition, and we write formal products to show how the calculation could be decomposed in the code):

    ([v_h,]div,k,h,[w_h,]div,k,h)div,g,h=[v_h,]div,k,hmatrix (,)div,g,hmatrix [w_h,]div,k,hmatrix, (4.3)
    ([v_h,w_h]div,k,h,[,]div,k,h)div,g,h=[v_h,w_h]div,k,hvector (,)div,g,hmatrix [,]div,k,h3-dim array. (4.4)

    We note that the map [,]div,k,h:(X_k,gcurl,h)2X_k,gdiv,h is bilinear, but requires an extra dimension in the corresponding array to represent the output in X_k,gdiv,h. Thus the terms [v_h,]div,k,h and [w_h,]div,k,h are indeed represented by matrices, calculated using the same principle (described in (4.2)) of avoiding the tensorisation until the last step. The order of operations is also crucial in (4.4); the vector-matrix multiplication must come first, to ensure that the 3-dimensional array is only contracted with a vector. We stress again however, that the full set of [,]div,k,h coefficients is never constructed, and all calculations are done in the way of (4.2).

    The same idea is implemented in the second discretisation N2 (see (3.7)), by introducing a basis for P2k(T), and working with the map

    [Pk,gcurl,T,Pk,gcurl,T]:(X_k,gcurl,T)2P2k(T)g.

    The numerical decomposition of the term analogous to (4.3) is

    [Pk,gcurl,Tv_,Pk,gcurl,T]matrix(T,)matrix[Pk,gcurl,Tw_,Pk,gcurl,T]matrix, (4.5)

    where the integral is realised by the tensorisation of the mass matrix of the basis on P2k(T), and the mass matrix of the Lie algebra (see (4.1)). With orthonormal choices of bases of P2k(T) and g (which is the default in the HArDCore library), the calculations here are greatly simplified; the components of [Pk,gcurl,T,Pk,gcurl,T] can be found using only the triple integrals of the bases of Pk(T) and P2k(T) (without requiring to solve a linear system afterwards), and the integral in (4.5) is just given by the identity matrix

    Id(2k+1)=I2k+1Id.

    We present a numerical comparison of the convergence of the two schemes, as well as the exact constraint preservation that is expected. The tests were performed on a Dell Precision 5820 desktop with a 14-core Intel Xeon processor (W-2275) clocked at 3.3 GHz and equipped with 128 GB of DDR4 RAM, running Ubuntu 22.04.1 LTS. The discretisation setting is identical to that of [2, Section 5], which only contained tests for k=0 of the scheme pertaining to N1. Here we expand on these results for higher orders (k=0,1,2), and also consider the performance in relation to the second discretisation.

    Let us recall the setting of these tests. The Lie algebra is g=su(2), with basis

    e1=i2[0110],e2=i2[0ii0],e3=i2[1001].

    The time interval is [0, 1] and the space domain is the unit cube (0,1)3; the spatial discretisation is based on three families of Voronoi, tetrahedral, and cubic cell meshes. For each mesh of size h, the time interval is uniformly{\rm{div}}ided into max{10,5/hk+1} time steps; given that we use an implicit time discretisation, the expected rate of convergence is in δt+hk+1, and the choice of time step is designed so that, when plotted against h, the errors should decay as hk+1. To set non-zero initial conditions, and to assess the convergence properties of the schemes, we select a manufactured solution based on

    A(t)=[0.5cos(t)sin(πx)cos(πy)cos(πz)cos(t)cos(πx)sin(πy)cos(πz)0.5cos(t)cos(πx)cos(πy)sin(πz)]e1+[0.5sin(t)sin(πx)cos(πy)cos(πz)sin(t)cos(πx)sin(πy)cos(πz)0.5sin(t)cos(πx)cos(πy)sin(πz)]e2+[0.5sin(t)sin2(πy)cos(t)cos2(πz)0.5sin(t)cos2(πx)]e3, (5.1)

    from which E(t) is calculated using (3.3a). Then for all tests in this section, the initial conditions are assumed to be A_0h=I_k,gcurl,hA(0),E_0h=I_k,gcurl,hE(0).

    Remark 6 (Convergence results for λ_h). Although the fields A, E of a solution to the constrained formulation (3.3) solve the Yang–Mills equations, there is no proof that the λ obtained is unique. Testing performed in [2, Section 5] suggest indeed that there are infinitely many solutions; the values obtained for λ_nh are therefore not very instructive, and have been omitted from the graphs. Discussion around the solvability of the linear system deriving from such a scheme can also be found in the cited section; we experienced a similar success, with a worst residual for the linear solver of the order 1e-09.

    In addition, appropriate boundary conditions and forcing terms are introduced to balance the equations (see [2, Section 5.1] for details). The errors for both schemes are measured by calculating the difference E_n+1hI_k,gcurl,hE(1)curl,g,h (resp. A_n+1h,A) at the final time, and dividing by the norm of E_n+1h (resp. A_n+1h). These relative errors are plotted in Figure 1 for E, and Figure 2 for A.

    Figure 1.  Relative errors on E for N1 and N2: Voronoi, tetrahedral and cubic meshes.
    Figure 2.  Relative errors on A for N1 and N2: Voronoi, tetrahedral and cubic meshes.

    We remark immediately that for A, the errors are indistinguishable from the figure alone. The precise difference for the Voronoi and cubic sequences are calculated in Table 1, with the trend applying identically to the tetrahedral family. As either k increases or h decreases, the difference between the errors shrink accordingly, and this is seen also in the errors for E for k=1,2. However for the electric field, there is a more visible separation when k=0, with the N1-based discretisation performing slightly better. These tests seem to indicate that, overall, both choices N1,N2 lead to acceptable and similar results.

    Table 1.  Difference between the errors of A (N1) and A (N2) for various degrees k on the Voronoi and Cubic meshes.
    Voronoi mesh Cubic mesh
    1 2 3 4 5 1 2 3 4
    k=0 4.36e-3 5.98e-4 5.02e-4 1.67e-5 1.43e-5 1.05e-2 9.97e-4 8.98e-5 1.11e-5
    k=1 1.41e-3 8.93e-5 1.47e-5 6.23e-6 2.57e-6 9.99e-4 1.05e-4 7.04e-6 4.35e-7
    k=2 9.16e-5 3.46e-6 3.4e-7 6e-8 - 1.01e-4 4.97e-6 1.96e-7 -

     | Show Table
    DownLoad: CSV

    The schemes converge on the Voronoi and cubic meshes at the expected rate of k+1 for both E and A, but this behaviour was not as stable for E on the tetrahedral line, where we see a rate that jumps around 3 for every k. This might be due to the asymptotic regime not been reached yet on these meshes (we note that, for k=0 for example, the simulation on the finest mesh seem to indicate that the convergence rate slows down). The magnitude of these errors are still ordered in the expected way, except for the coarsest cubic mesh in Figure 1, where it is corrected after the first refinement.

    The tests for the preservation of constraint are run with the same initial conditions as the convergence tests. For proper solutions to the Yang–Mills equations, and for Proposition 5, it is expected that these discrete fields prescribe a small or vanishing initial constraint C0. This can be achieved by projecting the initial conditions (see [2]), however for the purpose of testing Proposition 4, which does not depend on the initial values, it suffices to measure the maximum change in the functional CnC0 over all times. The differences are presented in Table 2 for selected meshes from each sequence. We see for both methods that the constraint is stationary up to machine precision, with the small drift coming from rounding errors present at each iteration.

    Table 2.  Maximum over n of the difference CnC0 measured in the dual norm.
    Voronoi mesh Tetrahedral mesh Cubic mesh
    N1 1 3 2 4 1 3
    k=0 8.47329e-15 3.05676e-14 2.06362e-14 4.75412e-14 3.52318e-15 2.16527e-14
    k=1 1.4144e-13 8.93075e-13 3.67781e-13 1.81426e-12 2.33678e-14 6.44019e-13
    k=2 3.69918e-12 1.18207e-10 3.82037e-12 2.77407e-11 4.45312e-14 6.48608e-12
    N2 1 3 2 4 1 3
    k=0 8.16124e-15 3.13617e-14 2.01667e-14 4.77633e-14 4.22851e-15 2.11083e-14
    k=1 9.8531e-14 8.83056e-13 3.69107e-13 1.81787e-12 2.52977e-14 6.48934e-13
    k=2 4.16428e-12 7.99416e-11 3.81537e-12 2.77391e-11 4.51672e-14 6.48285e-12

     | Show Table
    DownLoad: CSV

    For reference, we also provide in Table 3 a comparison of the runtimes for the two different choices of discretisation of the nonlinear tests. The performances of both schemes are very comparable on a variety of meshes and degrees k, with the exception of a 10% difference in favour of N1 for k=2 on the Tetrahedral meshes, that shows up consistently through our tests. This difference is likely due to the nontrivial calculation attached to each face component (3.8a) in the definition of the discrete bracket of N1. These calculations are necessary because the face values also contribute to the L2-product, but they result in a larger dependency of the runtime on the number of faces in a particular mesh. In comparison, the N2 discretisation is less affected by the shape of the elements; numerically, an extra face only represents an increase in size of the SDDR operators (which equally affects N1) used in the integrals. This is supported by the results for the Voronoi sequence, that has a higher face to element ratio than the tetrahedral sequence, where N2 starts to slightly outperform N1.

    Table 3.  Total runtime for each test in seconds.
    Voronoi mesh Tetrahedral mesh Cubic mesh
    N1 1 3 2 4 1 3
    k=0 5.00865 145.77 4.70017 21.1378 0.564665 35.2541
    k=1 35.9231 2836.36 50.997 360.943 3.58296 588.679
    k=2 198.435 43303.9 578.499 5732.1 14.6638 14337.4
    N2 1 3 2 4 1 3
    k=0 4.57515 135.231 4.16998 19.7708 0.53204 32.879
    k=1 34.2036 2814.14 51.3249 340.817 3.62877 631.546
    k=2 190.447 42083.9 634.162 6421.87 13.8524 14414.9

     | Show Table
    DownLoad: CSV

    We designed two schemes for the Yang–Mills equations based on the DDR method, both displaying arbitrary orders of accuracy and applications on generic polyhedral meshes. Thanks to the complex property of DDR and to the usage of a Lagrange multiplier, both schemes also preserve a discrete nonlinear constraint deriving from the Yang–Mills equations, and satisfy energy bounds. The schemes only differ in their treatment of the nonlinearity akin to a cross product combined with the Lie bracket for Lie algebra-valued vector functions. The first scheme reconstructs a discrete version of the continuous product bracket, that can then be used in the discrete L2-products of the DDR complex. The second scheme uses the DDR potential reconstructions to get polynomials in each element, on which the continuous product bracket can be applied. We show how a clever ordering of the algebraic operations in the assembly of the schemes can help keep the computational cost at a reasonable level, despite needing to deal with multidimensional arrays and high system sizes due to the Lie algebra components. Numerical results are presented which show a good behaviour and an expected rate of convergence, with respect to the mesh size, in hk+1.

    The authors declare they have not used Artificial Intelligence (AI) tools in the creation of this article.

    Funded by the European Union (ERC, NEMESIS, No. 101115663). Views and opinions expressed are however those of the authors only and do not necessarily reflect those of the European Union or the European Research Council Executive Agency. Neither the European Union nor the granting authority can be held responsible for them.

    The authors declare no conflicts of interest.



    [1] D. A. Di Pietro, J. Droniou, Homological- and analytical-preserving serendipity framework for polytopal complexes, with application to the DDR method, ESAIM: M2AN, 57 (2023), 191–225. https://doi.org/10.1051/m2an/2022067 doi: 10.1051/m2an/2022067
    [2] J. Droniou, T. A. Oliynyk, J. J. Qian, A polyhedral discrete de rham numerical scheme for the Yang–Mills equations, J. Comput. Phys., 478 (2023), 111955. https://doi.org/10.1016/j.jcp.2023.111955 doi: 10.1016/j.jcp.2023.111955
    [3] D. N. Arnold, R. S. Falk, R. Winther, Finite element exterior calculus, homological techniques, and applications, Acta Numer., 15 (2006), 1–155. https://doi.org/10.1017/S0962492906210018 doi: 10.1017/S0962492906210018
    [4] D. Arnold, Finite element exterior calculus, Society for Industrial and Applied Mathematics, 2018. https://doi.org/10.1137/1.9781611975543
    [5] D. N. Arnold, R. S. Falk, R. Winther, Finite element exterior calculus: from Hodge theory to numerical stability, Bull. Amer. Math. Soc., 47 (2010), 281–354. https://doi.org/10.1090/S0273-0979-10-01278-4 doi: 10.1090/S0273-0979-10-01278-4
    [6] A. Gillette, K. Hu, S. Zhang, Nonstandard finite element de Rham complexes on cubical meshes, Bit Numer. Math., 60 (2020), 373–409. https://doi.org/10.1007/s10543-019-00779-y doi: 10.1007/s10543-019-00779-y
    [7] D. Arnold, K. Hu, Complexes from complexes, Found. Comput. Math., 21 (2021), 1739–1774. https://doi.org/10.1007/s10208-021-09498-9
    [8] D. Di Pietro, M. Hanot, A discrete three-dimensional{\rm{div}}div complex on polyhedral meshes with application to a mixed formulation of the biharmonic problem, arXiv, 2023. https://doi.org/10.48550/arXiv.2305.05729
    [9] L. Beirão da Veiga, F. Brezzi, L. D. Marini, A. Russo, H(div) and H(curl)-conforming VEM, Numer. Math., 133 (2016), 303–332. https://doi.org/10.1007/s00211-015-0746-1 doi: 10.1007/s00211-015-0746-1
    [10] L. Beirão da Veiga, F. Brezzi, F. Dassi, L. D. Marini, A. Russo, A family of three-dimensional virtual elements with applications to magnetostatics, SIAM J. Numer. Anal., 56 (2018), 2940–2962. https://doi.org/10.1137/18M1169886 doi: 10.1137/18M1169886
    [11] D. A. Di Pietro, J. Droniou, F. Rapetti, Fully discrete polynomial de Rham sequences of arbitrary degree on polygons and polyhedra, Math. Models Methods Appl. Sci., 30 (2020), 1809–1855. https://doi.org/10.1142/S0218202520500372 doi: 10.1142/S0218202520500372
    [12] D. A. Di Pietro, J. Droniou, An arbitrary-order discrete de Rham complex on polyhedral meshes: exactness, Poincaré inequalities, and consistency, Found. Comput. Math., 23 (2023), 85–164. https://doi.org/10.1007/s10208-021-09542-8 doi: 10.1007/s10208-021-09542-8
    [13] D. A. Di Pietro, J. Droniou, An arbitrary-order method for magnetostatics on polyhedral meshes based on a discrete de Rham sequence, J. Comput. Phys., 429 (2021), 109991. https://doi.org/10.1016/j.jcp.2020.109991 doi: 10.1016/j.jcp.2020.109991
    [14] D. A. Di Pietro, J. Droniou, A discrete de Rham method for the Reissner-Mindlin plate bending problem on polygonal meshes, arXiv, 2021. https://doi.org/10.48550/arXiv.2105.11773
    [15] D. A. Di Pietro, J. Droniou, A fully discrete plates complex on polygonal meshes with application to the Kirchhoff–Love problem, Math. Comp., 92 (2023), 51–77. https://doi.org/10.1090/mcom/3765 doi: 10.1090/mcom/3765
    [16] L. Chen, X. Huang, Decoupling of mixed methods based on generalized Helmholtz decompositions, SIAM J. Numer. Anal., 56 (2018), 2796–2825. https://doi.org/10.1137/17M1145872 doi: 10.1137/17M1145872
    [17] L. Chen, X. Huang, Finite elements for{\rm{div}}- and{\rm{div}}div-conforming symmetric tensors in arbitrary dimension, SIAM J. Numer. Anal., 60 (2022), 1932–1961. https://doi.org/10.1137/21M1433708 doi: 10.1137/21M1433708
    [18] L. Beirão da Veiga, F. Dassi, D. A. Di Pietro, J. Droniou, Arbitrary-order pressure-robust DDR and VEM methods for the Stokes problem on polyhedral meshes, Comput. Meth. Appl. Mech. Eng., 397 (2022), 115061. https://doi.org/10.1016/j.cma.2022.115061 doi: 10.1016/j.cma.2022.115061
    [19] L. Beirão da Veiga, F. Dassi, G. Vacca, The stokes complex for virtual elements in three dimensions, Math. Models Methods Appl. Sci., 30 (2020), 477–512. https://doi.org/10.1142/S0218202520500128 doi: 10.1142/S0218202520500128
    [20] S. H. Christiansen, R. Winther, On constraint preservation in numerical simulations of Yang–Mills equations, SIAM J. Sci. Comput., 28 (2006), 75–101. https://doi.org/10.1137/040616887 doi: 10.1137/040616887
    [21] Y. Berchenko-Kogan, A. Stern, Charge-conserving hybrid methods for the Yang–Mills equations, SMAI J. Comput. Math., 7 (2021), 97–119. https://doi.org/10.5802/smai-jcm.73 doi: 10.5802/smai-jcm.73
    [22] D. Alic, C. Bona-Casas, C. Bona, L. Rezzolla, C. Palenzuela, Conformal and covariant formulation of the Z4 system with constraint-violation damping, Phys. Rev. D, 85 (2012), 064040. https://doi.org/10.1103/PhysRevD.85.064040 doi: 10.1103/PhysRevD.85.064040
    [23] O. Brodbeck, S. Frittelli, P. Hübner, O. A. Reula, Einstein's equations with asymptotically stable constraint propagation, J. Math. Phys., 40 (1999), 909–923. https://doi.org/10.1063/1.532694 doi: 10.1063/1.532694
    [24] J. Frauendiener, T. Vogel, Algebraic stability analysis of constraint propagation, Class. Quantum Grav., 22 (2005), 1769. https://doi.org/10.1088/0264-9381/22/9/019 doi: 10.1088/0264-9381/22/9/019
    [25] C. Gundlach, G. Calabrese, I. Hinder, J. M. Martín-García, Constraint damping in the Z4 formulation and harmonic gauge, Class. Quantum Grav., 22 (2005), 3767. https://doi.org/10.1088/0264-9381/22/17/025 doi: 10.1088/0264-9381/22/17/025
    [26] H. Friedrich, Hyperbolic reductions for Einstein's equations, Class. Quantum Grav., 13 (1996), 1451. https://doi.org/10.1088/0264-9381/13/6/014 doi: 10.1088/0264-9381/13/6/014
    [27] A. Anderson, Y. Choquet-Bruhat, J. W. York Jr., Einstein-Bianchi hyperbolic system for general relativity, Topol. Methods Nonlinear Anal., 10 (1997), 353–373. https://doi.org/10.12775/TMNA.1997.037 doi: 10.12775/TMNA.1997.037
    [28] D. A. Di Pietro, J. Droniou, The Hybrid High-Order method for polytopal meshes: design, analysis, and applications, Springer Cham, 2020. https://doi.org/10.1007/978-3-030-37203-3
    [29] F. Bonaldi, D. A. Di Pietro, J. Droniou, K. Hu, An exterior calculus framework for polytopal methods, arXiv, 2023. https://doi.org/10.48550/arXiv.2303.11093
    [30] D. A. Di Pietro, J. Droniou, S. Pitassi, Cohomology of the discrete de Rham complex on domains of general topology, Calcolo, 60 (2023), 32. https://doi.org/10.1007/s10092-023-00523-7 doi: 10.1007/s10092-023-00523-7
    [31] D. A. Di Pietro, J. Droniou, A third Strang lemma and an Aubin-Nitsche trick for schemes in fully discrete formulationn, Calcolo, 55 (2018), 40. https://doi.org/10.1007/s10092-018-0282-3 doi: 10.1007/s10092-018-0282-3
  • Reader Comments
  • © 2024 the Author(s), licensee AIMS Press. This is an open access article distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/4.0)
通讯作者: 陈斌, bchen63@163.com
  • 1. 

    沈阳化工大学材料科学与工程学院 沈阳 110142

  1. 本站搜索
  2. 百度学术搜索
  3. 万方数据库搜索
  4. CNKI搜索

Metrics

Article views(842) PDF downloads(112) Cited by(0)

Other Articles By Authors

/

DownLoad:  Full-Size Img  PowerPoint
Return
Return

Catalog