<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.2 20190208//EN" "http://jats.nlm.nih.gov/publishing/1.2/JATS-journalpublishing1.dtd"><article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" article-type="research-article" dtd-version="1.2" xml:lang="en">
    <front>
        <journal-meta>
            <journal-id journal-id-type="pmc">F1000Research</journal-id>
            <journal-title-group>
                <journal-title>F1000Research</journal-title>
            </journal-title-group>
            <issn pub-type="epub">2046-1402</issn>
            <publisher>
                <publisher-name>F1000 Research Limited</publisher-name>
                <publisher-loc>London, UK</publisher-loc>
            </publisher>
        </journal-meta>
        <article-meta>
            <article-id pub-id-type="doi">10.12688/f1000research.169129.2</article-id>
            <article-categories>
                <subj-group subj-group-type="heading">
                    <subject>Research Article</subject>
                </subj-group>
                <subj-group>
                    <subject>Articles</subject>
                </subj-group>
            </article-categories>
            <title-group>
                <article-title>Physics-Informed Neural Networks without Loss Balancing: A Direct Term Scaling Approach for Nonlinear 1D Problems</article-title>
                <fn-group content-type="pub-status">
                    <fn>
                        <p>[version 2; peer review: 1 approved]</p>
                    </fn>
                </fn-group>
            </title-group>
            <contrib-group>
                <contrib contrib-type="author" corresp="yes">
                    <name>
                        <surname>Theodosiou</surname>
                        <given-names>Theodosios</given-names>
                    </name>
                    <role content-type="http://credit.niso.org/">Conceptualization</role>
                    <role content-type="http://credit.niso.org/">Formal Analysis</role>
                    <role content-type="http://credit.niso.org/">Investigation</role>
                    <role content-type="http://credit.niso.org/">Methodology</role>
                    <role content-type="http://credit.niso.org/">Software</role>
                    <role content-type="http://credit.niso.org/">Supervision</role>
                    <role content-type="http://credit.niso.org/">Validation</role>
                    <role content-type="http://credit.niso.org/">Visualization</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Original Draft Preparation</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Review &amp; Editing</role>
                    <uri content-type="orcid">https://orcid.org/0000-0001-6938-1399</uri>
                    <xref ref-type="corresp" rid="c1">a</xref>
                    <xref ref-type="aff" rid="a1">1</xref>
                </contrib>
                <contrib contrib-type="author" corresp="no">
                    <name>
                        <surname>Rekatsinas</surname>
                        <given-names>Christoforos</given-names>
                    </name>
                    <role content-type="http://credit.niso.org/">Conceptualization</role>
                    <role content-type="http://credit.niso.org/">Formal Analysis</role>
                    <role content-type="http://credit.niso.org/">Investigation</role>
                    <role content-type="http://credit.niso.org/">Methodology</role>
                    <role content-type="http://credit.niso.org/">Validation</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Original Draft Preparation</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Review &amp; Editing</role>
                    <uri content-type="orcid">https://orcid.org/0000-0001-5538-2497</uri>
                    <xref ref-type="aff" rid="a2">2</xref>
                </contrib>
                <aff id="a1">
                    <label>1</label>Dept. of Energy Systems, University of Thessaly - Larissa, Larissa, Thessalia - Larissa, 41500, Greece</aff>
                <aff id="a2">
                    <label>2</label>Institute of Informatics and Telecommunications, Ethniko Kentro Ereunas Physikon Epistemon Demokritos, Athens, Attica, 15341, Greece</aff>
            </contrib-group>
            <author-notes>
                <corresp id="c1">
                    <label>a</label>
                    <email xlink:href="mailto:dozius@uth.gr">dozius@uth.gr</email>
                </corresp>
                <fn fn-type="conflict">
                    <p>No competing interests were disclosed.</p>
                </fn>
            </author-notes>
            <pub-date pub-type="epub">
                <day>24</day>
                <month>1</month>
                <year>2026</year>
            </pub-date>
            <pub-date pub-type="collection">
                <year>2025</year>
            </pub-date>
            <volume>14</volume>
            <elocation-id>1252</elocation-id>
            <history>
                <date date-type="accepted">
                    <day>20</day>
                    <month>1</month>
                    <year>2026</year>
                </date>
            </history>
            <permissions>
                <copyright-statement>Copyright: &#x00a9; 2026 Theodosiou T and Rekatsinas C</copyright-statement>
                <copyright-year>2026</copyright-year>
                <license xlink:href="https://creativecommons.org/licenses/by/4.0/">
                    <license-p>This is an open access article distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
                </license>
            </permissions>
            <self-uri content-type="pdf" xlink:href="https://f1000research.com/articles/14-1252/pdf"/>
            <abstract>
                <p>Physics-Informed Neural Networks (PINNs) have gained significant attention for solving differential equations, yet their efficiency is often hindered by the need for intricate and computationally costly loss-balancing techniques to address residual term imbalance. This paper introduces a direct differential equation term scaling framework that removes the loss-balancing bottleneck entirely. By scaling each term in the governing equations using characteristic physical dimensions, the proposed method ensures numerical consistency across all contributions, eliminating the need for adaptive weighting during training. This not only simplifies the PINN formulation but also improves stability and convergence. The approach is validated on challenging nonlinear one-dimensional elasticity problems, demonstrating that high-accuracy solutions can be obtained with compact neural network architectures and reducing floating-point operations by at least two orders of magnitude. A reverse scaling step restores the solution to the original physical domain, preserving physical interpretability. Unlike existing approaches that modify the loss function during training, the proposed framework operates directly at the level of the governing equations, prior to loss construction. The results demonstrate that direct term scaling transforms PINN training into an efficient, and easily deployable process, paving the way for broader adoption in computational mechanics and other physics-driven domains.</p>
            </abstract>
            <kwd-group kwd-group-type="author">
                <kwd>Compact High-Accuracy PINNs</kwd>
                <kwd>Physics-Consistent Normalization</kwd>
                <kwd>Loss-Balancing Elimination</kwd>
            </kwd-group>
            <funding-group>
                <funding-statement>The author(s) declared that no grants were involved in supporting this work.</funding-statement>
            </funding-group>
        </article-meta>
        <notes>
            <sec sec-type="version-changes">
                <label>Revised</label>
                <title>Amendments from Version 1</title>
                <p>This revised version of the manuscript addresses the comments raised during open peer review. In particular, the presentation of the proposed SEE-PINN framework has been clarified with respect to its motivation, novelty, and positioning relative to existing PINN formulations. Additional explanations have been provided regarding the choice of training settings, validation data, and case-study comparisons, while quantitative error metrics have been included to complement the performance analysis. The discussion section has been revised to more explicitly highlight the advantages, limitations, and implications of the proposed approach. Figures have also been updated. These revisions aim to improve clarity, transparency, and reproducibility, while preserving the original scope and contributions of the study.</p>
            </sec>
        </notes>
    </front>
    <body>
        <sec id="sec1" sec-type="intro">
            <title>1. Introduction</title>
            <p>

                <bold>Current state of the art.</bold> Physics-Informed Neural Networks (PINNs)
                <sup>
                    <xref ref-type="bibr" rid="ref1">1</xref>
                </sup> have emerged as a powerful and innovative approach to solving ordinary and partial differential equations (ODEs/PDEs). By integrating deep or shallow machine learning with physical principles, PINNs approximate solutions to these differential equations through optimization techniques. The process involves constructing a composite loss function that includes several components: (a) the residual of the ODE/PDE, which measures how well the solution satisfies the equation, (b) the initial conditions, which represent the state at the starting point, and (c) the boundary conditions, which describe the behavior at the edges of the domain. This method has shown great promise in various fields, such as fluid dynamics, material science, and inverse problems, because it can effectively handle complex, high-dimensional systems without relying on traditional numerical discretization methods. However, despite their potential, PINNs face a significant challenge: unbalanced loss terms. This issue can slow down convergence, reduce accuracy, and limit scalability.</p>
            <p>The challenge of unbalanced loss terms arises from the fact that different components of the loss function frequently operate on significantly varying scales. For example, the magnitude of the residual may be substantially larger or smaller than that of the boundary condition term. This imbalance results in uneven gradients during the backpropagation process, which may lead to the optimization process favoring one term over the others. Consequently, the neural network may converge to a suboptimal solution or, in some cases, fail to converge entirely. To mitigate this issue, researchers have proposed a range of strategies, each exhibiting distinct advantages and disadvantages.</p>
            <p>Recent advancements have explored regularization strategies and specialized network architectures aimed at enhancing the performance of PINNs. For instance, grouping regularization strategies alter the conventional loss function by implementing distinct scaling factors for each loss term, thereby ensuring that all terms are of similar magnitude and can be optimized concurrently.
                <sup>
                    <xref ref-type="bibr" rid="ref2">2</xref>
                </sup> DN-PINNs
                <sup>
                    <xref ref-type="bibr" rid="ref3">3</xref>
                </sup> have been designed to facilitate an even distribution of multiple back-propagated gradient components throughout the training process. By assessing the relative weights of initial or boundary condition losses in accordance with gradient norms, DN-PINNs dynamically adjust these weights to guarantee balanced training.</p>
            <p>An extension of loss-term scaling involves adaptive weighting schemes, which adjust the weights of loss terms dynamically throughout the training process. For instance, Gaussian probabilistic models employ maximum likelihood estimation to update the weights of each loss term during each training epoch, thereby ensuring that the network concentrates on the most critical terms.
                <sup>
                    <xref ref-type="bibr" rid="ref4">4</xref>
                </sup> Another notable method is the min-max algorithm, which identifies data points that present greater difficulty for training and mandates that the network prioritizes these challenging instances in subsequent iterations.
                <sup>
                    <xref ref-type="bibr" rid="ref5">5</xref>
                </sup> The wbPINN method
                <sup>
                    <xref ref-type="bibr" rid="ref6">6</xref>
                </sup> introduces an adaptive loss weighting strategy and a newly developed loss function that incorporates a correlation loss term and a penalty term to effectively address the interrelationships among the various loss terms
                <italic toggle="yes">.</italic>
            </p>
            <p>Furthermore, weighting schemes based on gradient statistics evaluate the gradients of individual loss terms during backpropagation and make necessary adjustments to their weights, promoting balanced training
                <sup>
                    <xref ref-type="bibr" rid="ref7">7</xref>
                </sup>; this work has been further refined through the introduction of kurtosis-standard deviation-based weighting and combined mean and standard deviation-based schemes, both of which enhance the accuracy of solutions to partial differential equations. Improved adaptive weighting PINNs based on Gaussian likelihood estimation have been applied to solve nonlinear PDEs.
                <sup>
                    <xref ref-type="bibr" rid="ref8">8</xref>
                </sup> Learning rate annealing algorithms also employ gradient statistics during training to balance the contributions of different loss terms, thus, reducing the risk of training failure.
                <sup>
                    <xref ref-type="bibr" rid="ref9">9</xref>
                </sup> Another innovative approach is the Stochastic Dimension Gradient Descent (SDGD) method,
                <sup>
                    <xref ref-type="bibr" rid="ref10">10</xref>
                </sup> which decomposes the gradient of the residual into smaller components corresponding to various dimensions. The SDGD method then randomly samples subsets of these components, thereby ensuring efficient optimization for high-dimensional challenges. Gradient-enhanced PINNs (gPINNs) incorporate gradient information of the PDE residual into the loss function to improve accuracy, especially for problems with steep gradients.
                <sup>
                    <xref ref-type="bibr" rid="ref11">11</xref>
                </sup> Residual-Quantile Adjustment (RQA), reassigns weights based on the distribution of residuals, ensuring a more balanced training process.
                <sup>
                    <xref ref-type="bibr" rid="ref12">12</xref>
                </sup>
            </p>
            <p>Another line of inquiry examines optimization-driven methodologies aimed at balancing loss components. For instance, the augmented Lagrangian relaxation technique converts the constrained optimization problem into a series of max-min problems, enabling the network to adaptively equilibrate each loss term.
                <sup>
                    <xref ref-type="bibr" rid="ref13">13</xref>
                </sup>
            </p>
            <p>Numerical treatments of the PDE and tweaking the neural network architecture is another promising path. The normalized reduced-order physics-informed neural network (nr-PINN)
                <sup>
                    <xref ref-type="bibr" rid="ref14">14</xref>
                </sup> converts the original PDE into a system of normalized lower-order equations. This technique employs scaling factors to mitigate gradient failures resulting from substantial PDE parameters or source functions and introduces a mechanism to automatically fulfill boundary conditions by redefining the outputs of the neural network. Integration of derivative information into the loss function has been further explored in.
                <sup>
                    <xref ref-type="bibr" rid="ref15">15</xref>
                </sup> This study constructs a loss function that includes both the differential equation and its derivative, enabling the network to automatically satisfy boundary conditions without explicit training at boundary points.</p>
            <p>

                <bold>Challenges &amp; Research gap.</bold> Despite their notable success, the selected method categories still encounter various challenges. For instance, PINNs based on Gaussian likelihood estimation struggle with solutions that exhibit sharp changes or discontinuities and gPINNs often require integration with other methods to achieve optimal performance. Moreover, these methodologies heavily depend on machine learning components while often overlooking the treatment of mathematical formulations. As a result, demonstrating their efficacy typically requires complex optimization processes and extensive hyperparameter tuning, which imposes significant computational demands.</p>
            <p>In contrast to existing PINN formulations that attempt to balance loss terms during training, this study proposes a fundamentally different approach based on physically consistent scaling of the governing differential equations prior to loss construction. Contrary to existing methodologies that concentrate on adjusting weights during the training phase or modifying network architectures, our approach involves preprocessing the PDE terms to ensure that they function on comparably scaled values. This strategy alleviates the burden on the machine learning component during the optimization process, thereby enhancing convergence, accuracy, and scalability while preserving the flexibility and robustness inherent in PINNs. By bridging the existing research gap regarding the treatment of unbalanced loss terms, our methodology offers an efficient framework for solving differential equations utilizing PINNs. Furthermore, our proposed method is straightforward to implement, as demonstrated through a step-by-step application to two distinct mechanical problems: an elastic rod and an Euler beam.</p>
            <p>The selection of the elastic rod and Euler&#x2013;Bernoulli beam as case studies is intentional. These problems represent canonical one-dimensional boundary value problems in computational mechanics and are frequently adopted as benchmarks in the PINN literature, allowing direct comparison with existing approaches. Although both problems are one-dimensional, they differ fundamentally in the order of their governing equations (second-order for the rod and fourth-order for the beam) and in the number and nature of boundary conditions. This enables a clear demonstration that the proposed PINN framework is not limited to a specific equation order or boundary-condition structure. Moreover, both formulations naturally allow for spatially varying material and geometric properties, which induce strong imbalance among equation terms and therefore provide an ideal testbed for evaluating the effectiveness of direct differential equation term scaling.</p>
            <p>In both cases, we follow the exact same procedural framework, highlighting the method&#x2019;s consistency and ease of use. The only variation lies in the number of variables and functions that require normalization, reinforcing the generality and adaptability of our approach across different types of differential equations. It has to be noted that the benchmark problem refer to cases with variable material and geometrical properties, which cannot be solved using traditional finite element methods.</p>
            <p>

                <bold>Novelity.</bold> Although several scale-consistent, normalized, or equation-enhanced PINN variants have been proposed in the literature, most of these approaches address imbalance indirectly by introducing adaptive weights, auxiliary optimization strategies, or additional loss terms. In contrast, the proposed Scaled Equation-Enhanced PINN (SEE-PINN) introduces a fundamentally different paradigm: the governing differential equation itself is rescaled prior to training using physically meaningful characteristic quantities. This preprocessing step ensures that all residual terms naturally operate at comparable magnitudes, thereby eliminating the need for loss-balancing mechanisms altogether. As a result, SEE-PINN transforms the PINN training process into a simpler, deterministic, and computationally efficient workflow, without altering the mathematical structure of the problem or introducing additional hyperparameters.</p>
            <p>

                <bold>Paper structure.</bold> The remainder of this paper is organized as follows: Section 2 presents the theoretical foundations of neural networks and PINNs. As these are well-established methodologies, only a brief introduction is provided, with appropriate references for further details. The section also introduces a general approach for scaling terms in differential equations, with specific examples applied to fundamental elasticity problems. Additionally, it explores extensions to more complex cases where analytical solutions are unavailable. Section 3 provides a comprehensive presentation of numerical experiments and results, covering validation cases ranging from simple models with constant properties to those with varying and nonlinear characteristics. The methodology&#x2019;s efficiency is evaluated through comparisons with case studies from the literature. Finally, Section 5 summarizes the key findings, discusses current limitations, and outlines potential directions for future research.</p>
        </sec>
        <sec id="sec2">
            <title>2. Theoretical background</title>
            <sec id="sec3">
                <title>2.1 Neural networks and PINNs</title>
                <p>Neural networks are computational models inspired by the structure and function of biological neural systems, specifically designed to learn complex patterns and relationships from data.
                    <sup>
                        <xref ref-type="bibr" rid="ref16">16</xref>
                    </sup> The fundamental unit of a neural network is the neuron or perceptron, which processes an input 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                        </mml:math>
</inline-formula> to produce an output 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>y</mml:mi>
                                <mml:mo stretchy="true">&#x0302;</mml:mo>
                            </mml:mover>
                        </mml:math>
</inline-formula> through the function 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>y</mml:mi>
                                <mml:mo stretchy="true">&#x0302;</mml:mo>
                            </mml:mover>
                            <mml:mo>=</mml:mo>
                            <mml:mi>&#x03c3;</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>w</mml:mi>
                                <mml:mo>&#x00b7;</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo>+</mml:mo>
                                <mml:mi>b</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula>, where the parameters 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                        </mml:math>
</inline-formula> and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>b</mml:mi>
                        </mml:math>
</inline-formula> are referred to as the weight and bias, respectively, learnt during training.
                    <sup>
                        <xref ref-type="bibr" rid="ref17">17</xref>
                    </sup> The &#x2018;activation function&#x2019; 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>&#x03c3;</mml:mi>
                        </mml:math>
</inline-formula> introduces nonlinearity and the network to model complex problems. Multiple neurons are clustered into groups known as layers, collectively forming a neural network (
                    <xref ref-type="fig" rid="f1">
Figure 1</xref>). Each layer may have several inputs and outputs, which are connected through an extension of the fundamental neuron equation.
                    <disp-formula id="e1">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mover accent="true">
                                    <mml:mi>y</mml:mi>
                                    <mml:mo stretchy="true">&#x0302;</mml:mo>
                                </mml:mover>
                                <mml:mi>j</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mi>&#x03c3;</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:munderover>
                                    <mml:mo>&#x2211;</mml:mo>
                                    <mml:mrow>
                                        <mml:mi>i</mml:mi>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>1</mml:mn>
                                    </mml:mrow>
                                    <mml:msub>
                                        <mml:mi>N</mml:mi>
                                        <mml:mtext mathvariant="italic">in</mml:mtext>
                                    </mml:msub>
                                </mml:munderover>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>i</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>w</mml:mi>
                                    <mml:mi mathvariant="italic">ij</mml:mi>
                                </mml:msub>
                                <mml:mo>+</mml:mo>
                                <mml:msub>
                                    <mml:mi>b</mml:mi>
                                    <mml:mi>j</mml:mi>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>,</mml:mo>
                            <mml:mi>i</mml:mi>
                            <mml:mo>&#x2208;</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mn>1</mml:mn>
                                <mml:mo>,</mml:mo>
                                <mml:msub>
                                    <mml:mi>N</mml:mi>
                                    <mml:mtext mathvariant="italic">out</mml:mtext>
                                </mml:msub>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(1)</label>
</disp-formula>where 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">in</mml:mtext>
                            </mml:msub>
                        </mml:math>
</inline-formula> is the number of inputs of each neuron and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">out</mml:mtext>
                            </mml:msub>
                        </mml:math>
</inline-formula> is the number of neurons of the layer; since each neuron produces a single output, the number of outputs for the layer is equal to the number of neurons, hence the use of 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">out</mml:mtext>
                            </mml:msub>
                        </mml:math>
</inline-formula>. The sequence of calculations from input, through the network, to the output is termed as forward pass.</p>
                <fig fig-type="figure" id="f1" orientation="portrait" position="float">
                    <label>
Figure 1. </label>
                    <caption>
                        <title>The general structure of a neural network.</title>
                    </caption>
                    <graphic id="gr1" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure1.gif"/>
                </fig>
                <p>According to the universal approximation theorem, a neural network has the capacity to approximate any function with arbitrary precision
                    <sup>
                        <xref ref-type="bibr" rid="ref18">18</xref>
                    </sup>; however, the required connectivity of the neurons, referred to as network architecture, must be thoroughly examined. Generally, deep architectures, consisting of a multiple hidden layers, are utilized to capture hierarchical features, whereas shallow networks, which consist of fewer layers, are deployed in scenarios where data or computational resources are limited.
                    <sup>
                        <xref ref-type="bibr" rid="ref19">19</xref>
                    </sup> The training process entails the formulation of a &#x2018;Loss function&#x2019; to compare the outputs generated by the neural network 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="true">
                                    <mml:mi>y</mml:mi>
                                    <mml:mo stretchy="true">&#x0302;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula> against an established ground truth 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>y</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula>, followed by the targeted adjustment of weights and biases.</p>
                <p>In the context of PINNs, neural networks are extended to incorporate physical constraints directly into the training process. Unlike conventional neural networks that rely solely on data-driven learning, PINNs integrate information from governing equations and boundary conditions into the loss function, ensuring that the learned solutions adhere to underlying physical laws.
                    <sup>
                        <xref ref-type="bibr" rid="ref1">1</xref>
                    </sup> The loss function in PINNs comprises three main components: (i) a data loss term that ensures consistency with available observations, (ii) a physics loss term that enforces compliance with differential equations, and (iii) a boundary/initial condition loss term that satisfies prescribed constraints.</p>
                <p>PINNs can be categorized into two main types: data-driven approaches, which infer hidden relationships from experimental data, and physics-driven approaches, which directly solve differential equations while enforcing physical consistency.
                    <sup>
                        <xref ref-type="bibr" rid="ref20">20</xref>,
                        <xref ref-type="bibr" rid="ref21">21</xref>
                    </sup> It has been demonstrated that the integration of physical principles into neural network architectures improves their interpretability, generalizability, and applicability across a diverse array of scientific and engineering challenges.
                    <sup>
                        <xref ref-type="bibr" rid="ref22">22</xref>
                    </sup> This study focuses on the latter category, specifically employing physics-driven PINNs to solve differential equations while addressing challenges associated with unbalanced loss terms.</p>
            </sec>
            <sec id="sec4">
                <title>2.2 Term scaling</title>
                <p>An effective introduction to the scaling treatment of differential equations is presented herein, based on generalized scaling methods.
                    <sup>
                        <xref ref-type="bibr" rid="ref23">23</xref>
                    </sup> The objective of scaling is to render both the dependent and independent variables dimensionless, while simultaneously positioning them within the unit range. Each variable is normalized using a characteristic quantity relevant to the specific problem. For instance, the spatial variable may be normalized in relation to the length of a structure. Subsequently, all terms and derivatives appearing in the differential equation are expressed in terms of their dimensionless equivalents. Any unestablished scaling coefficients are approximated by requiring that the corresponding terms of the equation remain proximate to unity. Upon resolving the equation in its normalized form, a reverse process is employed to retrieve the solution in the physical domain.</p>
                <p>The proposed method, referred to as Scaled Equation-Enhanced Physics Informed Neural Network (SEE-PINN), for handling unbalanced loss terms in PINNs, is built directly on this scaling framework. By ensuring that all terms of the differential equation operate on comparable scales before constructing the loss function, our approach simplifies implementation while improving optimization efficiency. This is demonstrated through its application to two distinct mechanical problems: an elastic rod and an Euler beam. In both cases, the exact same procedural steps are followed, emphasizing the method&#x2019;s consistency and ease of use. The only variation lies in the number of variables and functions requiring normalization, reinforcing its generality and adaptability across different types of differential equations. The following paragraphs provide the numerical formulation of equations typically encountered in the literature, incorporating this systematic scaling approach.</p>
                <p>It is important to distinguish the proposed SEE-PINN framework from existing approaches that aim to alleviate loss-term imbalance in PINNs. Adaptive weighting methods dynamically modify the contribution of each loss term during training, often relying on gradient statistics, probabilistic models, or auxiliary optimization loops. Gradient-enhanced or equation-augmented PINNs enrich the loss function by incorporating higher-order derivatives or additional residual constraints, increasing both computational cost and implementation complexity.</p>
                <p>In contrast, SEE-PINN operates exclusively at the level of the governing differential equation. By rescaling each term using characteristic physical quantities prior to training, the resulting normalized equation is inherently balanced. Consequently, the loss function remains simple and fixed throughout training, and standard optimizers can be employed without tuning or adaptive mechanisms. This shift of complexity from the optimization stage to a one-time, physics-driven preprocessing step constitutes the central novelty of the proposed framework.</p>
                <p>

                    <bold>2.2.1 Elastic rod</bold>
                </p>
                <p>The response of an elastic rod is described by the 1D Poisson equation:
                    <disp-formula id="e2">

                        <mml:math display="block">
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mi>E</mml:mi>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mi>x</mml:mi>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo>&#x00b7;</mml:mo>
                                <mml:mi>A</mml:mi>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mi>x</mml:mi>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo>&#x00b7;</mml:mo>
                                <mml:mfrac>
                                    <mml:mi mathvariant="italic">du</mml:mi>
                                    <mml:mi mathvariant="italic">dx</mml:mi>
                                </mml:mfrac>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>+</mml:mo>
                            <mml:mi>p</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.35em"/>
                            <mml:mi>x</mml:mi>
                            <mml:mo>&#x2208;</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mn>0</mml:mn>
                                <mml:mo>,</mml:mo>
                                <mml:mi>L</mml:mi>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(2)</label>
</disp-formula>where 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
</inline-formula> is the length, 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>E</mml:mi>
                        </mml:math>
</inline-formula> is the Young&#x2019;s modulus, 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>A</mml:mi>
                        </mml:math>
</inline-formula> is the cross-sectional area, 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>p</mml:mi>
                        </mml:math>
</inline-formula> is the applied load and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>u</mml:mi>
                        </mml:math>
</inline-formula> corresponds to the pursued axial displacement. The fact that all quantities are presumed to vary arbitrarily with respect to 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                        </mml:math>
</inline-formula>, prevents the derivation of general analytic solutions. 
                    <xref ref-type="disp-formula" rid="e2">Eq. (2)</xref> can be expanded as
                    <disp-formula id="e3">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>E</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mi>A</mml:mi>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mi>E</mml:mi>
                            <mml:msub>
                                <mml:mi>A</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mi mathvariant="italic">EA</mml:mi>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mi>p</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                        </mml:math>

                        <label>(3)</label>
</disp-formula>where subscript 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                        </mml:math>
</inline-formula> indicates differentiation.</p>
                <p>To derive the normalized formulation of 
                    <xref ref-type="disp-formula" rid="e3">Eq. (3)</xref> each term is normalized using a characteristic quantity. Initially, the normalized spatial variable is defined as
                    <disp-formula id="e4">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>x</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>x</mml:mi>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1em"/>
                            <mml:mi>x</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>x</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>x</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1em"/>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mn>1</mml:mn>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                        </mml:math>

                        <label>(4)</label>
</disp-formula>where 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>x</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> is the scaling coefficient. In the same sense, the Young&#x2019;s modulus, the cross-sectional area, the axial displacement and the applied load can be expressed in their respective normalized forms:
                    <disp-formula id="e5">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x2261;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>E</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:msub>
                                    <mml:mi>e</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1em"/>
                            <mml:mi>E</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>e</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(5)</label>
</disp-formula>

                    <disp-formula id="e6">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>A</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x2261;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>A</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>A</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:msub>
                                    <mml:mi>a</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1em"/>
                            <mml:mi>A</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>a</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>A</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(6)</label>
</disp-formula>

                    <disp-formula id="e7">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>u</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x2261;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>u</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>u</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:msub>
                                    <mml:mi>u</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1em"/>
                            <mml:mi>u</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>u</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(7)</label>
</disp-formula>

                    <disp-formula id="e8">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>p</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x2261;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>p</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>p</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:msub>
                                    <mml:mi>p</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1em"/>
                            <mml:mi>p</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>p</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>p</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(8)</label>
</disp-formula>where 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>e</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:msub>
                                <mml:mi>a</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:msub>
                                <mml:mi>p</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> are scaling coefficients to ensure that the range of 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>E</mml:mi>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mover accent="true">
                                <mml:mi>A</mml:mi>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mover accent="true">
                                <mml:mi>u</mml:mi>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
</inline-formula> and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>p</mml:mi>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
</inline-formula> is normalized to 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mn>0</mml:mn>
                                <mml:mo>,</mml:mo>
                                <mml:mn>1</mml:mn>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula>. The following reasonable assumptions are made for 
                    <xref ref-type="disp-formula" rid="e4">Eqs. (4)</xref>-
                    <xref ref-type="disp-formula" rid="e8">(8)</xref>:
                    <disp-formula id="e9">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>x</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mi>L</mml:mi>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:msub>
                                <mml:mi>e</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mo>max</mml:mo>
                            <mml:mi>E</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:msub>
                                <mml:mi>a</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mo>max</mml:mo>
                            <mml:mi>A</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:msub>
                                <mml:mi>p</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mo>max</mml:mo>
                            <mml:mrow>
                                <mml:mo>|</mml:mo>
                                <mml:mi>p</mml:mi>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mi>x</mml:mi>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo>|</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(9)</label>
</disp-formula>
                </p>
                <p>For 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> no assumption can be made at this point, since the value of 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>u</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula> remains unknown; consequently, it must be approximated through an alternative method.</p>
                <p>The respective spatial derivatives appearing in 
                    <xref ref-type="disp-formula" rid="e3">Eq. (3)</xref> are expressed in normalized form using 
                    <xref ref-type="disp-formula" rid="e4">Eqs.(4)</xref>-
                    <xref ref-type="disp-formula" rid="e8">(8)</xref>:
                    <disp-formula id="e10">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>E</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">dE</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:msub>
                                    <mml:mi>e</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>e</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>E</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>e</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(10)</label>
</disp-formula>

                    <disp-formula id="e11">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>A</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">dA</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:msub>
                                    <mml:mi>a</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>A</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>a</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>A</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>a</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>A</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(11)</label>
</disp-formula>

                    <disp-formula id="e12">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">du</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:msub>
                                    <mml:mi>u</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>u</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>u</mml:mi>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(12)</label>
</disp-formula>

                    <disp-formula id="e13">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msub>
                                        <mml:mi>u</mml:mi>
                                        <mml:mi>x</mml:mi>
                                    </mml:msub>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mfrac>
                                    <mml:msub>
                                        <mml:mi>u</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mfrac>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>u</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>u</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msub>
                                        <mml:mover accent="false">
                                            <mml:mi>u</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                    </mml:msub>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>u</mml:mi>
                                <mml:msubsup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msubsup>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(13)</label>
</disp-formula>
                </p>
                <p>Then, 
                    <xref ref-type="disp-formula" rid="e3">Eq. (3)</xref> can be reformulated utilizing the normalized quantities:
                    <disp-formula id="e14">

                        <mml:math display="block">
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>e</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>a</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mover accent="false">
                                <mml:mi>A</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>u</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:msub>
                                <mml:mi>e</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>a</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>A</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>u</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:msub>
                                <mml:mi>e</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>a</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mover accent="false">
                                <mml:mi>A</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>u</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msubsup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msubsup>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:msub>
                                <mml:mi>p</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mover accent="false">
                                <mml:mi>p</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                        </mml:math>

                        <label>(14)</label>
</disp-formula>
                </p>
                <p>After simplifying the equation:
                    <disp-formula id="e15">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>A</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>A</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>A</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>u</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>p</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msubsup>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>p</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>e</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>a</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>u</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                        </mml:math>

                        <label>(15)</label>
</disp-formula>
                </p>
                <p>To confine the last term within the interval [0,1] as well, its coefficient is set equal unity, yielding the value of the normalizing parameter 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula>:
                    <disp-formula id="e16">

                        <mml:math display="block">
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>p</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msubsup>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>e</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>a</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>u</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mn>1</mml:mn>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>p</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msubsup>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>e</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>a</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mrow>
                            </mml:mfrac>
                        </mml:math>

                        <label>(16)</label>
</disp-formula>
                </p>
                <p>

                    <bold>2.2.2 Elastic Euler beam</bold>
                </p>
                <p>The response of an elastic Euler beam is described by the well-known equation:
                    <disp-formula id="e17">

                        <mml:math display="block">
                            <mml:mfrac>
                                <mml:msup>
                                    <mml:mi>d</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msup>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msup>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mi>E</mml:mi>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mi>x</mml:mi>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo>&#x00b7;</mml:mo>
                                <mml:mi>I</mml:mi>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mi>x</mml:mi>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo>&#x00b7;</mml:mo>
                                <mml:mfrac>
                                    <mml:mrow>
                                        <mml:msup>
                                            <mml:mi>d</mml:mi>
                                            <mml:mn>2</mml:mn>
                                        </mml:msup>
                                        <mml:mi>w</mml:mi>
                                    </mml:mrow>
                                    <mml:mrow>
                                        <mml:mi>d</mml:mi>
                                        <mml:msup>
                                            <mml:mi>x</mml:mi>
                                            <mml:mn>2</mml:mn>
                                        </mml:msup>
                                    </mml:mrow>
                                </mml:mfrac>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mi>p</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.35em"/>
                            <mml:mi>x</mml:mi>
                            <mml:mspace width="0.25em"/>
                            <mml:mo>&#x2208;</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mn>0</mml:mn>
                                <mml:mo>,</mml:mo>
                                <mml:mi>L</mml:mi>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(17)</label>
</disp-formula>where 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
</inline-formula> is the length, 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>E</mml:mi>
                        </mml:math>
</inline-formula> is the Young&#x2019;s modulus, 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>I</mml:mi>
                        </mml:math>
</inline-formula> is moment of inertia, 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>p</mml:mi>
                        </mml:math>
</inline-formula> is the applied load and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                        </mml:math>
</inline-formula> is the pursued transverse deflection. All quantities are presumed to vary with respect to 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                        </mml:math>
</inline-formula>, which precludes general analytic solutions. 
                    <xref ref-type="disp-formula" rid="e17">Eq. (17)</xref> can be expanded as
                    <disp-formula id="e18">

                        <mml:math display="block">
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msub>
                                    <mml:mi>E</mml:mi>
                                    <mml:mi mathvariant="italic">xx</mml:mi>
                                </mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mo>+</mml:mo>
                                <mml:mn>2</mml:mn>
                                <mml:msub>
                                    <mml:mi>E</mml:mi>
                                    <mml:mi>x</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>I</mml:mi>
                                    <mml:mi>x</mml:mi>
                                </mml:msub>
                                <mml:mo>+</mml:mo>
                                <mml:mi>E</mml:mi>
                                <mml:msub>
                                    <mml:mi>I</mml:mi>
                                    <mml:mi mathvariant="italic">xx</mml:mi>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mn>2</mml:mn>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msub>
                                    <mml:mi>E</mml:mi>
                                    <mml:mi>x</mml:mi>
                                </mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mo>+</mml:mo>
                                <mml:mi>E</mml:mi>
                                <mml:msub>
                                    <mml:mi>I</mml:mi>
                                    <mml:mi>x</mml:mi>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi mathvariant="italic">xxx</mml:mi>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mi mathvariant="italic">EI</mml:mi>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mtext mathvariant="italic">xxxx</mml:mtext>
                            </mml:msub>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mi>p</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                        </mml:math>

                        <label>(18)</label>
</disp-formula>where subscript 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                        </mml:math>
</inline-formula> indicates differentiation.</p>
                <p>To derive the normalized formulation of 
                    <xref ref-type="disp-formula" rid="e18">Eq. (18)</xref>, each term is normalized using a characteristic quantity. The normalized spatial variable, Young modulus and applied load are defined again as in 
                    <xref ref-type="disp-formula" rid="e4">Eqs. (4)</xref>, 
                    <xref ref-type="disp-formula" rid="e5">(5)</xref> and 
                    <xref ref-type="disp-formula" rid="e8">(8)</xref> using the same scaling coefficients as in 
                    <xref ref-type="disp-formula" rid="e9">Eq. (9)</xref>. In the same sense the normalized inertial moment and transverse deflection are defined as:
                    <disp-formula id="e19">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>I</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x2261;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>I</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>I</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:msub>
                                    <mml:mi>i</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1.5em"/>
                            <mml:mi>I</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>i</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>I</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(19)</label>
</disp-formula>

                    <disp-formula id="e20">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>w</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>&#x2261;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>w</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>w</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:msub>
                                    <mml:mi>w</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mspace width="1em"/>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:mspace width="1.5em"/>
                            <mml:mi>w</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mover accent="false">
                                <mml:mi>w</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(20)</label>
</disp-formula>where 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>i</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> are scaling coefficients to ensure that the range of 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>I</mml:mi>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
</inline-formula> and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>w</mml:mi>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
</inline-formula> is normalized to 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mn>0</mml:mn>
                                <mml:mo>,</mml:mo>
                                <mml:mn>1</mml:mn>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula>. A reasonable assumption for 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>i</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> is:
                    <disp-formula id="e21">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>i</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mo>max</mml:mo>
                            <mml:mi>I</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(21)</label>
</disp-formula>but, again, no assumption can be made for 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula>, and it needs to be determined.</p>
                <p>The respective spatial derivatives appearing in 
                    <xref ref-type="disp-formula" rid="e18">Eq. (18)</xref> are expressed in normalized form:
                    <disp-formula id="e22">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>E</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">dE</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:msub>
                                    <mml:mi>e</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>e</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>E</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>e</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(22)</label>
</disp-formula>

                    <disp-formula id="e23">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>E</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msub>
                                        <mml:mi>E</mml:mi>
                                        <mml:mi>x</mml:mi>
                                    </mml:msub>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mfrac>
                                    <mml:msub>
                                        <mml:mi>e</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mfrac>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>E</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>e</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msubsup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msubsup>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(23)</label>
</disp-formula>

                    <disp-formula id="e24">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">dI</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:msub>
                                    <mml:mi>i</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>I</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>i</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>I</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>i</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>I</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(24)</label>
</disp-formula>

                    <disp-formula id="e25">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msub>
                                        <mml:mi>I</mml:mi>
                                        <mml:mi>x</mml:mi>
                                    </mml:msub>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mfrac>
                                    <mml:msub>
                                        <mml:mi>i</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mfrac>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>I</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>i</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msubsup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msubsup>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>I</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(25)</label>
</disp-formula>

                    <disp-formula id="e26">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">dw</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:msub>
                                    <mml:mi>w</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>w</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>w</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(26)</label>
</disp-formula>

                    <disp-formula id="e27">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi>x</mml:mi>
                                    </mml:msub>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mfrac>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mfrac>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>w</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>w</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msubsup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msubsup>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(27)</label>
</disp-formula>

                    <disp-formula id="e28">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi mathvariant="italic">xxx</mml:mi>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi mathvariant="italic">xx</mml:mi>
                                    </mml:msub>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mfrac>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msubsup>
                                </mml:mfrac>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>w</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                    </mml:mrow>
                                </mml:msub>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>w</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msubsup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                    <mml:mn>3</mml:mn>
                                </mml:msubsup>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(28)</label>
</disp-formula>

                    <disp-formula id="e29">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mtext mathvariant="italic">xxxx</mml:mtext>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi mathvariant="italic">xxx</mml:mi>
                                    </mml:msub>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mi>d</mml:mi>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mfrac>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>3</mml:mn>
                                    </mml:msubsup>
                                </mml:mfrac>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>w</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                    </mml:mrow>
                                </mml:msub>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mi mathvariant="italic">dx</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msub>
                                    <mml:mi>w</mml:mi>
                                    <mml:mi>c</mml:mi>
                                </mml:msub>
                                <mml:msubsup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mi>c</mml:mi>
                                    <mml:mn>4</mml:mn>
                                </mml:msubsup>
                            </mml:mfrac>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>x</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(29)</label>
</disp-formula>
                </p>
                <p>Then, 
                    <xref ref-type="disp-formula" rid="e18">Eq. (18)</xref> can then be recast using the normalized quantities:
                    <disp-formula id="e30">

                        <mml:math display="block">
                            <mml:mover accent="false">
                                <mml:mi>E</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mover accent="false">
                                <mml:mi>I</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mn>2</mml:mn>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>E</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>I</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo>+</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>I</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mo>+</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>E</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                    </mml:mrow>
                                </mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>I</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mo>+</mml:mo>
                                <mml:mn>2</mml:mn>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>E</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>I</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:msub>
                                <mml:mo>+</mml:mo>
                                <mml:mover accent="false">
                                    <mml:mi>E</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:msub>
                                    <mml:mover accent="false">
                                        <mml:mi>I</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                        <mml:mover accent="false">
                                            <mml:mi>x</mml:mi>
                                            <mml:mo>&#x00af;</mml:mo>
                                        </mml:mover>
                                    </mml:mrow>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:msub>
                                <mml:mover accent="false">
                                    <mml:mi>w</mml:mi>
                                    <mml:mo>&#x00af;</mml:mo>
                                </mml:mover>
                                <mml:mrow>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mover accent="false">
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>p</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>4</mml:mn>
                                    </mml:msubsup>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>e</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>i</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mover accent="false">
                                <mml:mi>p</mml:mi>
                                <mml:mo>&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                        </mml:math>

                        <label>(30)</label>
</disp-formula>
                </p>
                <p>In order to constrain the last term in [0,1] as well, its coefficient is set equal unity, yielding the value of the normalizing parameter 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula>:
                    <disp-formula id="e31">

                        <mml:math display="block">
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>p</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>4</mml:mn>
                                    </mml:msubsup>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>e</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>i</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>w</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:mn>1</mml:mn>
                            <mml:mo>&#x2192;</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>c</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>p</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>c</mml:mi>
                                        <mml:mn>4</mml:mn>
                                    </mml:msubsup>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>e</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msub>
                                        <mml:mi>i</mml:mi>
                                        <mml:mi>c</mml:mi>
                                    </mml:msub>
                                </mml:mrow>
                            </mml:mfrac>
                        </mml:math>

                        <label>(31)</label>
</disp-formula>
                </p>
            </sec>
        </sec>
        <sec id="sec5">
            <title>3. Technical aspects and performance assessment</title>
            <p>In this section, the architecture of the proposed SEE-PINN framework is first introduced, detailing the network structure, activation functions, training procedure, and implementation of the term-scaling approach. This ensures a comprehensive understanding of the methodology before proceeding to validation and performance evaluation.</p>
            <p>Following this, the proposed method is validated through a series of test cases and subsequently compared to solutions found in the literature to illustrate its computational efficiency. The objective is not to undermine existing methods but to demonstrate that they can benefit from our approach and achieve enhanced accuracy and robustness.</p>
            <p>Both simple and complex case studies are examined concerning the problems associated with the elastic rod and the elastic Euler beam to validate the proposed method. For straightforward cases, the solution obtained through PINNs is compared against analytical solutions. In more complex scenarios, where no analytical solution is available, the PINN solution is contrasted with numerical solutions.</p>
            <sec id="sec6">
                <title>3.1 Network architecture</title>
                <p>Following the term scaling methodology description, a comprehensive architecture is provided here. The fundamental framework is presented for the rod and beam problems. This design is intended to be easily adaptable, enabling other researchers to extend it to various problems with minimal effort.</p>
                <p>The proposed approach begins with a normalization step applied to the coefficients of the ODE terms before they are introduced into the input layer. These normalized coefficients, together with the neural network outputs, undergo automatic differentiation to compute the gradients of the required to form the ODE. The resulting terms are then incorporated into the loss function, which typically consists of one term for the ODE residual and additional terms for each boundary condition. In this work, the mean squared error is employed for the terms of the loss function. If the total loss converges below a predefined threshold, the process proceeds to de-normalization, producing the final solution. Otherwise, backpropagation updates the network&#x2019;s weights and biases until convergence is reached.</p>
                <p>The architecture for the elastic rod is illustrated in 
                    <xref ref-type="fig" rid="f2">
Figure 2</xref> and can be readily adapted to the beam problem (or other related problems) by modifying the predicted quantities and the computed gradients. Specifically, for the beam, the output variable changes from the axial displacement 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>u</mml:mi>
                        </mml:math>
</inline-formula> (for the rod) to the transverse deflection 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                        </mml:math>
</inline-formula>, while the required gradients expand significantly. The rod problem involves computing 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>E</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>A</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>u</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula>, whereas the beam problem requires additional terms, namely 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>E</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>x</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi mathvariant="italic">xx</mml:mi>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi mathvariant="italic">xxx</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mtext mathvariant="italic">xxxx</mml:mtext>
                            </mml:msub>
                        </mml:math>
</inline-formula>. Likewise, the rod problem is solved using two boundary conditions, e.g. a Dirichlet and a Neumann condition (denoted in 
                    <xref ref-type="fig" rid="f2">
Figure 2</xref> by 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>L</mml:mi>
                                <mml:mi>D</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> and 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>L</mml:mi>
                                <mml:mi>N</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula> respectively), while the beam problem requires four boundary conditions. Although the mathematical complexity increases significantly (as detailed in the respective sections), the transition from the rod to the beam remains conceptually straightforward. The same principle applies when extending the approach to other problems.</p>
                <fig fig-type="figure" id="f2" orientation="portrait" position="float">
                    <label>
Figure 2. </label>
                    <caption>
                        <title>Network architecture for the problem of the elastic rod.</title>
                    </caption>
                    <graphic id="gr2" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure2.gif"/>
                </fig>
                <p>The network is implemented in PyTorch, to take advantage of computational optimizations, and automatic computing (Autograd) of derivatives in the loss function.</p>
            </sec>
            <sec id="sec7">
                <title>3.2 Validations</title>
                <p>

                    <bold>3.2.1 Fixed uniform rod with distributed load</bold>
                </p>
                <p>

                    <bold>Statement of the problem.</bold> This represents a straightforward scenario. A homogenous rod with a uniform cross-section is subjected to an axially distributed load. The left end of the rod is fixed, while the right one is free. The axial displacement along the rod is analyzed. Numerical values are:
                    <disp-formula id="e32">

                        <mml:math display="block">
                            <mml:mi>E</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>200</mml:mn>
                            <mml:mi mathvariant="italic">GPa</mml:mi>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mi>A</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>1</mml:mn>
                            <mml:mi>c</mml:mi>
                            <mml:msup>
                                <mml:mi>m</mml:mi>
                                <mml:mn>2</mml:mn>
                            </mml:msup>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mi>p</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mn>1000</mml:mn>
                            <mml:msup>
                                <mml:mi>x</mml:mi>
                                <mml:mn>2</mml:mn>
                            </mml:msup>
                            <mml:mfrac>
                                <mml:mi>N</mml:mi>
                                <mml:mi>m</mml:mi>
                            </mml:mfrac>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mi>L</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>1</mml:mn>
                            <mml:mi>m</mml:mi>
                        </mml:math>

                        <label>(32)</label>
</disp-formula>
                </p>
                <p>Since properties are constant along the rod, 
                    <xref ref-type="disp-formula" rid="e2">Eq. (2)</xref> is diminished to
                    <disp-formula id="e33">

                        <mml:math display="block">
                            <mml:mi mathvariant="italic">EA</mml:mi>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:msup>
                                        <mml:mi>d</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msup>
                                    <mml:mi>u</mml:mi>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>d</mml:mi>
                                    <mml:msup>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msup>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>+</mml:mo>
                            <mml:mi>p</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0</mml:mn>
                        </mml:math>

                        <label>(33)</label>
</disp-formula>with boundary conditions
                    <disp-formula id="e34">

                        <mml:math display="block">
                            <mml:mtable displaystyle="true">
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:mtext mathvariant="italic">Displacement</mml:mtext>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi mathvariant="italic">at</mml:mi>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                        <mml:mo>:</mml:mo>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mi>u</mml:mi>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>0</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:mtext mathvariant="italic">Force</mml:mtext>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi mathvariant="italic">at</mml:mi>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>=</mml:mo>
                                        <mml:mi>L</mml:mi>
                                        <mml:mo>:</mml:mo>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mi mathvariant="italic">EA</mml:mi>
                                        <mml:msub>
                                            <mml:mi>u</mml:mi>
                                            <mml:mi>x</mml:mi>
                                        </mml:msub>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mi>L</mml:mi>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                    </mml:mtd>
                                </mml:mtr>
                            </mml:mtable>
                        </mml:math>

                        <label>(34)</label>
</disp-formula>
                </p>
                <p>The analytic solution is
                    <disp-formula id="e35">

                        <mml:math display="block">
                            <mml:mi>u</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mfrac>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>4</mml:mn>
                                </mml:msup>
                                <mml:mn>240000</mml:mn>
                            </mml:mfrac>
                            <mml:mo>+</mml:mo>
                            <mml:mfrac>
                                <mml:mi>x</mml:mi>
                                <mml:mn>60000</mml:mn>
                            </mml:mfrac>
                        </mml:math>

                        <label>(35)</label>
</disp-formula>
                </p>
                <p>

                    <bold>SEE-PINN solution.</bold> An appropriate neural network is designed to approximate the displacement field of the rod. The input of the neural network is the spatial coordinate 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                        </mml:math>
</inline-formula>, and its output is the predicted displacement 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>u</mml:mi>
                                <mml:mo stretchy="true">&#x0302;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula>. The network consists of only one fully connected layer, with 10 neurons, and each neuron employs the tanh activation function. The network is trained at 75 points using the Adam optimizer with learning rate 0.01 for 5000 epochs.</p>
                <p>

                    <bold>Comparison and error analysis.</bold> The predicted solution the PINN is validated against the analytical solution &#x2013; 
                    <xref ref-type="disp-formula" rid="e35">Eq. (35)</xref>. 
                    <xref ref-type="fig" rid="f3">
Figure 3a</xref> demonstrates that the analytic and the PINN solution are indistinguishable from each other, as verified by the parity plot in 
                    <xref ref-type="fig" rid="f3">
Figure 3b</xref>. The prediction quality is further assessed using the normalized relative error, where the relative error is scaled according to the magnitude of the displacement values to prevent numerical artifacts from division by very small numbers.
                    <disp-formula id="e36">

                        <mml:math display="block">
                            <mml:mi>e</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mo>|</mml:mo>
                                    <mml:mi>u</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mover accent="true">
                                        <mml:mi>u</mml:mi>
                                        <mml:mo stretchy="true">&#x0302;</mml:mo>
                                    </mml:mover>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>|</mml:mo>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mo>|</mml:mo>
                                    <mml:mi>u</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>+</mml:mo>
                                    <mml:mi>O</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>u</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>|</mml:mo>
                                </mml:mrow>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mn>100</mml:mn>
                            <mml:mo>%</mml:mo>
                        </mml:math>

                        <label>(36)</label>
</disp-formula>
                </p>
                <fig fig-type="figure" id="f3" orientation="portrait" position="float">
                    <label>
Figure 3. </label>
                    <caption>
                        <title>SEE-PINN vs. Analytic solution for case 3.2.1.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr3" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure3.gif"/>
                </fig>
                <p>The maximum relative error is ca. 0.4%, which demonstrates the PINN approach achieves nearly exact agreement with the analytical solution.</p>
                <p>

                    <bold>3.2.2 Fixed rod with variable cross-section and distributed load</bold>
                </p>
                <p>

                    <bold>Statement of the problem.</bold> This case builds upon the previous problem by introducing a nonlinear variation in the cross-sectional area.
                    <disp-formula id="e37">

                        <mml:math display="block">
                            <mml:mi>A</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mn>2</mml:mn>
                                <mml:mo>+</mml:mo>
                                <mml:mo>sin</mml:mo>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:mn>2</mml:mn>
                                    <mml:mi>&#x03c0;</mml:mi>
                                    <mml:mfrac>
                                        <mml:mi>x</mml:mi>
                                        <mml:mi>L</mml:mi>
                                    </mml:mfrac>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mi>c</mml:mi>
                            <mml:msup>
                                <mml:mi>m</mml:mi>
                                <mml:mn>2</mml:mn>
                            </mml:msup>
                        </mml:math>

                        <label>(37)</label>
</disp-formula>while keeping all other parameters unchanged, increasing the complexity of the analysis.</p>
                <p>

                    <bold>SEE-PINN solution.</bold> The same neural network has been employed to approximate the displacement field of the rod; i.e. one fully connected layer, with 10 neurons, and each neuron employs the tanh activation function. The network is trained at 75 points using the Adam optimizer with learning rate 0.01 for 5000 epochs.</p>
                <p>

                    <bold>Comparison and error analysis.</bold> The predicted solution is compared against a numerical reference for validation. 
                    <xref ref-type="fig" rid="f4">
Figure 4</xref> illustrates that the analytic and the PINN solution are again indistinguishable. With a maximum relative error of approximately 0.04%, the PINN approach demonstrates an excellent agreement with the analytical solution.</p>
                <fig fig-type="figure" id="f4" orientation="portrait" position="float">
                    <label>
Figure 4. </label>
                    <caption>
                        <title>SEE-PINN vs. Analytic solution for case 3.2.2.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr4" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure4.gif"/>
                </fig>
                <p>

                    <bold>3.2.3 Fixed rod with variable Young&#x2019;s modulus and cross-section, and distributed load</bold>
                </p>
                <p>

                    <bold>Statement of the problem.</bold> The complexity is further increased by incorporating a nonlinear variation in the Young&#x2019;s modulus of the rod.
                    <disp-formula id="e38">

                        <mml:math display="block">
                            <mml:mi>E</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mn>200</mml:mn>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mn>1</mml:mn>
                                <mml:mo>&#x2212;</mml:mo>
                                <mml:mo>tanh</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mi mathvariant="italic">GPa</mml:mi>
                        </mml:math>

                        <label>(38)</label>
</disp-formula>while preserving the other parameters; the cross-sectional area still varies according to 
                    <xref ref-type="disp-formula" rid="e37">Eq. (37)</xref>. This variation is designed to mimic the behavior of exotic materials, similar to those found in advanced metamaterials, or the properties of damaged materials.</p>
                <p>

                    <bold>SEE-PINN solution.</bold> The same neural network has been employed to approximate the displacement field of the rod; i.e. one fully connected layer, with 10 neurons, and each neuron employs the tanh activation function. The network is trained at 75 points using the Adam optimizer with learning rate 0.01 for 5000 epochs.</p>
                <p>

                    <bold>Comparison and error analysis.</bold> The predicted solution validated against is validated against a numerical reference. As shown in 
                    <xref ref-type="fig" rid="f5">
Figure 5</xref>, the analytical and PINN solutions are virtually identical. The maximum relative error is approximately 0.05%, indicating that the PINN approach achieves an almost exact match with the analytical solution.</p>
                <fig fig-type="figure" id="f5" orientation="portrait" position="float">
                    <label>
Figure 5. </label>
                    <caption>
                        <title>SEE-PINN vs. Analytic solution for case 3.2.3.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr5" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure5.gif"/>
                </fig>
                <p>

                    <bold>3.2.4 Uniform Euler beam with distributed load</bold>
                </p>
                <p>

                    <bold>Statement of the problem.</bold> The second part of the validation examines three beam problems. The first case considers a uniform, homogeneous elastic beam with a length of 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>1</mml:mn>
                        </mml:math>
</inline-formula>m. The beam has a rectangular cross-section of 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>b</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>6</mml:mn>
                            <mml:mi mathvariant="italic">cm</mml:mi>
                            <mml:mo>,</mml:mo>
                            <mml:mi>h</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>1</mml:mn>
                            <mml:mi mathvariant="italic">cm</mml:mi>
                        </mml:math>
</inline-formula> and is composed of a material with 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>E</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>200</mml:mn>
                            <mml:mspace width="0.25em"/>
                            <mml:mi mathvariant="italic">GPa</mml:mi>
                        </mml:math>
</inline-formula>. The left end of the rod is fixed, while the right one is simply supported. The beam is subjected to a transverse load of 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>p</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mn>100</mml:mn>
                            <mml:mspace width="0.25em"/>
                            <mml:mi>N</mml:mi>
                            <mml:mo>/</mml:mo>
                            <mml:mi>m</mml:mi>
                        </mml:math>
</inline-formula>, and its transverse deflection is analyzed.</p>
                <p>This problem can be easily solved through the analytical solution of 
                    <xref ref-type="disp-formula" rid="e17">Eq. (17)</xref> with constant properties and boundary conditions:
                    <disp-formula id="e39">

                        <mml:math display="block">
                            <mml:mtable displaystyle="true">
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:mtext mathvariant="italic">Deflection</mml:mtext>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi mathvariant="italic">at</mml:mi>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                        <mml:mo>:</mml:mo>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mi>w</mml:mi>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>0</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:mtext mathvariant="italic">Rotation</mml:mtext>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi mathvariant="italic">at</mml:mi>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                        <mml:mo>:</mml:mo>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:msup>
                                            <mml:mi>w</mml:mi>
                                            <mml:mo>&#x2032;</mml:mo>
                                        </mml:msup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>0</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:mtext mathvariant="italic">Deflection</mml:mtext>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi mathvariant="italic">at</mml:mi>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>=</mml:mo>
                                        <mml:mi>L</mml:mi>
                                        <mml:mo>:</mml:mo>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mi>w</mml:mi>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mi>L</mml:mi>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:mtext mathvariant="italic">Moment</mml:mtext>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi mathvariant="italic">at</mml:mi>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo>=</mml:mo>
                                        <mml:mi>L</mml:mi>
                                        <mml:mo>:</mml:mo>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mi mathvariant="italic">EI</mml:mi>
                                        <mml:msup>
                                            <mml:mi>w</mml:mi>
                                            <mml:mrow>
                                                <mml:mo>&#x2032;</mml:mo>
                                                <mml:mo>&#x2032;</mml:mo>
                                            </mml:mrow>
                                        </mml:msup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mi>L</mml:mi>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>0</mml:mn>
                                    </mml:mtd>
                                </mml:mtr>
                            </mml:mtable>
                        </mml:math>

                        <label>(39)</label>
</disp-formula>
                </p>
                <p>The analytic solution is:
                    <disp-formula id="e40">

                        <mml:math display="block">
                            <mml:mi>w</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>4</mml:mn>
                                </mml:msup>
                                <mml:mn>240</mml:mn>
                            </mml:mfrac>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mfrac>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>3</mml:mn>
                                </mml:msup>
                                <mml:mn>96</mml:mn>
                            </mml:mfrac>
                            <mml:mo>+</mml:mo>
                            <mml:mfrac>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msup>
                                <mml:mn>160</mml:mn>
                            </mml:mfrac>
                        </mml:math>

                        <label>(40)</label>
</disp-formula>
                </p>
                <p>

                    <bold>SEE-PINN solution.</bold> An appropriate neural network is designed to approximate the deflection of the beam. The input of the neural network is the spatial coordinate 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                        </mml:math>
</inline-formula>, and its output is the predicted transverse displacement 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mover accent="true">
                                <mml:mi>w</mml:mi>
                                <mml:mo stretchy="true">&#x0302;</mml:mo>
                            </mml:mover>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>
</inline-formula>. The network consists of only one fully connected layer, with 10 neurons, and each neuron employs the tanh activation function. The network is trained at 75 points using the Adam optimizer with learning rate 0.001 for 10000 epochs.</p>
                <p>

                    <bold>Comparison and error analysis.</bold> The predicted solution is validated against the analytical reference (
                    <xref ref-type="fig" rid="f6">
Figure 6</xref>), showing that the analytical and PINN solutions are virtually identical (
                    <xref ref-type="fig" rid="f6">
Figure 6a</xref>); this is further supported by the parity plot (
                    <xref ref-type="fig" rid="f6">
Figure 6b</xref>), where all data points practically lay along the diagonal. With a maximum relative error of approximately 0.2%, the PINN approach achieves exceptional accuracy in comparison to the analytical solution.</p>
                <fig fig-type="figure" id="f6" orientation="portrait" position="float">
                    <label>
Figure 6. </label>
                    <caption>
                        <title>SEE-PINN vs. Analytic solution for case 3.2.4.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr6" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure6.gif"/>
                </fig>
                <p>

                    <bold>3.2.5 Euler beam with variable cross-section and distributed load</bold>
                </p>
                <p>

                    <bold>Statement of the problem.</bold> This case builds upon the previous problem by introducing a nonlinear transition in the inertial moment of the cross-section, represented by 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mi>I</mml:mi>
                        </mml:math>
</inline-formula>:
                    <disp-formula id="e41">

                        <mml:math display="block">
                            <mml:mi>I</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mn>0</mml:mn>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:mn>1</mml:mn>
                                <mml:mo>+</mml:mo>
                                <mml:mn>0.5</mml:mn>
                                <mml:mi>x</mml:mi>
                                <mml:mo>&#x2212;</mml:mo>
                                <mml:mn>0.25</mml:mn>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msup>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>,</mml:mo>
                            <mml:mspace width="0.35em"/>
                            <mml:msub>
                                <mml:mi>I</mml:mi>
                                <mml:mn>0</mml:mn>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mi>b</mml:mi>
                                    <mml:mo>&#x00b7;</mml:mo>
                                    <mml:msup>
                                        <mml:mi>h</mml:mi>
                                        <mml:mn>3</mml:mn>
                                    </mml:msup>
                                </mml:mrow>
                                <mml:mn>12</mml:mn>
                            </mml:mfrac>
                        </mml:math>

                        <label>(41)</label>
</disp-formula>while keeping all other parameters unchanged, increasing the complexity of the analysis.</p>
                <p>

                    <bold>PINN solution.</bold> A shallow architecture has been employed to approximate the deflection of the beam; i.e. one fully connected layer, with 10 neurons, and each neuron employs the tanh activation function. The network is trained at 75 points using the Adam optimizer with learning rate 0.001 for 10000 epochs.</p>
                <p>

                    <bold>Comparison and error analysis.</bold> The predicted solution is compared against a numerical reference for validation. 
                    <xref ref-type="fig" rid="f7">
Figure 7</xref> illustrates that the analytic and the PINN solution are again indistinguishable. With a maximum relative error of approximately 0.35%, the PINN approach demonstrates an excellent agreement with the analytical solution.</p>
                <fig fig-type="figure" id="f7" orientation="portrait" position="float">
                    <label>
Figure 7. </label>
                    <caption>
                        <title>SEE-PINN vs. Numerical solution for case 3.2.5.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr7" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure7.gif"/>
                </fig>
                <p>

                    <bold>3.2.6 Euler beam with variable Young&#x2019;s modulus and cross-section, and distributed load</bold>
                </p>
                <p>

                    <bold>Statement of the problem.</bold> The complexity is further enhanced by introducing a nonlinear variation in the Young&#x2019;s modulus of the beam,

                    <disp-formula id="e42">

                        <mml:math display="block">
                            <mml:mi>E</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mn>200</mml:mn>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mn>1</mml:mn>
                                <mml:mo>&#x2212;</mml:mo>
                                <mml:mn>0.25</mml:mn>
                                <mml:mi>x</mml:mi>
                                <mml:mo>&#x2212;</mml:mo>
                                <mml:mn>0.5</mml:mn>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msup>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mspace width="0.25em"/>
                            <mml:mi mathvariant="italic">GPa</mml:mi>
                        </mml:math>

                        <label>(42)</label>
</disp-formula>while keeping all other parameters unchanged. The cross-sectional area continues to vary according to 
                    <xref ref-type="disp-formula" rid="e41">Eq. (41)</xref>.</p>
                <p>

                    <bold>SEE-PINN solution.</bold> The same neural network has been employed to approximate the deflection of the beam; one fully connected layer, with 10 neurons, and each neuron employs the tanh activation function. The network is trained at 75 points using the Adam optimizer with learning rate 0.001 for 10000 epochs.</p>
                <p>

                    <bold>Comparison and error analysis.</bold> The predicted solution is compared against a numerical reference for validation. 
                    <xref ref-type="fig" rid="f8">
Figure 8</xref> illustrates that the analytic and the PINN solution are again indistinguishable. With a maximum relative error of approximately 0.4%, the PINN approach demonstrates an excellent agreement with the analytical solution.</p>
                <fig fig-type="figure" id="f8" orientation="portrait" position="float">
                    <label>
Figure 8. </label>
                    <caption>
                        <title>SEE-PINN vs. Numerical solution for case 3.2.6.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr8" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure8.gif"/>
                </fig>
            </sec>
            <sec id="sec8">
                <title>3.3 Performance</title>
                <p>The performance of the introduced methodology is assessed by comparison to existing models. The objective is to demonstrate that the suggested approach yields the same solution while utilizing significantly fewer computational resources. Given that the precise technical details of each study are not known, theoretical estimates of computational requirements and complexity have been derived from the respective network architectures.</p>
                <p>

                    <bold>3.3.1 Performance metric</bold>
                </p>
                <p>This analysis evaluates the floating point operations (FLOPs) required for both the forward and backward passes as a key metric for assessing the performance of a neural network. While other metrics, such as the memory needed to store weights, biases, and intermediate results, could also be considered, a more detailed examination of these factors is beyond the scope of this paper.</p>
                <p>According to 
                    <xref ref-type="disp-formula" rid="e1">Eq. (1)</xref>, a neuron in fully connected layer performs three basic operations: (a) multiplication of every input with a weight, i.e. 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">in</mml:mtext>
                            </mml:msub>
                        </mml:math>
</inline-formula> operations, (b) summation of all input-weight products, i.e. 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">in</mml:mtext>
                            </mml:msub>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mn>1</mml:mn>
                        </mml:math>
</inline-formula> operations, and (c) addition of a bias, i.e. 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:mn>1</mml:mn>
                        </mml:math>
</inline-formula> operation. Thus, for a layer with 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">in</mml:mtext>
                            </mml:msub>
                        </mml:math>
</inline-formula> inputs an 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">out</mml:mtext>
                            </mml:msub>
                        </mml:math>
</inline-formula> outputs, the required number of FLOPs for a forward pass is:
                    <disp-formula id="e43">

                        <mml:math display="block">
                            <mml:msubsup>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">FWD</mml:mi>
                                <mml:mi>L</mml:mi>
                            </mml:msubsup>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msub>
                                    <mml:mi>N</mml:mi>
                                    <mml:mtext mathvariant="italic">in</mml:mtext>
                                </mml:msub>
                                <mml:mo>,</mml:mo>
                                <mml:msub>
                                    <mml:mi>N</mml:mi>
                                    <mml:mtext mathvariant="italic">out</mml:mtext>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">[</mml:mo>
                                <mml:msub>
                                    <mml:mi>N</mml:mi>
                                    <mml:mtext mathvariant="italic">in</mml:mtext>
                                </mml:msub>
                                <mml:mo>+</mml:mo>
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:msub>
                                        <mml:mi>N</mml:mi>
                                        <mml:mtext mathvariant="italic">in</mml:mtext>
                                    </mml:msub>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                    <mml:mo stretchy="true">)</mml:mo>
                                </mml:mrow>
                                <mml:mo>+</mml:mo>
                                <mml:mn>1</mml:mn>
                                <mml:mo stretchy="true">]</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">out</mml:mtext>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>2</mml:mn>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">in</mml:mtext>
                            </mml:msub>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mtext mathvariant="italic">out</mml:mtext>
                            </mml:msub>
                        </mml:math>

                        <label>(43)</label>
</disp-formula>
</p>
                <p>The backpropagation process is more complex than the forward pass and is assumed to require three times as many FLOPs; 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">BKD</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>3</mml:mn>
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">FWD</mml:mi>
                            </mml:msub>
                        </mml:math>
</inline-formula>. For simplicity, the computations needed for activation functions are considered minimal, so any additional overhead calculations&#x2014;which may vary by implementation&#x2014;are not included. Therefore, the total computational load is calculated by multiplying the total number of FLOPs required for both the forward pass and backpropagation by the number of training points and the number of epochs.</p>
                <p>

                    <bold>3.3.2 Case studies</bold>

                    <statement id="state1">
                        <label>Case 1.</label>
                        <p>Wang et al.
                            <sup>
                                <xref ref-type="bibr" rid="ref24">24</xref>
                            </sup> have conducted simulations on a 10 m long homogeneous rod featuring a cross-sectional area of 1 m
                            <sup>2</sup>, composed of a material characterized by a Young&#x2019;s modulus of 175 Pa. The rod was fixed at both ends and subjected to a distributed load:
                            <disp-formula id="e44">

                                <mml:math display="block">
                                    <mml:mi>b</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>=</mml:mo>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mfrac>
                                        <mml:mrow>
                                            <mml:mn>4</mml:mn>
                                            <mml:msup>
                                                <mml:mi>&#x03c0;</mml:mi>
                                                <mml:mn>2</mml:mn>
                                            </mml:msup>
                                            <mml:msup>
                                                <mml:mrow>
                                                    <mml:mo stretchy="true">(</mml:mo>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mn>2.5</mml:mn>
                                                    <mml:mo stretchy="true">)</mml:mo>
                                                </mml:mrow>
                                                <mml:mn>2</mml:mn>
                                            </mml:msup>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mi>&#x03c0;</mml:mi>
                                        </mml:mrow>
                                        <mml:msup>
                                            <mml:mi>e</mml:mi>
                                            <mml:mrow>
                                                <mml:mi>&#x03c0;</mml:mi>
                                                <mml:msup>
                                                    <mml:mrow>
                                                        <mml:mo stretchy="true">(</mml:mo>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mn>2.5</mml:mn>
                                                        <mml:mo stretchy="true">)</mml:mo>
                                                    </mml:mrow>
                                                    <mml:mn>2</mml:mn>
                                                </mml:msup>
                                            </mml:mrow>
                                        </mml:msup>
                                    </mml:mfrac>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mfrac>
                                        <mml:mrow>
                                            <mml:mn>8</mml:mn>
                                            <mml:msup>
                                                <mml:mi>&#x03c0;</mml:mi>
                                                <mml:mn>2</mml:mn>
                                            </mml:msup>
                                            <mml:msup>
                                                <mml:mrow>
                                                    <mml:mo stretchy="true">(</mml:mo>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mn>7.5</mml:mn>
                                                    <mml:mo stretchy="true">)</mml:mo>
                                                </mml:mrow>
                                                <mml:mn>2</mml:mn>
                                            </mml:msup>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mn>4</mml:mn>
                                            <mml:mi>&#x03c0;</mml:mi>
                                        </mml:mrow>
                                        <mml:msup>
                                            <mml:mi>e</mml:mi>
                                            <mml:mrow>
                                                <mml:mi>&#x03c0;</mml:mi>
                                                <mml:msup>
                                                    <mml:mrow>
                                                        <mml:mo stretchy="true">(</mml:mo>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mn>7.5</mml:mn>
                                                        <mml:mo stretchy="true">)</mml:mo>
                                                    </mml:mrow>
                                                    <mml:mn>2</mml:mn>
                                                </mml:msup>
                                            </mml:mrow>
                                        </mml:msup>
                                    </mml:mfrac>
                                </mml:math>

                                <label>(44)</label>
</disp-formula>
                        </p>
                    </statement>
                </p>
                <p>The authors addressed the problem by utilizing a PINN comprising 6 hidden layers, with each layer containing 512 neurons employing the ReLU activation function. The model was trained for 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>e</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>50,000</mml:mn>
                        </mml:math>
</inline-formula> epochs using 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>p</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>100</mml:mn>
                        </mml:math>
</inline-formula> data points.</p>
                <p>The computational cost for a forward pass is the total sum of FLOPs for the input layer, the six hidden layers, and the output layer, i.e.
                    <disp-formula id="e45">

                        <mml:math display="block">
                            <mml:mtable displaystyle="true">
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:maligngroup/>
                                        <mml:msub>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                        </mml:msub>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>6</mml:mn>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>6</mml:mn>
                                        <mml:mo>&#x00b7;</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>512</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>3</mml:mn>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mn>147</mml:mn>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mn>776</mml:mn>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mtext mathvariant="italic">FLOPs</mml:mtext>
                                    </mml:mtd>
                                </mml:mtr>
                            </mml:mtable>
                        </mml:math>

                        <label>(45)</label>
</disp-formula>
                </p>
                <p>When including the cost of back-propagation and considering the number of training points, the total computational cost becomes:
                    <disp-formula id="e46">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">tot</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msub>
                                    <mml:mi>F</mml:mi>
                                    <mml:mi mathvariant="italic">FWD</mml:mi>
                                </mml:msub>
                                <mml:mo>+</mml:mo>
                                <mml:msub>
                                    <mml:mi>F</mml:mi>
                                    <mml:mi mathvariant="italic">BKD</mml:mi>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>p</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>e</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>4</mml:mn>
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">FWD</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>p</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>e</mml:mi>
                            </mml:msub>
                            <mml:mspace width="0.25em"/>
                            <mml:mo>&#x2248;</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mn>63</mml:mn>
                            <mml:mtext mathvariant="italic">TFLOPs</mml:mtext>
                        </mml:math>

                        <label>(46)</label>
</disp-formula>
                </p>
                <p>The solution was subsequently validated against an analytical benchmark solution:
                    <disp-formula id="e47">

                        <mml:math display="block">
                            <mml:mi>u</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mfrac>
                                <mml:mn>1</mml:mn>
                                <mml:mi mathvariant="italic">EA</mml:mi>
                            </mml:mfrac>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msup>
                                    <mml:mi>e</mml:mi>
                                    <mml:mrow>
                                        <mml:mo>&#x2212;</mml:mo>
                                        <mml:mi>&#x03c0;</mml:mi>
                                        <mml:msup>
                                            <mml:mrow>
                                                <mml:mo stretchy="true">(</mml:mo>
                                                <mml:mi>x</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mn>2.5</mml:mn>
                                                <mml:mo stretchy="true">)</mml:mo>
                                            </mml:mrow>
                                            <mml:mn>2</mml:mn>
                                        </mml:msup>
                                        <mml:mo>&#x2212;</mml:mo>
                                        <mml:msup>
                                            <mml:mi>e</mml:mi>
                                            <mml:mrow>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mn>6.25</mml:mn>
                                                <mml:mi>&#x03c0;</mml:mi>
                                            </mml:mrow>
                                        </mml:msup>
                                    </mml:mrow>
                                </mml:msup>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>+</mml:mo>
                            <mml:mfrac>
                                <mml:mn>2</mml:mn>
                                <mml:mi mathvariant="italic">EA</mml:mi>
                            </mml:mfrac>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msup>
                                    <mml:mi>e</mml:mi>
                                    <mml:mrow>
                                        <mml:mo>&#x2212;</mml:mo>
                                        <mml:mi>&#x03c0;</mml:mi>
                                        <mml:msup>
                                            <mml:mrow>
                                                <mml:mo stretchy="true">(</mml:mo>
                                                <mml:mi>x</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mn>7.5</mml:mn>
                                                <mml:mo stretchy="true">)</mml:mo>
                                            </mml:mrow>
                                            <mml:mn>2</mml:mn>
                                        </mml:msup>
                                    </mml:mrow>
                                </mml:msup>
                                <mml:mo>&#x2212;</mml:mo>
                                <mml:msup>
                                    <mml:mi>e</mml:mi>
                                    <mml:mrow>
                                        <mml:mo>&#x2212;</mml:mo>
                                        <mml:mn>6.25</mml:mn>
                                        <mml:mi>&#x03c0;</mml:mi>
                                    </mml:mrow>
                                </mml:msup>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                        </mml:math>

                        <label>(47)</label>
</disp-formula>
                </p>
                <p>The same problem was solved using the proposed approach but with a significantly smaller network, specifically two layers containing 20 neurons each, trained on 100 points for 30,000 epochs. A comparison of the predictions with the provided analytical solution in 
                    <xref ref-type="fig" rid="f9">
Figure 9</xref> shows excellent agreement.</p>
                <fig fig-type="figure" id="f9" orientation="portrait" position="float">
                    <label>
Figure 9. </label>
                    <caption>
                        <title>SEE-PINN vs. Analytical solution for case study 1.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr9" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure9.gif"/>
                </fig>
                <p>The computational cost for a forward pass in this configuration is given:
                    <disp-formula id="e48">

                        <mml:math display="block">
                            <mml:mtable displaystyle="true">
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:maligngroup/>
                                        <mml:msub>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                        </mml:msub>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>2</mml:mn>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>2</mml:mn>
                                        <mml:mo>&#x00b7;</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>20</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>1600</mml:mn>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mtext mathvariant="italic">FLOPs</mml:mtext>
                                    </mml:mtd>
                                </mml:mtr>
                            </mml:mtable>
                        </mml:math>

                        <label>(48)</label>
</disp-formula>
and the total cost is 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">tot</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>20.16</mml:mn>
                            <mml:mspace width="0.25em"/>
                            <mml:mtext mathvariant="italic">GFLOPs</mml:mtext>
                        </mml:math>
</inline-formula> which is three orders of magnitude lower than the original approach.
                    <statement id="state2">
                        <label>Case 2.</label>
                        <p>Singh et al.
                            <sup>
                                <xref ref-type="bibr" rid="ref25">25</xref>
                            </sup> simulated the bending of a 1 m long homogeneous Euler beam with a moment of inertia I = 1.0, made of a material with Young&#x2019;s modulus of 1.0 Pa. The beam was fixed at one end and subjected to a distributed load:
                            <disp-formula id="e49">

                                <mml:math display="block">
                                    <mml:mi>p</mml:mi>
                                    <mml:mrow>
                                        <mml:mo stretchy="true">(</mml:mo>
                                        <mml:mi>x</mml:mi>
                                        <mml:mo stretchy="true">)</mml:mo>
                                    </mml:mrow>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>1</mml:mn>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mi>x</mml:mi>
                                </mml:math>

                                <label>(49)</label>
</disp-formula>
                        </p>
                    </statement>
                </p>
                <p>To solve this problem, the authors employed a PINN with 5 hidden layers, each containing 50 neurons using the tanh activation function. The model was trained for 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>e</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>300</mml:mn>
                        </mml:math>
</inline-formula> epochs using 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>p</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>51</mml:mn>
                        </mml:math>
</inline-formula> data points.</p>
                <p>The computational cost for a forward pass is the total sum of FLOPs for the input layer, the five hidden layers, and the output layer, i.e.
                    <disp-formula id="e50">

                        <mml:math display="block">
                            <mml:mtable displaystyle="true">
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:maligngroup/>
                                        <mml:msub>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                        </mml:msub>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>5</mml:mn>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>5</mml:mn>
                                        <mml:mo>&#x00b7;</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>50</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>25</mml:mn>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mn>200</mml:mn>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mtext mathvariant="italic">FLOPs</mml:mtext>
                                    </mml:mtd>
                                </mml:mtr>
                            </mml:mtable>
                        </mml:math>

                        <label>(50)</label>
</disp-formula>
                </p>
                <p>Taking into account the cost of back-propagation, the number of training points and the number of epochs, the total computational cost is given by:
                    <disp-formula id="e51">

                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">tot</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:msub>
                                    <mml:mi>F</mml:mi>
                                    <mml:mi mathvariant="italic">FWD</mml:mi>
                                </mml:msub>
                                <mml:mo>+</mml:mo>
                                <mml:msub>
                                    <mml:mi>F</mml:mi>
                                    <mml:mi mathvariant="italic">BKD</mml:mi>
                                </mml:msub>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>p</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>e</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>4</mml:mn>
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">FWD</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>p</mml:mi>
                            </mml:msub>
                            <mml:mo>&#x00b7;</mml:mo>
                            <mml:msub>
                                <mml:mi>N</mml:mi>
                                <mml:mi>e</mml:mi>
                            </mml:msub>
                            <mml:mspace width="0.25em"/>
                            <mml:mo>&#x2248;</mml:mo>
                            <mml:mspace width="0.25em"/>
                            <mml:mn>1.54</mml:mn>
                            <mml:mtext mathvariant="italic">GFLOPs</mml:mtext>
                        </mml:math>

                        <label>(51)</label>
</disp-formula>
                </p>
                <p>The solution was validated against an analytical benchmark solution:
                    <disp-formula id="e52">

                        <mml:math display="block">
                            <mml:mi>w</mml:mi>
                            <mml:mrow>
                                <mml:mo stretchy="true">(</mml:mo>
                                <mml:mi>x</mml:mi>
                                <mml:mo stretchy="true">)</mml:mo>
                            </mml:mrow>
                            <mml:mo>=</mml:mo>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mfrac>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>5</mml:mn>
                                </mml:msup>
                                <mml:mn>120</mml:mn>
                            </mml:mfrac>
                            <mml:mo>+</mml:mo>
                            <mml:mfrac>
                                <mml:msup>
                                    <mml:mi>x</mml:mi>
                                    <mml:mn>4</mml:mn>
                                </mml:msup>
                                <mml:mn>24</mml:mn>
                            </mml:mfrac>
                        </mml:math>

                        <label>(52)</label>
</disp-formula>
                </p>
                <p>The same problem was solved using the proposed approach but with a significantly smaller network: a single hidden layer with 10 neurons, trained on 75 points for 1,000 epochs. As shown in 
                    <xref ref-type="fig" rid="f10">
Figure 10</xref>, the predictions closely match the analytical solution, demonstrating excellent agreement.</p>
                <fig fig-type="figure" id="f10" orientation="portrait" position="float">
                    <label>
Figure 10. </label>
                    <caption>
                        <title>SEE-PINN vs. Analytical solution for case study 2.</title>
                        <p>(a) Direct comparison of predictions. (b) Parity plot of predicted vs. reference solution.</p>
                    </caption>
                    <graphic id="gr10" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure10.gif"/>
                </fig>
                <p>The computational cost for a forward pass using the SEE-PINN configuration is given:
                    <disp-formula id="e53">

                        <mml:math display="block">
                            <mml:mtable displaystyle="true">
                                <mml:mtr>
                                    <mml:mtd>
                                        <mml:maligngroup/>
                                        <mml:msub>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                        </mml:msub>
                                    </mml:mtd>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>1</mml:mn>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>F</mml:mi>
                                            <mml:mi mathvariant="italic">FWD</mml:mi>
                                            <mml:mi>L</mml:mi>
                                        </mml:msubsup>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">(</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo>,</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">)</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>5</mml:mn>
                                        <mml:mo>&#x00b7;</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                        <mml:mo>+</mml:mo>
                                        <mml:mrow>
                                            <mml:mo stretchy="true">[</mml:mo>
                                            <mml:mn>2</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>10</mml:mn>
                                            <mml:mo>&#x00b7;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                            <mml:mo stretchy="true">]</mml:mo>
                                        </mml:mrow>
                                    </mml:mtd>
                                </mml:mtr>
                                <mml:mtr>
                                    <mml:mtd/>
                                    <mml:mtd>
                                        <mml:mo>=</mml:mo>
                                        <mml:mn>240</mml:mn>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mtext mathvariant="italic">FLOPs</mml:mtext>
                                    </mml:mtd>
                                </mml:mtr>
                            </mml:mtable>
                        </mml:math>

                        <label>(53)</label>
</disp-formula>and the total cost is 
                    <inline-formula>

                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>F</mml:mi>
                                <mml:mi mathvariant="italic">tot</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mn>72</mml:mn>
                            <mml:mspace width="0.25em"/>
                            <mml:mtext mathvariant="italic">MFLOPs</mml:mtext>
                        </mml:math>
</inline-formula> which is two orders of magnitude lower than the original approach. Performance efficiency is visually demonstrated by comparison in 
                    <xref ref-type="fig" rid="f11">
Figure 11</xref>.</p>
                <fig fig-type="figure" id="f11" orientation="portrait" position="float">
                    <label>
Figure 11. </label>
                    <caption>
                        <title>Performance comparisons between SEE-PINN and SOA models in literature (Lower is better).</title>
                        <p>The proposed approach requires 2-3 times less FLOPs.</p>
                    </caption>
                    <graphic id="gr11" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/194668/26e798f9-3638-4bc9-96ad-6b73675abaec_figure11.gif"/>
                </fig>
            </sec>
        </sec>
        <sec id="sec9">
            <title>4. Summary and discussion</title>
            <p>The proposed methodology offers an efficient and streamlined approach for solving ordinary differential equations (ODEs) with Physics-Informed Neural Networks (PINNs) by directly scaling the terms of the governing equations, rather than introducing balancing weights within the loss function. Each term is normalized using characteristic physical dimensions, bringing all contributions to a similar order of magnitude close to unity. This ensures numerical consistency and eliminates the need for complex and computationally intensive loss-balancing procedures. The scaled equations are solved within a PINN framework, after which a reverse scaling step restores the solution to the physical domain.</p>
            <p>The method has been demonstrated through nonlinear one-dimensional elasticity problems, including rod and Euler&#x2013;Bernoulli beam cases. The results show that high accuracy can be achieved with extremely compact network architectures &#x2013; even a single hidden layer with ten nodes &#x2013; while maintaining negligible maximum percentage error across collocation points. Benchmarking against existing PINN approaches reveals that the proposed scaling strategy reduces floating-point operations (FLOPs) by at least two orders of magnitude, underscoring its potential to deliver substantial computational savings without compromising precision.</p>
            <p>While promising, the method also presents opportunities for further development:
                <list list-type="order">
                    <list-item>
                        <label>1.</label>
                        <p>

                            <bold>Optimal Hyperparameter Selection:</bold> Automated, self-tuning strategies remain an open research goal to avoid case-by-case manual tuning.</p>
                    </list-item>
                    <list-item>
                        <label>2.</label>
                        <p>

                            <bold>Extension to Higher Dimensions:</bold> Applying the methodology to 2D and 3D problems, where term coupling increases complexity, is a priority.</p>
                    </list-item>
                    <list-item>
                        <label>3.</label>
                        <p>

                            <bold>Highly Nonlinear and Discontinuous Cases:</bold> Future work will target problems with sharp gradients, contact conditions, discontinuities, and dynamic effects.</p>
                    </list-item>
                    <list-item>
                        <label>4.</label>
                        <p>

                            <bold>Time-Dependent Problems:</bold> These can be addressed by treating time as an additional dimension or by adopting time-aware neural architectures such as LSTMs.</p>
                    </list-item>
                </list>
            </p>
            <p>In conclusion, the proposed scaling-based PINN framework (SEE-PINN) demonstrates that direct differential equation term scaling can fundamentally simplify and accelerate the training of PINNs for nonlinear problems. By completely removing the reliance on elaborate and costly loss-balancing mechanisms, it enables the use of compact, fast, and accurate models that are easier to deploy in real-world engineering settings. The combination of high accuracy, drastic computational savings, and straightforward implementation positions SEE-PINN as a practical and scalable tool, with the potential to reshape how machine learning is applied to challenging differential equation problems in computational mechanics and beyond.</p>
        </sec>
        <sec id="sec10">
            <title>Ethics and consent</title>
            <p>Ethical approval and consent were not required.</p>
        </sec>
    </body>
    <back>
        <sec id="sec13" sec-type="data-availability">
            <title>Data availability</title>
            <p>The data required to reproduce graphs and figures are available under CC-BY 4.0 license 
                <ext-link ext-link-type="uri" xlink:href="https://zenodo.org/records/16909058">https://zenodo.org/records/16909058</ext-link>, 10.5281/zenodo.16909058.
                <sup>
                    <xref ref-type="bibr" rid="ref26">26</xref>
                </sup>
            </p>
        </sec>
        <ack>
            <title>Acknowledgement</title>
            <p>The publication of the article in Open Access mode was financially supported by HEAL-Link (HEAL1000 Gateway). The authors employed ChatGPT 4 for proofreading specific paragraphs of this manuscript; however, all ideas, analyses, methods, results and conclusions presented remain solely those of the authors.</p>
        </ack>
        <ref-list>
            <title>References</title>
            <ref id="ref1">
                <label>1</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Raissi</surname>
                            <given-names>M</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Perdikaris</surname>
                            <given-names>P</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Karniadakis</surname>
                            <given-names>GE</given-names>
                        </name>
</person-group>:
                    <article-title>Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations.</article-title>
                    <source>

                        <italic toggle="yes">J Comput Phys.</italic>
</source>
                    <year>2019</year>;<volume>378</volume>:<fpage>686</fpage>&#x2013;<lpage>707</lpage>.
                    <pub-id pub-id-type="doi">10.1016/j.jcp.2018.10.045</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref2">
                <label>2</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Wang</surname>
                            <given-names>Y</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Yao</surname>
                            <given-names>Y</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Guo</surname>
                            <given-names>J</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>A practical PINN framework for multi-scale problems with multi-magnitude loss terms.</article-title>
                    <source>

                        <italic toggle="yes">J Comput Phys.</italic>
</source>
                    <year>2024</year>;<volume>510</volume>:<fpage>113112</fpage>.
                    <pub-id pub-id-type="doi">10.1016/j.jcp.2024.113112</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref3">
                <label>3</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Deguchi</surname>
                            <given-names>S</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Asai</surname>
                            <given-names>M</given-names>
                        </name>
</person-group>:
                    <article-title>Dynamic &amp; norm-based weights to normalize imbalance in back-propagated gradients of physics-informed neural networks.</article-title>
                    <source>

                        <italic toggle="yes">J Phys Commun.</italic>
</source>
                    <year>2023</year>;<volume>7</volume>:<fpage>075005</fpage>.
                    <pub-id pub-id-type="doi">10.1088/2399-6528/ace416</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref4">
                <label>4</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Xiang</surname>
                            <given-names>Z</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Peng</surname>
                            <given-names>W</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Liu</surname>
                            <given-names>X</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Self-adaptive loss balanced Physics-informed neural networks.</article-title>
                    <source>

                        <italic toggle="yes">Neurocomputing.</italic>
</source>
                    <year>2022</year>;<volume>496</volume>:<fpage>11</fpage>&#x2013;<lpage>34</lpage>.
                    <pub-id pub-id-type="doi">10.1016/j.neucom.2022.05.015</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref5">
                <label>5</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Li</surname>
                            <given-names>S</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Feng</surname>
                            <given-names>X</given-names>
                        </name>
</person-group>:
                    <article-title>Dynamic Weight Strategy of Physics-Informed Neural Networks for the 2D Navier&#x2013;Stokes Equations.</article-title>
                    <source>

                        <italic toggle="yes">Entropy.</italic>
</source>
                    <year>2022</year>;<volume>24</volume>:<fpage>1254</fpage>.
                    <pub-id pub-id-type="pmid">36141140</pub-id>
                    <pub-id pub-id-type="doi">10.3390/e24091254</pub-id>
                    <pub-id pub-id-type="pmcid">PMC9497516</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref6">
                <label>6</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Cao</surname>
                            <given-names>F</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Guo</surname>
                            <given-names>X</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Dong</surname>
                            <given-names>X</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>wbPINN: Weight balanced physics-informed neural networks for multi-objective learning.</article-title>
                    <source>

                        <italic toggle="yes">Applied Soft Computing.</italic>
</source>
                    <year>2025</year>;<volume>170</volume>:<fpage>112632</fpage>.
                    <pub-id pub-id-type="doi">10.1016/j.asoc.2024.112632</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref7">
                <label>7</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Vemuri</surname>
                            <given-names>SK</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Denzler</surname>
                            <given-names>J</given-names>
                        </name>
</person-group>:
                    <article-title>Gradient Statistics-Based Multi-Objective Optimization in Physics-Informed Neural Networks.</article-title>
                    <source>

                        <italic toggle="yes">Sensors.</italic>
</source>
                    <year>2023</year>;<volume>23</volume>:<fpage>8665</fpage>.
                    <pub-id pub-id-type="pmid">37960365</pub-id>
                    <pub-id pub-id-type="doi">10.3390/s23218665</pub-id>
                    <pub-id pub-id-type="pmcid">PMC10650063</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref8">
                <label>8</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Wang</surname>
                            <given-names>J</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Xiao</surname>
                            <given-names>X</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Feng</surname>
                            <given-names>X</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>An improved physics-informed neural network with adaptive weighting and mixed differentiation for solving the incompressible Navier&#x2013;Stokes equations.</article-title>
                    <source>

                        <italic toggle="yes">Nonlinear Dynam.</italic>
</source>
                    <year>2024</year>;<volume>112</volume>:<fpage>16113</fpage>&#x2013;<lpage>16134</lpage>.
                    <pub-id pub-id-type="doi">10.1007/s11071-024-09856-6</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref9">
                <label>9</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Wang</surname>
                            <given-names>S</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Teng</surname>
                            <given-names>Y</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Perdikaris</surname>
                            <given-names>P</given-names>
                        </name>
</person-group>:
                    <article-title>Understanding and Mitigating Gradient Flow Pathologies in Physics-Informed Neural Networks.</article-title>
                    <source>

                        <italic toggle="yes">SIAM J Sci Comput.</italic>
</source>
                    <year>2021</year>;<volume>43</volume>:<fpage>A3055</fpage>&#x2013;<lpage>A3081</lpage>.
                    <pub-id pub-id-type="doi">10.1137/20M1318043</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref10">
                <label>10</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Hu</surname>
                            <given-names>Z</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Shukla</surname>
                            <given-names>K</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Karniadakis</surname>
                            <given-names>GE</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Tackling the curse of dimensionality with physics-informed neural networks.</article-title>
                    <source>

                        <italic toggle="yes">Neural Networks.</italic>
</source>
                    <year>2024</year>;<volume>176</volume>:<fpage>106369</fpage>.
                    <pub-id pub-id-type="pmid">38754287</pub-id>
                    <pub-id pub-id-type="doi">10.1016/j.neunet.2024.106369</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref11">
                <label>11</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Yu</surname>
                            <given-names>J</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Lu</surname>
                            <given-names>L</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Meng</surname>
                            <given-names>X</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Gradient-enhanced physics-informed neural networks for forward and inverse PDE problems.</article-title>
                    <source>

                        <italic toggle="yes">Comput Methods Appl Mech Engrg.</italic>
</source>
                    <year>2022</year>;<volume>393</volume>:<fpage>114823</fpage>.
                    <pub-id pub-id-type="doi">10.1016/j.cma.2022.114823</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref12">
                <label>12</label>
                <mixed-citation publication-type="book">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Han</surname>
                            <given-names>J</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Cai</surname>
                            <given-names>Z</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Wu</surname>
                            <given-names>Z</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <chapter-title>Residual-Quantile Adjustment for Adaptive Training of Physics-informed Neural Network.</chapter-title>
                    <source>

                        <italic toggle="yes">2022 IEEE International Conference on Big Data (Big Data).</italic>
</source>
                    <publisher-loc>Osaka, Japan</publisher-loc>:
                    <publisher-name>IEEE</publisher-name>;<year>2022</year>; pp.<fpage>921</fpage>&#x2013;<lpage>930</lpage>.
                    <pub-id pub-id-type="doi">10.1109/BigData55660.2022.10020596</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref13">
                <label>13</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Son</surname>
                            <given-names>H</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Cho</surname>
                            <given-names>SW</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Hwang</surname>
                            <given-names>HJ</given-names>
                        </name>
</person-group>:
                    <article-title>Enhanced physics-informed neural networks with Augmented Lagrangian relaxation method (AL-PINNs).</article-title>
                    <source>

                        <italic toggle="yes">Neurocomputing.</italic>
</source>
                    <year>2023</year>;<volume>548</volume>:<fpage>126424</fpage>.
                    <pub-id pub-id-type="doi">10.1016/j.neucom.2023.126424</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref14">
                <label>14</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Luong</surname>
                            <given-names>KA</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Le-Duc</surname>
                            <given-names>T</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Lee</surname>
                            <given-names>S</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>A novel normalized reduced-order physics-informed neural network for solving inverse problems.</article-title>
                    <source>

                        <italic toggle="yes">Engineering with Computers.</italic>
</source>
                    <year>2024</year>;<volume>40</volume>:<fpage>3253</fpage>&#x2013;<lpage>3272</lpage>.
                    <pub-id pub-id-type="doi">10.1007/s00366-024-01971-7</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref15">
                <label>15</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Jha</surname>
                            <given-names>N</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Mallik</surname>
                            <given-names>E</given-names>
                        </name>
</person-group>:
                    <article-title>GPINN with Neural Tangent Kernel Technique for Nonlinear Two Point Boundary Value Problems.</article-title>
                    <source>

                        <italic toggle="yes">Neural Process Lett.</italic>
</source>
                    <year>2024</year>;<volume>56</volume>:<fpage>192</fpage>.
                    <pub-id pub-id-type="doi">10.1007/s11063-024-11644-7</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref16">
                <label>16</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Schmidhuber</surname>
                            <given-names>J</given-names>
                        </name>
</person-group>:
                    <article-title>Deep learning in neural networks: An overview.</article-title>
                    <source>

                        <italic toggle="yes">Neural Networks.</italic>
</source>
                    <year>2015</year>;<volume>61</volume>:<fpage>85</fpage>&#x2013;<lpage>117</lpage>.
                    <pub-id pub-id-type="doi">10.1016/j.neunet.2014.09.003</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref17">
                <label>17</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>LeCun</surname>
                            <given-names>Y</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Bengio</surname>
                            <given-names>Y</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Hinton</surname>
                            <given-names>G</given-names>
                        </name>
</person-group>:
                    <article-title>Deep learning.</article-title>
                    <source>

                        <italic toggle="yes">Nature.</italic>
</source>
                    <year>2015</year>;<volume>521</volume>:<fpage>436</fpage>&#x2013;<lpage>444</lpage>.
                    <pub-id pub-id-type="doi">10.1038/nature14539</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref18">
                <label>18</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Cybenko</surname>
                            <given-names>G</given-names>
                        </name>
</person-group>:
                    <article-title>Approximation by superpositions of a sigmoidal function.</article-title>
                    <source>

                        <italic toggle="yes">Math Control Signals Systems.</italic>
</source>
                    <year>1989</year>;<volume>2</volume>:<fpage>303</fpage>&#x2013;<lpage>314</lpage>.
                    <pub-id pub-id-type="doi">10.1007/BF02551274</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref19">
                <label>19</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Zhang</surname>
                            <given-names>C</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Bengio</surname>
                            <given-names>S</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Hardt</surname>
                            <given-names>M</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Understanding deep learning (still) requires rethinking generalization.</article-title>
                    <source>

                        <italic toggle="yes">Commun ACM.</italic>
</source>
                    <year>2021</year>;<volume>64</volume>:<fpage>107</fpage>&#x2013;<lpage>115</lpage>.
                    <pub-id pub-id-type="doi">10.1145/3446776</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref20">
                <label>20</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Karniadakis</surname>
                            <given-names>GE</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Kevrekidis</surname>
                            <given-names>IG</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Lu</surname>
                            <given-names>L</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Physics-informed machine learning.</article-title>
                    <source>

                        <italic toggle="yes">Nat Rev Phys.</italic>
</source>
                    <year>2021</year>;<volume>3</volume>:<fpage>422</fpage>&#x2013;<lpage>440</lpage>.
                    <pub-id pub-id-type="doi">10.1038/s42254-021-00314-5</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref21">
                <label>21</label>
                <mixed-citation publication-type="book">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Kafkas</surname>
                            <given-names>P</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Giannakopoulos</surname>
                            <given-names>G</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Rekatsinas</surname>
                            <given-names>C</given-names>
                        </name>
</person-group>:
                    <chapter-title>Solving Linear Elasticity Problems using Physics-Informed Neural Networks.</chapter-title>
                    <source>

                        <italic toggle="yes">Proceedings of the 13th Hellenic Conference on Artificial Intelligence.</italic>
</source>
                    <publisher-loc>Piraeus Greece</publisher-loc>:
                    <publisher-name>ACM</publisher-name>;<year>2024</year>; pp.<fpage>1</fpage>&#x2013;<lpage>8</lpage>.
                    <pub-id pub-id-type="doi">10.1145/3688671.3688746</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref22">
                <label>22</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Mishra</surname>
                            <given-names>S</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Molinaro</surname>
                            <given-names>R</given-names>
                        </name>
</person-group>:
                    <article-title>Estimates on the generalization error of physics-informed neural networks for approximating PDEs.</article-title>
                    <source>

                        <italic toggle="yes">IMA J Numer Anal.</italic>
</source>
                    <year>2023</year>;<volume>43</volume>:<fpage>1</fpage>&#x2013;<lpage>43</lpage>.
                    <pub-id pub-id-type="doi">10.1093/imanum/drab093</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref23">
                <label>23</label>
                <mixed-citation publication-type="book">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Langtangen</surname>
                            <given-names>HP</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Pedersen</surname>
                            <given-names>GK</given-names>
                        </name>
</person-group>:
                    <source>

                        <italic toggle="yes">Scaling of Differential Equations.</italic>
</source>
                    <publisher-loc>Cham</publisher-loc>:
                    <publisher-name>Springer International Publishing</publisher-name>;<year>2016</year>.
                    <pub-id pub-id-type="doi">10.1007/978-3-319-32726-6</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref24">
                <label>24</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Wang</surname>
                            <given-names>J</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Mo</surname>
                            <given-names>YL</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Izzuddin</surname>
                            <given-names>B</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Exact Dirichlet boundary Physics-informed Neural Network EPINN for solid mechanics.</article-title>
                    <source>

                        <italic toggle="yes">Comput Methods Appl Mech Engrg.</italic>
</source>
                    <year>2023</year>;<volume>414</volume>:<fpage>116184</fpage>.
                    <pub-id pub-id-type="doi">10.1016/j.cma.2023.116184</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref25">
                <label>25</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Singh</surname>
                            <given-names>V</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Harursampath</surname>
                            <given-names>D</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Dhawan</surname>
                            <given-names>S</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Physics-Informed Neural Network for Solving a One-Dimensional Solid Mechanics Problem.</article-title>
                    <source>

                        <italic toggle="yes">Modelling.</italic>
</source>
                    <year>2024</year>;<volume>5</volume>:<fpage>1532</fpage>&#x2013;<lpage>1549</lpage>.
                    <pub-id pub-id-type="doi">10.3390/modelling5040080</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref26">
                <label>26</label>
                <mixed-citation publication-type="other">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Theodosiou</surname>
                            <given-names>T</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Rekatsinas</surname>
                            <given-names>C</given-names>
                        </name>
</person-group>:
                    <article-title>Dataset for Physics-Informed Neural Networks without Loss Balancing: A Direct Term Scaling Approach for Nonlinear 1D Problems.</article-title>
                    <year>2025</year>.
                    <pub-id pub-id-type="doi">10.5281/ZENODO.16909058</pub-id>
                </mixed-citation>
            </ref>
        </ref-list>
    </back>
    <sub-article article-type="reviewer-report" id="report452879">
        <front-stub>
            <article-id pub-id-type="doi">10.5256/f1000research.194668.r452879</article-id>
            <title-group>
                <article-title>Reviewer response for version 2</article-title>
            </title-group>
            <contrib-group>
                <contrib contrib-type="author">
                    <name>
                        <surname>Wijakmatee</surname>
                        <given-names>Thossaporn</given-names>
                    </name>
                    <xref ref-type="aff" rid="r452879a1">1</xref>
                    <role>Referee</role>
                    <uri content-type="orcid">https://orcid.org/0000-0001-6979-3510</uri>
                </contrib>
                <aff id="r452879a1">
                    <label>1</label>Chemical Engineering, Institute of Science Tokyo, Meguro, Tokyo, Japan</aff>
            </contrib-group>
            <author-notes>
                <fn fn-type="conflict">
                    <p>
                        <bold>Competing interests: </bold>No competing interests were disclosed.</p>
                </fn>
            </author-notes>
            <pub-date pub-type="epub">
                <day>2</day>
                <month>2</month>
                <year>2026</year>
            </pub-date>
            <permissions>
                <copyright-statement>Copyright: &#x00a9; 2026 Wijakmatee T</copyright-statement>
                <copyright-year>2026</copyright-year>
                <license xlink:href="https://creativecommons.org/licenses/by/4.0/">
                    <license-p>This is an open access peer review report distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
                </license>
            </permissions>
            <related-article ext-link-type="doi" id="relatedArticleReport452879" related-article-type="peer-reviewed-article" xlink:href="10.12688/f1000research.169129.2"/>
            <custom-meta-group>
                <custom-meta>
                    <meta-name>recommendation</meta-name>
                    <meta-value>approve</meta-value>
                </custom-meta>
            </custom-meta-group>
        </front-stub>
        <body>
            <p>After reviewing the revised content, I find that the authors have addressed the previous concerns and improved the article to meet the academic standards for indexing.&#x00a0;&#x200b;&#x200b;&#x200b;&#x200b;&#x200b;&#x200b;I have no further comments to make, and I am pleased to recommend it for indexing.</p>
            <p>Is the work clearly and accurately presented and does it cite the current literature?</p>
            <p>Partly</p>
            <p>If applicable, is the statistical analysis and its interpretation appropriate?</p>
            <p>Partly</p>
            <p>Are all the source data underlying the results available to ensure full reproducibility?</p>
            <p>Partly</p>
            <p>Is the study design appropriate and is the work technically sound?</p>
            <p>Partly</p>
            <p>Are the conclusions drawn adequately supported by the results?</p>
            <p>Partly</p>
            <p>Are sufficient details of methods and analysis provided to allow replication by others?</p>
            <p>Yes</p>
            <p>Reviewer Expertise:</p>
            <p>Engineering, Machine learning, Physics-informed method, Quantum mechanics</p>
            <p>I confirm that I have read this submission and believe that I have an appropriate level of expertise to confirm that it is of an acceptable scientific standard.</p>
        </body>
    </sub-article>
    <sub-article article-type="reviewer-report" id="report439115">
        <front-stub>
            <article-id pub-id-type="doi">10.5256/f1000research.186415.r439115</article-id>
            <title-group>
                <article-title>Reviewer response for version 1</article-title>
            </title-group>
            <contrib-group>
                <contrib contrib-type="author">
                    <name>
                        <surname>Wijakmatee</surname>
                        <given-names>Thossaporn</given-names>
                    </name>
                    <xref ref-type="aff" rid="r439115a1">1</xref>
                    <role>Referee</role>
                    <uri content-type="orcid">https://orcid.org/0000-0001-6979-3510</uri>
                </contrib>
                <aff id="r439115a1">
                    <label>1</label>Chemical Engineering, Institute of Science Tokyo, Meguro, Tokyo, Japan</aff>
            </contrib-group>
            <author-notes>
                <fn fn-type="conflict">
                    <p>
                        <bold>Competing interests: </bold>No competing interests were disclosed.</p>
                </fn>
            </author-notes>
            <pub-date pub-type="epub">
                <day>31</day>
                <month>12</month>
                <year>2025</year>
            </pub-date>
            <permissions>
                <copyright-statement>Copyright: &#x00a9; 2025 Wijakmatee T</copyright-statement>
                <copyright-year>2025</copyright-year>
                <license xlink:href="https://creativecommons.org/licenses/by/4.0/">
                    <license-p>This is an open access peer review report distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
                </license>
            </permissions>
            <related-article ext-link-type="doi" id="relatedArticleReport439115" related-article-type="peer-reviewed-article" xlink:href="10.12688/f1000research.169129.1"/>
            <custom-meta-group>
                <custom-meta>
                    <meta-name>recommendation</meta-name>
                    <meta-value>approve-with-reservations</meta-value>
                </custom-meta>
            </custom-meta-group>
        </front-stub>
        <body>
            <p>The authors propose a scaled equation-enhanced physics-informed neural network (SEE-PINN) for nonlinear one-dimensional problems, specifically mechanical systems such as an elastic rod and an Euler beam. The topic is interesting, and several computational aspects are explained in detail. However, several points require clarification to better articulate the originality, motivation, and logical structure of the study. After addressing the issues outlined below, the manuscript may be reconsidered for publication. 
                <list list-type="order">
                    <list-item>
                        <p>Based on the statement, &#x201c;Further more, our proposed method is straightforward to implement, as demonstrated through a step-by-step application to two distinct mechanical problems: an elastic rod and an Euler beam&#x201d;, please clarify the motivation for selecting these two problems as representative case studies.</p>
                    </list-item>
                    <list-item>
                        <p>The novelty of the SEE-PINN framework should be more clearly articulated. From the reviewer&#x2019;s perspective, several scale-consistent or equation-enhanced learning approaches already exist in the literature. The authors should explicitly distinguish SEE-PINN from existing methods and emphasize its unique contributions.</p>
                    </list-item>
                    <list-item>
                        <p>In Section 3.2 (Validation), the source of the data used for validation is unclear. Please clarify whether the data were obtained from experiments conducted by the authors or sourced from existing literature.</p>
                    </list-item>
                    <list-item>
                        <p>In Section 3.2, is the use of 75 training data points appropriate for the PINN framework? Please justify the selection of this number.</p>
                    </list-item>
                    <list-item>
                        <p>Please explain the rationale for choosing the Adam optimizer with a learning rate of 0.01 and 5000 training epochs throughout Section 3.2.</p>
                    </list-item>
                    <list-item>
                        <p>The x- and y-axis scales in the parity plots (Figures 3b, 7b, and 8b) are not consistent, which makes comparison somewhat difficult. Please revise these figures for clarity.</p>
                    </list-item>
                    <list-item>
                        <p>Although the relative error defined in Equation 36 is reported, metrics such as MAE or RMSE may be more informative for practical applications and acceptable error assessment in physical units. Please consider including these metrics.</p>
                    </list-item>
                    <list-item>
                        <p>In Section 3.3.2 (Case Studies), reporting quantitative error metrics would better demonstrate that the proposed method reduces computational cost while maintaining acceptable accuracy.</p>
                    </list-item>
                    <list-item>
                        <p>The term &#x201c;the authors&#x201d; used in Section 3.3.2 is ambiguous. Please clarify whether it refers to the authors of the current study or to authors of referenced works.</p>
                    </list-item>
                    <list-item>
                        <p>In case 2 of Section 3.3.2, please explain the reason for using a different number of training data points compared with the reference study.</p>
                    </list-item>
                    <list-item>
                        <p>Since SEE-PINN is the main contribution of this work, Section 4 should be revised to place greater emphasis on its advantages, limitations, and implications.</p>
                    </list-item>
                </list>
            </p>
            <p>Is the work clearly and accurately presented and does it cite the current literature?</p>
            <p>Partly</p>
            <p>If applicable, is the statistical analysis and its interpretation appropriate?</p>
            <p>Partly</p>
            <p>Are all the source data underlying the results available to ensure full reproducibility?</p>
            <p>Partly</p>
            <p>Is the study design appropriate and is the work technically sound?</p>
            <p>Partly</p>
            <p>Are the conclusions drawn adequately supported by the results?</p>
            <p>Partly</p>
            <p>Are sufficient details of methods and analysis provided to allow replication by others?</p>
            <p>Yes</p>
            <p>Reviewer Expertise:</p>
            <p>Engineering, Machine learning, Physics-informed method, Quantum mechanics</p>
            <p>I confirm that I have read this submission and believe that I have an appropriate level of expertise to confirm that it is of an acceptable scientific standard, however I have significant reservations, as outlined above.</p>
        </body>
        <sub-article article-type="response" id="comment15186-439115">
            <front-stub>
                <contrib-group>
                    <contrib contrib-type="author">
                        <name>
                            <surname>Theodosiou</surname>
                            <given-names>Theodosios</given-names>
                        </name>
                        <aff>Dept. of Energy Systems, University of Thessaly, Larissa, Thessalia Larissa, Greece</aff>
                    </contrib>
                </contrib-group>
                <author-notes>
                    <fn fn-type="conflict">
                        <p>
                            <bold>Competing interests: </bold>No competing interests were disclosed.</p>
                    </fn>
                </author-notes>
                <pub-date pub-type="epub">
                    <day>2</day>
                    <month>1</month>
                    <year>2026</year>
                </pub-date>
            </front-stub>
            <body>
                <p>We would like to sincerely thank the reviewer for the time and effort devoted to the evaluation of our manuscript and for the constructive comments provided. All reviewer comments have been addressed in full. The changes referenced below pertain to the revised version of the manuscript (Version 2), which is currently under submission. Detailed point-by-point responses to each reviewer comment follow.</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 1</bold>
                    </underline>
                </p>
                <p> &#x201c;Based on the statement, &#x2018;Furthermore, our proposed method is straightforward to implement, as demonstrated through a step-by-step application to two distinct mechanical problems: an elastic rod and an Euler beam&#x2019;, please clarify the motivation for selecting these two problems as representative case studies.&#x201d;</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this comment. The elastic rod and Euler&#x2013;Bernoulli beam problems were deliberately selected as representative benchmarks for three main reasons.</p>
                <p> First, they constitute canonical one-dimensional boundary value problems in solid mechanics, widely used in the PINN literature, which enables direct comparison with existing methods.</p>
                <p> Second, although both problems are one-dimensional, they differ fundamentally in the order of their governing differential equations (second-order for the rod and fourth-order for the beam), as well as in the number and type of boundary conditions required. This allows us to demonstrate that the proposed SEE-PINN framework is not tailored to a specific equation order or boundary-condition structure.</p>
                <p> Third, both problems naturally admit spatially varying material and geometric properties, leading to strong coefficient imbalance across equation terms. This makes them particularly suitable for assessing the effectiveness of direct equation-term scaling, which is the core contribution of this work.</p>
                <p> By applying the same normalization and training procedure to both cases, we demonstrate that SEE-PINN is a general, systematic, and easily transferable framework rather than a problem-specific solution.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Introduction - Added a new paragraph right after mentioning the rod and beam problems: &#x201c;The selection of the elastic rod and Euler&#x2013;Bernoulli beam as case studies is intentional. These problems represent canonical one-dimensional boundary value problems in computational mechanics and are frequently adopted as benchmarks in the PINN literature, allowing direct comparison with existing approaches. Although both problems are one-dimensional, they differ fundamentally in the order of their governing equations (second-order for the rod and fourth-order for the beam) and in the number and nature of boundary conditions. This enables a clear demonstration that the proposed PINN framework is not limited to a specific equation order or boundary-condition structure. Moreover, both formulations naturally allow for spatially varying material and geometric properties, which induce strong imbalance among equation terms and therefore provide an ideal testbed for evaluating the effectiveness of direct differential equation term scaling.&#x201d;</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 2</bold>
                    </underline>
                </p>
                <p> The novelty of the SEE-PINN framework should be more clearly articulated. From the reviewer&#x2019;s perspective, several scale-consistent or equation-enhanced learning approaches already exist in the literature. The authors should explicitly distinguish SEE-PINN from existing methods and emphasize its unique contributions.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We appreciate the reviewer&#x2019;s observation and agree that the distinction between SEE-PINN and existing scale-consistent or equation-enhanced approaches should be made more explicit. While several methods address imbalance in PINNs through normalization, adaptive weighting, or equation reformulation, the proposed SEE-PINN differs fundamentally in both philosophy and implementation.</p>
                <p> Existing scale-consistent or equation-enhanced approaches typically (i) introduce additional hyperparameters, (ii) modify the loss function through adaptive or data-driven weighting, or (iii) increase the complexity of the training process by incorporating gradient statistics, auxiliary optimization loops, or higher-order residuals. In contrast, SEE-PINN performs a (pre-training) physically motivated scaling of the governing differential equation itself, prior to the construction of the loss function.</p>
                <p> The key novelty of SEE-PINN lies in the fact that loss balancing is eliminated entirely, rather than mitigated or adaptively corrected during training. Once the governing equation is expressed in a normalized, scale-consistent form, all residual terms naturally contribute at comparable magnitudes, allowing standard optimization settings to be used without additional tuning. This results in a simpler, deterministic, and computationally efficient PINN formulation.</p>
                <p> Furthermore, unlike reduced-order or reformulated PINN variants, SEE-PINN does not alter the mathematical structure of the problem, introduce auxiliary constraints, or require problem-specific architectural modifications. A single reverse-scaling step restores the solution to the physical domain, preserving full physical interpretability.</p>
                <p> To clarify these distinctions, the manuscript has been revised to explicitly position SEE-PINN relative to existing scale-consistent and equation-enhanced PINN methodologies.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Introduction - Added a new paragraph to describe the novelties: &#x201c;Although several scale-consistent, normalized, or equation-enhanced PINN variants have been proposed in the literature, most of these approaches address imbalance indirectly by introducing adaptive weights, auxiliary optimization strategies, or additional loss terms. In contrast, the proposed Scaled Equation-Enhanced PINN (SEE-PINN) introduces a fundamentally different paradigm: the governing differential equation itself is rescaled prior to training using physically meaningful characteristic quantities. This preprocessing step ensures that all residual terms naturally operate at comparable magnitudes, thereby eliminating the need for loss-balancing mechanisms altogether. As a result, SEE-PINN transforms the PINN training process into a simpler, deterministic, and computationally efficient workflow, without altering the mathematical structure of the problem or introducing additional hyperparameters.&#x201d;</p>
                <p> Section 2 - Added the following clarification at the end of 2.2 (right before&#x00a0; starting to examine the elastic rod - 2.2.1): &#x201c;It is important to distinguish the proposed SEE-PINN framework from existing approaches that aim to alleviate loss-term imbalance in PINNs. Adaptive weighting methods dynamically modify the contribution of each loss term during training, often relying on gradient statistics, probabilistic models, or auxiliary optimization loops. Gradient-enhanced or equation-augmented PINNs enrich the loss function by incorporating higher-order derivatives or additional residual constraints, increasing both computational cost and implementation complexity.</p>
                <p> In contrast, SEE-PINN operates exclusively at the level of the governing differential equation. By rescaling each term using characteristic physical quantities prior to training, the resulting normalized equation is inherently balanced. Consequently, the loss function remains simple and fixed throughout training, and standard optimizers can be employed without tuning or adaptive mechanisms. This shift of complexity from the optimization stage to a one-time, physics-driven preprocessing step constitutes the central novelty of the proposed framework.&#x201d;</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 3</bold>
                    </underline>
                </p>
                <p> In Section 3.2 (Validation), the source of the data used for validation is unclear. Please clarify whether the data were obtained from experiments conducted by the authors or sourced from existing literature.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for pointing out this lack of clarity. No experimental data are used in this study. All validation data are obtained either from closed-form analytical solutions (when available) or from high-resolution numerical solutions generated for reference purposes.</p>
                <p> Specifically, for validation cases with constant material and geometric properties, analytical solutions are employed as ground truth. For cases involving spatially varying or nonlinear properties, where analytical solutions are not available, reference solutions are obtained using conventional numerical methods. The manuscript has been revised to explicitly state the origin of the validation data in Section 3.2 to ensure full transparency and reproducibility.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Section 3.2 - Added a new paragraph (right before the first rod analysis &#x2013; 3.2.1): &#x201c;The validation data employed in this section do not originate from experimental measurements. For problems with constant material and geometric properties, analytical solutions are available and are used as reference benchmarks. In cases involving spatially varying or nonlinear material and geometric properties, where closed-form solutions are not available, high-resolution numerical solutions are generated and used for validation. These numerical references serve solely as ground truth for assessing the accuracy of the proposed SEE-PINN framework.&#x201d;</p>
                <p> Section &#x2018;Data Availability&#x2019; - Added a clarification: &#x201c;The reference numerical solutions used for validation were generated using conventional numerical methods and are included in the shared dataset to ensure full reproducibility.&#x201d;</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 4</bold>
                    </underline>
                </p>
                <p> In Section 3.2, is the use of 75 training data points appropriate for the PINN framework? Please justify the selection of this number.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this important question. The selection of 75 training (collocation) points is intentional and directly linked to the objectives of this study. The primary aim of SEE-PINN is to demonstrate that physically consistent equation-term scaling significantly improves training efficiency, allowing accurate solutions to be obtained with compact network architectures and a limited number of collocation points.</p>
                <p> In all validation cases, the governing equations are one-dimensional, and the scaling procedure ensures that all residual terms operate at comparable magnitudes. Under these conditions, a relatively small number of uniformly distributed collocation points is sufficient to accurately capture the solution. Increasing the number of training points beyond this value was observed to yield negligible improvements in accuracy while proportionally increasing computational cost.</p>
                <p> Furthermore, the same number of training points is consistently used across multiple problems of increasing complexity, demonstrating the robustness of the proposed approach rather than problem-specific tuning. The manuscript has been revised to clarify the rationale behind this choice.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Section 3.2 - Added a clarification (after the introductory paragraph): &#x201c;All validation cases employ 75 uniformly distributed collocation points. This choice reflects a deliberate trade-off between accuracy and computational efficiency. Due to the physically consistent scaling of the governing equations, the residual terms are well-balanced, allowing accurate solutions to be obtained with a relatively small number of training points. Increasing the number of collocation points was found to provide marginal accuracy gains while significantly increasing computational cost. Using a fixed number of training points across problems of increasing complexity further highlights the robustness and generality of the proposed SEE-PINN framework.&#x201d;</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 5</bold>
                    </underline>
                </p>
                <p> Please explain the rationale for choosing the Adam optimizer with a learning rate of 0.01 and 5000 training epochs throughout Section 3.2.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this comment. The Adam optimizer was selected due to its widespread use and demonstrated robustness in training PINNs, particularly for problems involving automatic differentiation and stiff residual landscapes.</p>
                <p> The learning rate and number of epochs were chosen to reflect a standard, non-optimized training configuration. A learning rate of 0.01 was found to provide stable and fast convergence for the scaled governing equations, while 5000 training epochs were sufficient for the loss to consistently converge below a prescribed tolerance across all validation cases. Importantly, these parameters were kept fixed across different problems to avoid case-specific tuning and to highlight the stability of the proposed SEE-PINN framework.</p>
                <p> The effectiveness of these simple and uniform training settings is a direct consequence of the proposed equation-term scaling, which ensures balanced residual contributions and mitigates training instability. The manuscript has been revised to clarify this rationale.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Section 3.2 - Added a new paragraph after the paragraph supporting the use of 75 training points: &#x201c;All validation cases employ the Adam optimizer, owing to its robustness and widespread adoption in PINN-based studies. A fixed learning rate of 0.01 and 5000 training epochs are used for the rod problems, as these values consistently lead to stable convergence of the loss function below a prescribed tolerance. These hyperparameters were intentionally kept constant across different validation cases to avoid problem-specific tuning and to demonstrate that the proposed equation-term scaling yields reliable convergence under standard optimization settings. The balanced magnitude of the scaled residual terms allows the use of simple training configurations without the need for adaptive learning rates or multi-stage optimization strategies.&#x201d;</p>
                <p> Section 3.2.4 - Added a complementary clarification to justify section of learning rate and training epochs for the beam problems: &#x201c;A smaller learning rate and a higher number of training epochs are adopted for the beam problems due to the higher-order derivatives involved in the governing equation, which increase stiffness in the optimization landscape.&#x201d;</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 6</bold>
                    </underline>
                </p>
                <p> The x- and y-axis scales in the parity plots (Figures 3b, 7b, and 8b) are not consistent, which makes comparison somewhat difficult. Please revise these figures for clarity.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this observation. All parity plots have been revised so that the x- and y-axes use identical ranges and scaling, ensuring direct visual comparability between predicted and reference solutions. This revision improves clarity and avoids any potential misinterpretation of the results. The updated figures are included in the revised manuscript. No changes in made in plotted data.</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 7</bold>
                    </underline>
                </p>
                <p> Although the relative error defined in Equation 36 is reported, metrics such as MAE or RMSE may be more informative for practical applications and acceptable error assessment in physical units. Please consider including these metrics.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this constructive suggestion. In addition to the normalized relative error, we have now included the Mean Absolute Error (MAE) and Root Mean Square Error (RMSE) as complementary quantitative metrics. These measures provide error estimates directly in physical units and facilitate practical interpretation of the results. The manuscript has been revised accordingly, and the additional metrics are reported for the validation cases.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Section 3.2 - Added a new paragraph: &#x201c;In addition to the normalized relative error, two standard error metrics are employed to quantify prediction accuracy in physical units: the Mean Absolute Error (MAE) and the Root Mean Square Error (RMSE), defined as (MEA and RMSE definitions). These metrics complement the relative error by providing absolute measures of accuracy that are directly interpretable in the physical domain.&#x201d;</p>
                <p> Figures: Figures in validation cases have been updated to include the MAE and RMSE. Also, these values are mentioned in the &#x201c;Comparison and error analysis&#x201d; paragraph of each case.</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 8</bold>
                    </underline>
                </p>
                <p> In Section 3.3.2 (Case Studies), reporting quantitative error metrics would better demonstrate that the proposed method reduces computational cost while maintaining acceptable accuracy.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this valuable suggestion. To better quantify the trade-off between computational efficiency and accuracy, quantitative error metrics have been added to the case studies in Section 3.3.2. Specifically, MAE and RMSE values are now reported alongside the computational cost estimates. These additions explicitly demonstrate that the proposed SEE-PINN framework achieves comparable accuracy to state-of-the-art PINN models while reducing computational cost by two to three orders of magnitude. The manuscript has been revised accordingly.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Figure 9: Added error metrics.</p>
                <p> Section 3.2.2 &#x2013; Case 1. Added an explanatory paragraph right after mentioning Fig. 9: &#x201c;In addition to the visual agreement shown in Figure 9, quantitative error metrics confirm the accuracy of the proposed approach.</p>
                <p> Figure 10: Added error metrics.</p>
                <p> Section 3.2.2 &#x2013; Case 2. Added an explanatory paragraph right after mentioning Fig. 10: &#x201c;Quantitative error metrics further support this observation. The MAE and RMSE obtained using SEE-PINN remain within acceptable limits for engineering applications and are comparable to the reference PINN solution, while the computational cost is reduced by approximately two orders of magnitude. This confirms that the proposed scaling-based framework maintains accuracy while significantly improving computational efficiency.&#x201d;</p>
                <p> Section 3.2.2 &#x2013; After Case 2. Added Table 1 with summary of benchmarks.</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 9</bold>
                    </underline>
                </p>
                <p> The term &#x2018;the authors&#x2019; used in Section 3.3.2 is ambiguous. Please clarify whether it refers to the authors of the current study or to authors of referenced works.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for highlighting this ambiguity. The manuscript has been revised to explicitly distinguish between the authors of the present study and the authors of the referenced works. Ambiguous instances of the term &#x201c;the authors&#x201d; have been replaced with clearer phrasing to avoid any possible confusion.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Section 3.2.2 &#x2013; Case 1:
                    <italic> </italic>Replaced &#x201c;The authors addressed&#x2026;&#x201d; with &#x201c;The authors of [24] addressed&#x2026;&#x201d;.</p>
                <p> Section 3.2.2 &#x2013; Case 2:
                    <italic> </italic>Replaced &#x201c;The authors employed&#x2026;&#x201d; with &#x201c;The authors of [25] employed&#x2026;&#x201d;.</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 10</bold>
                    </underline>
                </p>
                <p> In case 2 of Section 3.3.2, please explain the reason for using a different number of training data points compared with the reference study.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this comment. In Case 2, the number of training (collocation) points used in the present study differs from that of the reference work by Singh et al. because the objective is not to replicate the original training configuration, but to provide a conservative and fair assessment of the proposed SEE-PINN framework.</p>
                <p> Specifically, a slightly higher number of collocation points is employed in the present study to ensure that any observed reduction in computational cost arises from the compact network architecture and the proposed equation-term scaling, rather than from a reduced training dataset. Despite this conservative choice, the SEE-PINN framework achieves comparable accuracy while still requiring significantly fewer floating-point operations. The manuscript has been revised to clarify this rationale.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Section 3.2.2-Case 2 (after description of the network architecture): It is noted that the number of training (collocation) points used in the present study differs from that reported by Singh et al. A slightly higher number of collocation points is intentionally adopted to provide a conservative comparison and to ensure that the observed reduction in computational cost stems from the compact network architecture and the proposed equation-term scaling, rather than from a reduced training dataset. Despite this choice, the SEE-PINN framework achieves comparable accuracy while maintaining a substantial reduction in computational cost.</p>
                <p> </p>
                <p> 
                    <underline>
                        <bold>Comment 11</bold>
                    </underline>
                </p>
                <p> Since SEE-PINN is the main contribution of this work, Section 4 should be revised to place greater emphasis on its advantages, limitations, and implications.</p>
                <p> 
                    <bold>Response:</bold>
                </p>
                <p> We thank the reviewer for this important remark. Section 4 has been revised to explicitly focus on the advantages, limitations, and broader implications of the proposed SEE-PINN framework. The revised discussion clarifies the conditions under which the method is most effective, its current limitations, and its potential impact on the practical adoption of PINNs in computational mechanics and related fields.</p>
                <p> 
                    <bold>Changes in the manuscript:</bold>
                </p>
                <p> Section 4 has been revised based on the Reviewer&#x2019;s comment.</p>
            </body>
        </sub-article>
    </sub-article>
</article>
