efficient tracking of behavior in complex hybrid systems via hybrid

Annual Conference of the Prognostics and Health Management Society, 2010

Efficient Tracking of Behavior in Complex Hybrid Systems viaHybrid Bond Graphs

Benjamin Podgursky 1, Gautam Biswas 1, and Xenofon Koutsoukos 1

1 Dept of EECE/ISIS, Vanderbilt University, Nashville, TN, 37235, United [email protected]

[email protected]@vanderbilt.edu

ABSTRACT

For many real-world systems, which exhibit complex,nonlinear, and hybrid behavior, it is important to accu-rately track and monitor the state and health of these sys-tems. The continuous state estimation problem has beenwell studied, and a number of extensions of the Kalmanfilter to nonlinear systems have been proposed. Hy-brid state estimation poses an additional challenge, be-cause the model must be quickly updated during a modechange to facilitate accurate, real time tracking. Thispaper discusses an approach to minimize the amount ofequation regeneration necessary when the system under-goes hybrid mode changes. These equations are used asthe state update equation for an Unscented Kalman Fil-ter that tracks the system’s state. We demonstrate theeffectiveness of our approach by tracking the hybrid be-haviors of NASA’s ADAPT test bench. Results show thatour algorithm scales well for tracking large nonlinear andhybrid systems.

1. INTRODUCTIONMany mission critical systems, such as aircraft andpower generation systems, exhibit complex nonlinearand hybrid behaviors. Hybrid systems are characterizedby intervals of continuous behavior interspersed withdiscrete changes. With increased needs for safety andreliability, it is becoming important to monitor systembehavior online, and couple the monitoring system withaccurate fault detection and isolation mechanisms. In an-other example, accurate and robust tracking is the pri-mary functionality of aircraft avionics systems.

Accurate tracking of complex, nonlinear hybrid be-haviors is in itself a major challenge. In realistic sit-uations, this challenge is further compounded by noisysensors and inaccuracies in the system models. Kalmanfilters and their extensions (Lefebvre, Bruyninckx &

This is an open-access article distributed under the terms ofthe Creative Commons Attribution 3.0 United States License,which permits unrestricted use, distribution, and reproductionin any medium, provided the original author and source arecredited.

Schutter, 2004) have been used extensively for track-ing online behaviors. We briefly discuss two of the for-malisms: (1) the Extended Kalman Filter (EKF) (Welsh& Bishop, 2006), and (2) the Unscented Kalman Filter(UKF) (Julier & Uhlmann, 1997) in the next section.

Tracking the hybrid system mode and state adds addi-tional challenges to the nonlinear continuous state esti-mation problem since the modes, i.e., the configurationsof the system, and therefore, the dynamic system modelchange during system behavior evolution. For example,aircraft operate in different modes that include taxi, take-off, cruise, descend, and land. Traditionally hybrid sys-tems have been modeled as Hybrid Automata (Cuijpers& Reniers, 2005), (Henzinger, 1996), where each modeof operation is described as a state of the automaton, andthe automata specifies the transitions between differentmodes of operation. Within each mode, the continuousstate of the system is modeled by a set of differentialequations. This representation works well for modelingsmall systems; however, modeling of large, complex sys-tems requires complete enumeration of all of the systemmodes. Pre-enumerating all of these modes is wastefulin both space and time, because most modes may not oc-cur at runtime. On some large systems, complete modeenumeration may be completely infeasible.

A more efficient method for tracking hybrid behav-ior is to generate models for each mode only when thatmode is visited. However, model generation after a modechange must occur quickly, before the state estimate di-verges from the true state.

In this paper, we adopt the Hybrid Bond Graph(HBG) approach to model nonlinear hybrid systems(Mosterman & Biswas, 1998). Real world systems arelarge, nonlinear, and may have lots of switching com-ponents. HBGs represent a paradigm for representingthese large complex systems in a compact form. This isbecause in the HBG representation, system modes do nothave to be pre-enumerated, instead they are generated atruntime when a transition occurs to that mode. We usethe equations generated from the HBG model in a modeto formulate the equations for the Unscented Kalman Fil-ter, which tracks the behavior of the system.

Section 2 defines the filtering problem and discussesthe strengths and weaknesses of the Extended Kalman

1


Filter and Unscented Kalman Filter approaches for track-ing system state. Section 3 describes an efficient incre-mental regeneration process to derive the system stateequations when mode changes occur. Section 4 dis-cusses an implementation of our modeling frameworkin the Generic Modeling Environment (GME), and theuse of interpreters within the environment to generatethe state equations and the filter to estimate the systemstate. In section 5 we run comparative analysis exper-iments with the generated UKFs and EKFs on severalnonlinear systems at varying noise levels. We also showhow the structure of our equation representation allowsus to improve runtime performance by caching interme-diate results. Last, we show how automated equationgeneration and state tracking via the UKF allows us toeasily model large hybrid systems.

2. STATE ESTIMATION USING KALMANFILTERS

The Kalman filter (Welsh, 2006) is known to be an op-timal filter for linear time invariant dynamical systemswhere modeling errors and measurement noise are Gaus-sian. Unfortunately, solutions to the corresponding opti-mal nonlinear filtering problem are infinite-dimensionalin the general case, and nonlinear filters must approxi-mate the optimal solution using linearization or samplingmethods. EKFs and UKFs are extensions of the linearKalman filter to nonlinear systems.

2.1 The Extended Kalman FilterThe Extended Kalman Filter (EKF) was for a long timethe standard algorithm for nonlinear state estimation; anexcellent description of the EKF can be found in (Welsh,2006), which forms the basis for the description below.The general idea behind the EKF is that by linearizingthe nonlinear state and measurement equations about thecurrent state estimate, the prediction and update equa-tions from the linear Kalman Filter can be applied to anonlinear system. The EKF assumes that the system isupdated by the discrete-time non-linear stochastic differ-ence equation f , with measurements generated by h:

xk =f(xk−1, uk−1, wk−1)zk =h(xk−1, vk−1)

Since the process and measurement noise are not known,x and z are approximated:

xk =f (xk−1, uk−1, 0)zk =h (xk, 0)

An estimation step is broken into two parts: predict andupdate. In the predict step, the system model is used topropagate the state estimate forward:

x−k =f(xk−1, uk−1, 0)

P−k =AkPk−1A

Tk + WkQk−1W

Tk

In the update step, the measurement is combined with thestate estimate to get a new state and covariance estimate:

Kk =f (xk−1, uk−1, 0)

xk =x−k + Kk

(zk − h

(x−

k , 0))

Pk =(I − KkHk)P−k

The EKF linearizes f and h about x to generate the A, W,H, and V matrices.

A[i,j] =df[i]

dx[j](xk−1, uk−1, 0)

W[i,j] =df[i]

dw[j](xk−1, uk−1, 0)

H[i,j] =dh[i]

dx[j](xk, 0)

V[i,j] =dh[i]

dv[j](xk, 0)

There are two main drawbacks to the first-order lin-earization approach used by the EKF. First, it is wellknown that, because linearization is only accurate to thefirst-order, the EKF does not perform well when track-ing highly nonlinear systems. Second, generating sym-bolic solutions for A, W, H, and V can be significantlymore difficult than generating the system state equations(Julier, 1997). These Jacobian matrices can be computednumerically, but on nonlinear systems this can lead tonumerically unstable behavior.

2.2 The Unscented Kalman FilterThe Unscented Kalman Filter (Julier, 1997) is an alter-nate approach for nonlinear tracking. The UKF, an ex-tension to the Kalman filter, uses a deterministic sam-pling approach instead of an explicit linearization. Likethe EKF, the UKF assumes a discrete time nonlinear statetransition function:

xk+1 =F (xk, uk]) + vk

yk =H (xk) + nk

Like the EKF, the UKF operates with alternating timeand measurement update steps (Merwe & Wan, 2001),outlined below: Initialize:

x0 =E [x0]

P0 =E[(P0 − x0) (x0 − x0)

T]

For k ∈ {1, · · · ,∞}

X∗k|k−1 =

[xk−1xk−1 + γ

√Pk−1xk−1 − γ

√Pk−1

]Time update:X∗

k|k−1 =F (Xk−1, uk−1)

x−k =

2L∑i=0

W(m)i X∗

i,k|k−1

P−k =

2L∑i=0

W(c)i

[X∗

i,k|k−1 − x−k

] [X∗

i,k|k−1 − x−k

]T+ Rv

Xk|k−1 =[x−

k x−k + γ

√P−

k x−k − γ

√P−

k

]Yk|k−1 =H

[Xk|k−1

]y−

k =2L∑i=0

W(m)i Yi,k|k−1

2


Measurement update:

Peykexk

=2L∑i=0

W(c)i

[Yi,k|k−1 − y−

k

] [Yi,k|k−1 − y−

k

]T+ Rn

Pxkyk=

2L∑i=0

W(c)i

[Xi,k|k−1 − x−

k

] [Yi,k|k−1 − y−

k

]TKk =Pxkyk

P−1eyk eyk

xk =x−k + Kk

(yk − y−

k

)Pk =P−

k − KkPykykKT

k

{Wi} is the set of weights:

W(m)0 =

λ

(L + λ)

W(c)0 =

λ

(L + λ)+ (1 − α2 + B)

W(m)i =W

(c)i =

1(2 (L + λ))

, i = 1, · · · , 2L

λ =α2 (L + κ) − L

γ =√

(L + λ)

λ, α, and β are scaling parameters. Rv is the processnoise covariance. Rn is the measurement noise covari-ance.

By not linearizing the state equations about the stateestimate, the UKF addresses two of the main weaknessesof the EKF. First, when using the UKF, f and h donot need to be differentiated, making automated equa-tion generation significantly more feasible. Second, theUKFs deterministic sampling captures both the meanand covariance of a Gaussian Random Variable, whichwhen propagated through the nonlinear system capturesthe estimate mean and covariance to the 3rd order for anynonlinearity, as opposed to the first order approximationfrom the EKF. Many papers have compared the perfor-mance of the UKF and EKF, and many have found thatin both theoretical results (Lefebvre, 2004) and practi-cal applications (Romanenko & Castro, 2003) the UKFmatches or outperforms the EKF for nonlinear systems.

2.3 Extending the tracking problem to hybridsystems

Hybrid system behavior introduces new challenges tosystem tracking, because hybrid behaviors have to in-clude mode changes. To track the state of a hybrid sys-tem, an observer must now do three things: (1) check forand detect mode changes, (2) update the system modelwhen mode changes occur, and (3) perform continuousestimation in each mode of operation.

Hybrid mode estimation is a well researched area, anda number of techniques have been developed for simul-taneous state and mode estimation. Many techniquesmaintain a bank of state estimate trajectories, and usehidden Markov models (HMMs) to estimate the mostlikely current mode. Mode changes triggered by thecontinuous system state update the HMM beliefs, andeach of the state trajectories is updated by the modes the

HMM finds most probable (Hofbaur & Williams, 2002).For this paper, we do not attempt to estimate the systemmode; in all of the models in this paper, mode changesare interpreted as clearly observed system inputs. Thetechniques described here, though, could be used in con-junction with mode estimation techniques.

After the new mode is determined, it is important toquickly update the system model so that the filters stateestimate does not diverge from the correct estimate whilethe equations are being updated. The linearization per-formed by the EKF is even more of a computational bur-den in a hybrid system because every mode change re-quires the re-generation of the symbolic Jacobian matri-ces used to linearize the state equations. To use the EKFon a hybrid system, the matrices A, H , W , and V , aswell as f and h, need to be recomputed at each modechange. The UKF requires updated f and h functions,but has no matrices to update. This makes the UKF sig-nificantly more desirable as a state estimator for hybridand nonlinear systems. Last, within each system mode,the filter must still estimate the continuous state of thenonlinear system, given noisy measurements and an im-perfect system model.

Figure 1 illustrates this process. The techniques pre-sented in this paper speed up the model update step by ef-ficiently regenerating the state equations incrementally,rather than regenerating the entire set of state equationson a mode change.

Figure 1: State estimation process in a hybrid system

3. HYBRID BOND GRAPH MODELING OFHYBRID SYSTEMS

Bond Graphs are a topological domain-independentenergy-based paradigm for modeling physical systemsand processes (Karnopp, Margolis & Rosenberg, 2006).One of the strengths of this modeling paradigm is thatit has a strong correspondence with free-body diagramsin mechanics, circuit diagrams in electricity, and simi-lar representations in other physical domains. A BondGraph is built of primitive elements which include stor-age elements (capacitors, C and inductors, I), elementswhich dissipate energy (resistors, R), and those whichtransform energy from one form to another (transform-ers, TF , and gyrators, GY .) Sources of effort (Se) andsources of flow (Sf ) define interactions of the systemwith its environment. These primitive components areconnected to each other via junctions (0 and 1 junctions),which represent parallel and series connections betweencomponents. Bonds represent energy connections, andhave associated effort and flow variables with effort ×

3


flow defining the rate of energy flow (Roychoudhury,Daigle, Biswas & Koutsoukos, 2010).

Hybrid Bond Graphs (HBGs) extend Bond Graphs byintroducing discontinuous behavior via switching junc-tions, which turn on or off as a function of system stateand/or control input. (Mosterman, 2002) presents a morein-depth discussion of the HBG modeling paradigm andthe semantics of the switching junctions. HBGs are apowerful paradigm for representing large hybrid systemsbecause they can compactly represent a hybrid system;the equations for each state do not need to be enumer-ated prior to execution, but instead can be generated asneeded. This is an advantage over modeling paradigmslike Hybrid Automata, which generally require an enu-meration of all system modes prior to execution (Alur,Courcoubetis & Ho, 1993).

Modulated components allow the modeler to intro-duce nonlinearities into a Hybrid Bond Graph model.When a component is modulated, its parameter is a func-tion of other effort or flow variables. Modulated func-tions introduce potentially un-resolvable algebraic loopsinto the state equations, so during simulation, only theprevious time steps value of the modulated functions in-put variables are used. This is the same approach to mod-ulated functions taken by HyBrSim (Mosterman, 2002)and block diagrams (Daigle, Roychoudhury, Biswas,Koutsoukos & Daigle, 2007).

3.1 Behavior Generation for Hybrid Bond GraphsAs a hybrid system, the behavior of a HBG is definedby continuously differentiable behavior within a mode,and discrete mode changes when the system state equa-tions change. To simulate a HBG, state equations mustbe generated for each mode, and then numerically solvedvia methods such as Euler or Runge-Kutta for the dura-tion of the mode. When the state of a switching junctionchanges, triggered either by external input or from inter-nal switching, new state equations must be generated.

Continuous Behavior GenerationGenerating the continuous behavior of a system isstraightforward when the state equations are a set ofODEs. When the causality of a HBG is fixed, generat-ing ODEs modeling a HBG is a straightforward process.The equations for each bond graph component can guideeffort and flow variable substitutions, until the derivativeof each state variable is a function of the system state,parameters, and inputs.

The equation generation process is guided by thecausal configuration of a HBG. The rules for causalityassignment are given in detail in (Roychoudhury, 2010).The algorithms discussed here generate equations onlyfor systems where every component can be assigned in-tegral causality. When the causality assignment rules donot assign a causal stroke to every bond, the remainingbonds can be given any valid causality assignment, andthe model is said to have a zero-order causal path. Whenthis happens, equation generation is more complicated(Dijk & Breedveld, 1991), and the resulting equationsare said to contain an algebraic loop.

Work has already been done to improve the efficiencyof HBGs when modeling large hybrid systems. Block di-agrams represent the equations for each junction as con-nections between junctions which can be easily recon-figured. The Hybrid SCAP algorithm describes how to

efficiently reconfigure a block diagram on hybrid modechanges (Daigle, 2007). The algorithms presented belowextend the Block Diagram representation by performingsymbolic manipulation to derive the state equations.

Building State Equations From HBGsThe equation representation strategy presented here rep-resents the equations of a Bond Graph as a directedacyclic graph, which we call a Hybrid Equation. In thegraph, a child node ofa variable represents an expressionit is equivalent to when particular structural constraintsare satisfied. The children of an operator node are itsoperands. As the system transitions between modes, thestructural constraints of the HBG change, and variablesacquire new child nodes when new modes are visited.The previous child nodes are cached to allow easy re-trieval if a previously generated mode is revisited.

When the mode of a HBG changes, in most cases themajority of the state equations will not change. If theequations are cached properly, only the parts of the equa-tions which have changed will need to be regenerated.While generating the equations for a HBG, we note theconstraints imposed by the current system mode duringthe equation generation process, when the causality andmode guide the variable substitutions. To see which con-straints it is important to record, consider what changesto the HBG occur during a hybrid mode change: 1) thedetermining bond of junctions change, and 2), non de-termining bonds turn on or off. (1) will only affect theequation generation in two cases; when following theflow into a 1-junction or the effort into a 0-junction.Therefore, each of these variable substitutions is aug-mented with a constraint of the form < Bx determinesJy >, indicating that the substitution is only valid whilebond x is the determining bond of junction y. (2) willchange only the effort at a 1-junction or the flow at a0-junction. Therefore, each of these substitutions is aug-mented with the constraint < x1 · · ·xn active for Jz > ,where x1 · · ·xn are booleans which indicate the state ofeach of the bonds attached to junction z.

From these observations, we get algorithm 1 whichbuilds the initial state equations for the HBG. Algebraicloop resolution is discussed in more detail later.

Algorithm 1 Build initial equations1: Run hybrid SCAP to assign causality to the current

bond graph configuration2: Run generate equations3: Run resolve loops

When generating equations which are valid inmultiple system modes, the effort and flow variablesmust be augmented with the direction from which thesubstitution occurs. Consider f2 in Model 2; whenjunction o is on, the component equations contain:f2 = e2

R ; however, when o is off, bond 2 determines z,and the component equations contain e2 = f2R. If thereis only a single f2 node in the graph, the graph will becyclic, as the equalities f2 = e2

R and e2 = f2R are bothvalid in both modes. This can be prevented by notingfrom which direction a variable substitution is made,and maintaining distinct nodes for a variable found byfollowing a bond (labeled in) and going against thebond (labeled out.) So in Model 2, the equations for

4


Algorithm 2 Generate equationsRequire: stack unexplored containing equations to

generate1: while unexplored not empty do2: pop node from unexplored3: if node is a non-state variable and does not have a

valid substitution then4: let sub be the direct substitution for node5: add subsitution sub to node with its constraints6: set sub as node’s current substitution7: if sub is a variable then8: push sub onto unexplored9: else if sub is an operator then

10: push the children of sub onto unexplored11: end if12: end if13: end while

bond 2 are instead f2out = e2in

R , and e2out = f2inR.

Example 1: Derivation of state equations for asimple model (model 3):

The equations for each component and the derivedstate equations are shown below.

e1 =C : q

e3 =C1 : q

f5 =Sf

f2 =e2

Rf1 =f4 = f2

e5 =e4 = e3

e2 =e4 − e1

f3 =f5 − f4

C : q′ =1C

f1 =1

CR(C1 : q − C : q)

C1 : q′ =1

C1f3 =

1C1

(Sf − 1

R(C1 : q − C : q)

)The hybrid equation structure captures the variable sub-stitutions that are necessary to derive state equationsfor C : q′ and C1 : q′, using the component equationsabove. Figure 4 shows the full Hybrid Equation for fig-ure 2. The first variable substitution C : q′ = 1

C f1 isrepresented by an arc from C : State′ to f1

C in figure 4.f1 is not a state variable, so we can continue by usingthe equality f1 = f2, adding another arc. We continethis process until the full state equations are generated.

Algebraic Loop ResolutionWhen the causality of a Bond Graph is not completelyfixed by storage or source elements, there exists a zero-order causal path between two or more resistive elements(Dijk, 1991), and the state equations of the Bond Graphimplicitly represent a set of Differential Algebraic Equa-tions (DAEs) instead of a set of ODEs. There are threegeneral approaches to dealing with algebraic loops inBond Graphs: structural augmentation, numerical meth-ods, and symbolic resolution. Structural augmentation

Figure 2: Bond 2 will determine z in only one mode

Figure 3: A simple bond graph

Figure 4: Hybrid equation for figure 3

5


removes zero-order causal paths by inserting small stateelements which fix the causality of the system (Gawthrop& Smith, 1992). Unfortunately, augmented models in-clude additional state variables, and the resulting systemof equations may be stiff, causing numerical issues dur-ing simulation. We would like to avoid adding unneces-sary state variables, as this software is intended to assistin state and parameter estimation. Numerical methodsleave the equations in DAE form, and use a numericalDAE solver to solve for the future state of the system.However, numerically solving a DAE system can be verycomputationally expensive (Borutzky & Cellier, 1996).

Several groups have used symbolic manipulation onthe systems DAEs to derive a system of ODEs. 20-sim,a Bond Graph modeling and simulation tool, first at-tempts algebraic manipulation before resorting to numer-ical methods (20-sim, 2009). In (Borutzky, 1996), tech-niques are developed to intelligently choose variables touse to tear the system when converting it to an ODE.While ODE solutions to DAE systems are not possiblein the general nonlinear case, the use of timestep-delayedmodulated functions to model nonlinearities means thatour DAE system will contain only terms linear with re-spect to the variables being solved for. This indicates thatit is possible to convert our original DAEs into a systemof ODEs, albeit with a potentially large amount of sym-bolic manipulation.

If the equations representing a Bond Graph contain analgebraic loop, it will be clearly identifiable as a back-edge in the Hybrid Equation (figure 6). Loops are re-solved by finding a variable contained in an algebraicloop and algebraically compiling a solution for the vari-able. By noting the constraints which define the struc-ture of the algebraic loop, once a loop is resolved in onemode, the solution will remain valid for other modes, andwill not need to be re-solved in many future modes. Thealgorithm for resolving algebraic loops is shown below.

Algorithm 3 Resolve loops1: while a variable v can be found in an algebraic loop

do2: let originalSub = v’s current substitution3: call copy and compile on v to generate sub4: replace v’s original substitution with sub5: solve the loop for v6: find a new variable v in an algebraic loop7: end while

In solve equation, x and y could potentially stillcontain references to v, if there is an intermediatevariable still in an algebraic loop; otherwise functioncopy and compile would not terminate. The variableused to break the algebraic loop is found via a DFS ofthe graph which returns the first variable found in a cycle.This variable will not necessarily be the optimal choiceto solve; choosing the minimal number of variables tosolve is in general NP-complete (Borutzky, 1996). Inthe simple case with one zero-order causal path, the al-gorithm will always terminate in a single iteration.

Example 2: Derivation of state equations for a modelwith an algebraic loop (figure 5)

The component equations for figure 5 are shown.

Algorithm 4 Copy and compile equationRequire: node v

1: if v is a state variable, v is a parameter, or v hasalready been seen then

2: return v3: else if a substitution s for v has already been gener-

ated then4: return the s5: else if v is a non-state variable then6: note the constraints on v’s substitution7: return CopyAndCompile on v’s current substitu-

tion8: else if v is is an addition (multiplication) operator

then9: let newOp = a new addition (multiplication) op-

erator10: recursively copy each of v’s children and make

them children of newOp11: return newOp12: end if

Algorithm 5 Solve equationRequire: node v

1: simplify the substitution for v into the form vx + y2: resolve the loop by setting v = y

1−x

Figure 5: Simple model with an algebraic loop

e2 =Rf2

e1 =C : q

f5 =Sf

f3 =1

R1e3

e5 =e3 = e4

f1 =f2 = f4

f4 =f5 − f3

e4 =e1 + e2

C : q′ =1C

f1 =1C

(− 1

R1C : q + Sf

1 + RR1

)Figure 7 illustrates this procedure as represented by a

Hybrid Equation. The initial equations for figure 5 con-tain an algebraic loop: f4 = f5 − f3 = Sf − 1

R1C :q − R

R1f4. This problem manifests itself in the HybridEquation as a cycle, as seen in figure 6. By algebraicallycompiling a solution, f4 can be solved for explicitly:

f4 =Sf − 1

R1C : q

1 + RR1

6


Figure 7 shows the hybrid equation after resolving thealgebraic loop and generating explicit state equations.f4out was the variable used to break the cycle. The newsymbolic substitution for f4out is equivalent to the onecomputed above. The constraints on this substitutioncorrespond to the constraints that defined the structureof the algebraic loop in Figure . The loop will not needto be re-solved for any subsequent mode in which theseconstraints hold.

One situation this system is not able to handle is thepresence of causal loops (Dijk, 1991), where no explicitset of ODEs can be generated. We would need to im-plement numerical methods to simulate such a system.In the systems our research focuses on, we have not en-countered a system with a causal loop which could not bereduced into an equivalent system lacking causal loops.

EvaluationOnce algebraic loops have been removed from the equa-tions, the value of any node can be computed recursively,as shown in algorithm 6.

Algorithm 6 EvaluateRequire: node v

1: if the value of v has already been cached then2: return the cached value3: else if v is a state variable or parameter then4: value = the value of evaluate on v’s substitution5: else if v is a non-state variable then6: value = the value of evaluate on v’s substitution7: else if v is an addition (multiplication) operator then8: value = the sum(product) of all children9: cache value for node v

10: end if11: return value

Mode ChangesWhen the mode of a HBG changes, some constraintswill be invalidated, and the parts of the state equationswhich depend on them will need to be regenerated. Wecan tell which constraints have changed: 1) constraintswhich rely on the determining bond of a junction, whichcan be found while tracing causality changes through thesystem during the Hybrid SCAP procedure, and 2) con-straints for junctions which neighbor a bond which haschanged state. The algorithm for equation generation hasalready been defined, so the equation update algorithm issimple.

Algorithm 7 Update equation on mode change1: update all junction state to reflect structural changes2: perform Hybrid SCAP3: for all variables v with an invalid substitution do4: if v has a different substitution s which satisfies

the active constraints then5: set s as the current substitution of v6: else7: generate the updated equation for v8: end if9: end for

10: resolve algebraic loops

Figure 6: Hybrid equation for figure 5 with algebraicloop

Figure 7: Hybrid equation for figure 5 after algebraicloop resolution

7


Only if a variable has a substitution which a modechange has made invalid, will the substitution need tobe recomputed. If the system ever re-enters a previouslyvisited mode, every necessary variable will have at leastone valid substitution. As more modes are reached, itbecomes increasingly likely that a new substitution willnot need to be generated with a mode change.

Example 3: In model 3, junction o is a switching junc-tion. When it turns off, the state equations change:

C : q′ =0

C1 : q′ =1

C1Sf

Figure 8 shows the hybrid equation for figure 3 afterthe mode change. The bonds active for junction z havechanged, so f3 has a new substitution in the new mode.C is disconnected from the bond graph when bond 1turns off, so the new ODE C : State = 0 does not needto be explicitly stored.

Figure 8: The equations for figure 3 after the 1-junctionswitches off

3.2 Performance ImprovementsA Hybrid Equation is sufficient for numerical simula-tion, but this equation structure facilitates two strategieswhich improve runtime performance: caching and com-pilation.

CachingIn evaluate, the computed value of each node is cachedfor later reuse. Because nodes in a Hybrid Equationcan have multiple parents, and in most HBG models,a large number of intermediate variables are shared be-tween equations, this often saves a considerable amountof processing time. The ODEs generated could be solvedby an external ODE solver, but it is difficult to ensure

that a third-party ODE solver is able to take advantage ofthis redundancy. Other model-based approaches such asBlock Diagrams also implicitly cache intermediate val-ues.

CompilationTo improve simulation performance when the system isin a frequently occurring mode, it is possible to compile astate specific state equation, which is a compressed ver-sion of the Hybrid Equation valid only that single mode.The generation of the structure may or may not be worth-while, depending on how long the system is expected toremain in that mode. State Equations can be stored ordiscarded and regenerated as necessary. To handle mem-ory constraints, it is possible to set up a LRU cache ofState Equations, regenerating state equations which arecache misses. A state equation is generated by callingcopy and compile on each derivative and observed vari-able. This procedure preserves the intermediate cachingin evaluate. Figure 9 shows state equations for twomodels.

Figure 9: Compressed equations for figures 3 and 5

3.3 Summary of HBG representation and equationgeneration

HBGs provide a compact representation of a hybrid sys-tem which does not require a full enumeration of all thereachable states in a hybrid model. By taking note ofstructural constraints in the bond graph while generatingstate equations, we can efficiently update the state equa-tions when the system mode changes. Having an explicitsystem of equations allows us to resolve algebraic loopsvia symbolic manipulation. The loop will not need tobe resolved again in later modes as long as the structuralconstraints which define it are not violated. To improveperformance at runtime, we can compile the state equa-tions and cache intermediate results when evaluating thevalue of a variable.

4. IMPLEMENTATIONThe Generic Modeling Environment is a meta-modelingenvironment which facilitates the construction of do-main specific modeling languages (Agrawal, Karsai &Ledeczi, 2003). The HBG modeling paradigm has beenimplemented as a meta-model in GME. This allows fora graphical, component-oriented approach for buildingsystem models using a drag and drop interface. Becausecomponent interfaces are well-defined, it is easy to build

8


large system models that are syntactically and semanti-cally correct by composition. Interpreters can then beapplied to these models to convert them into the differ-ent forms needed for building the observers for trackingsystem behavior.

Figure 10: An example of a HBG built using GME. Swis a decision function which specifies the state of junc-tion z. TF is a modulated transformer, whose value is afunction of the effort at z1. A sensor measures the effortacross z1.

The incremental equation generation algorithms de-scribed in section 3. were implemented as a stand-aloneC++ application, using textual representations of bondgraphs produced by GME. We use the extensible opensource Bayes++ library of filter classes (Stevens, 2006)to implement both the EKF and UKF. The state and ob-servation equations for the models evaluated in section 5.were derived automatically. On models where we testedthe performance of the EKF, the symbolic solutions forthe matrices A, H , W , and V for each model were de-rived by hand.

5. RESULTSTo evaluate the performance of the integrated modelingsystem presented here, we have run 3 sets of experi-ments. We first plot the size of our state equation repre-sentation as hybrid modes are exhaustively visited, andtest the processing time saved through caching. Second,we compare the performance of the EKF and UKF ontwo nonlinear systems. Last, we show that we can trackthe behavior of large hybrid systems by automaticallygenerating equations and using the UKF to estimate thesystem state.

5.1 Equation Representation PerformanceBy only selectively re-generating parts of the HybridEquation, we achieve substantial space savings over are-generation of the equations during each mode change;which is demonstrated for two models. Figure 12 is a 4state system with an algebraic loop. Figure 13 is a sim-plified section of NASAs ADAPT test bench which con-tains one battery and two loads (1) one NEMO, and (2)one resistive. Figure 18 shows a flat representation. Thebattery is augmented with internal switching junctions.

Figure 14 shows the size of the hybrid equation foreach model as a function of the number of modes visited.The structure size is the sum of all terms (variables, op-erators, and parameters) and substitutions in the hybrid

Figure 11: A nonlinear two-state pump model

Figure 12: A HBG with 4 state variables

Figure 13: Simplified ADAPT battery

equation. Figure 14 shows that usually during a modechange, the majority of the equation components can bere-used, keeping the equation footprint light.

100

120

140

160

180

200

0 5 10 15 20 25 30

Equ

atio

n Si

ze

Modes

Pump Modes

Size

260

280

300

320

340

360

380

400

0 10 20 30 40 50 60

Equ

atio

n Si

ze

Modes

Simplified ADAPT Modes

Size

Figure 14: The size of the hybrid equations as the modesin figures 12 and 13 are enumerated

The caching performed during function evaluationsaves a significant amount of processing time. Simu-lation used a fixed step forward Euler method for nu-

9


merical integration. Results are shown in table 1 for 3models.

5.2 EKF and UKF ComparisonsTo compare the performance of the EKF and UKF on thesystems we are studying, we tracked the performance ofeach on several systems. The update equations for eachwere automatically derived from the shown models, ex-cept for the symbolic derivatives used by the EKF, whichwere generated by hand. All systems were simulatedwith additive process and measurement noise, and thefilters were given an incorrect initial state estimate.

2-State PumpFigure 11 shows a nonlinear 2-state pump model. Themodulating function regulating GY adds nonlinearity tothe system.

The UKF and EKF estimates the state of this modelare compared in figure 15 . Both filters were initializedwith incorrect m1 and m2 state estimates. As expectedfor a nonlinear model, the UFK converges on the correctstate estimates faster than the EKF.

0

1000

2000

3000

4000

5000

6000

7000

0 0.2 0.4 0.6 0.8 1 1.2

Stat

e

Time

Pump m1 State

StateUKFEKF

0 200 400 600 800

1000 1200 1400 1600

0 0.2 0.4 0.6 0.8 1 1.2

Stat

e

Time

Pump m2 State

StateUKFEKF

0 500

1000 1500 2000 2500 3000 3500 4000

0 0.2 0.4 0.6 0.8 1 1.2

Err

or

Time

Pump m1 Estimate Error

UKFEKF

0

100

200

300

400

500

600

0 0.2 0.4 0.6 0.8 1 1.2

Err

or

Time

Pump m2 Estimate Error

UKFEKF

Figure 15: Pump state m1 and m2 estimates and errors

ADAPT BatteryFigure 13 shows a full schematic of the simplified non-linear ADAPT battery model. The filters were run on thesystems with 5 levels of Gaussian distributed measure-ment noise (.04, .0012, .004, .00012, and .0004.) Theinitial filter estimates of the state of the Load 2 charge(L2C) and the battery charge (CIs1) were incorrect.

The performance of the UKF and EKF in estimatingeach of these states at each measurement noise level isshown in Figure . The state estimates of the filter at eachof the 5 levels of noise on each of these states are shownbelow.

CIs1s state behaves close to linearly over this timespan, so we expect the UKF and EKF to perform verysimilarly, which is supported by the results seen in figure15. The state of L2C does not behave linearly, so we ex-pect the UKF to outperform the EKF, which is supportedby the results shown in 17.

In all of the models evaluated, the UKF matches oroutperforms the EKF, and we expect this to hold on othermodels derived from HBGs.

5.3 ScalingUsing the integrated system for modeling, equation gen-eration, and state tracking described above, it is easy tomodel and track large hybrid systems. The system wasrun on a more complete version of the ADAPT DC test-bench, shown in figure 19, again on with 5 different ob-servation noise levels (.01, .003, .001, .0003, and .0001).The filter had an incorrect initial estimate of the chargeon battery 1. At time 30, two loads on the system discon-nect, and at time 60 reconnect. Figure 20 show the UKFstate estimate at each of the 5 observation noise levels.

6. RELATED WORK AND CONCLUSIONThe Advanced Diagnostics and Prognostics Testbed test-bench used in section 5. was built to evaluate and com-pare diagnostic and fault detection techniques, and wasthe basis for the 2009 diagnostic competition. The Pro-Diagnose diagnosis system performed diagnosis verysuccesfully by compiling a bayesian system model to anarithmetic circuit, which operated very efficiently (Ricks& Mengshoel, 2009). (Grastien & John, 2009) alsocompeted, but relied on a complete model of the testbench, including faulty behavior. The specifications ofthe ADAPT testbench were built into each of these sys-tems. RODON is a commercial diagnostics reasonerwhich showed good results on the ADAPT testbench(BunusIsakssonFrey & Munker, 2009). RODON usesRodelica, a modification to the general-purpose Model-ica modeling language.

A number of Bond Graph modeling systems have beenbuilt. VirtualDynamics has developed a Bond Graphtoolkit for Mathematica (Venuti, 2001); Matlab has aBond Graph block library as well (Geitner, 2008). 20-sim is a software system dedicated to Bond Graph mod-eling and simulation (Broenink & Kleijn, 1999). How-ever, there are very few systems designed to efficientlymodel Hybrid Bond Graphs (Daigle, 2007).

HyBrSim is an experimental Java modeling and simu-lation environment developed for modeling Hybrid BondGraphs (Mosterman, 2002). HyBrSim can simulate asystem by propagating state values forward through the

10


Table 1: Performance gains from caching

- Structure size Without caching (ms) With caching (ms) GainADAPT Battery (figure 18) 299 23141 5859 74.7%

Pump (figure 11) 99 56078 7391 86.8%4-state model (figure 12) 101 3812 1594 58.2%

2.4115e+06 2.41155e+06

2.4116e+06 2.41165e+06

2.4117e+06 2.41175e+06

2.4118e+06 2.41185e+06

0 10 20 30 40 50 60

Err

or

Time

UKF Cls1 State Estimate

State.04

.012

.004.0012.0004

2.4115e+06 2.41155e+06

2.4116e+06 2.41165e+06

2.4117e+06 2.41175e+06

2.4118e+06 2.41185e+06

0 10 20 30 40 50 60

Err

or

Time

EKF Cls1 State estimate

State.04

.012

.004.0012.0004

0

20

40

60

80

100

120

140

0 10 20 30 40 50 60

Err

or

Time

UKF Cls1 Estimate Error

.04.012.004

.0012

.0004

0

20

40

60

80

100

120

140

0 10 20 30 40 50 60E

rror

Time

EKF Cls1 Estimate Error

.04.012.004

.0012

.0004

Figure 16: CIs1 state estimates and errors

0

2

4

6

8

10

0 10 20 30 40 50 60

Err

or

Time

UKF L2C State Estimate

State.04

.012

.004.0012.0004

0

2

4

6

8

10

0 10 20 30 40 50 60

Err

or

Time

EKF L2C State Estimate

State.04

.012

.004.0012.0004

0

1

2

3

4

5

0 10 20 30 40 50 60

Err

or

Time

UKF L2C Estimate Error

.04.012.004

.0012

.0004

0

1

2

3

4

5

0 10 20 30 40 50 60

Err

or

Time

EKF L2C Estimate Error

.04.012.004

.0012

.0004

Figure 17: L2C state estimates and errors

all Bond Graph junctions, without explicit equation gen-eration. HyBrSim can also export state equations as a setof DAEs solvable by a Differential Algebraic Equation(DAE) solver. Last, it can export equations for a modeas C++ code; however, modes exported to C++ must bepre-enumerated, limiting its use to small systems.

This work is an extension of the Block Diagram ap-proach to simulation of Hybrid Bond Graphs (Daigle,2007), whose system is simulated via Simulink. How-ever, Block Diagrams do not attempt to resolve algebraicloops, and do not generate an explicit system of equa-tions. The Block Diagram approach also does not ex-plicitly cache the equations for commonly reached states

as done here.The system described here system stores HBG state

and measurement equations in a fashion that minimizesthe reconfiguration necessary on mode changes. Wehave shown that the size of the hybrid equation struc-ture scales very well with the number of hybrid modesgenerated. By generating explicit equations, we are ableto resolve many algebraic loops, and are able to simplifythe equations to improve runtime performance.

We then showed that on the systems in which we areinterested, the Unscented Kalman Filter matches or out-performs the Extended Kalman Filter. This is ideal forour purposes, as the UKF can be easily integrated into

11


our system; the UKF does not require the manual sym-bolic Jacobian generation required by the EKF. Combin-ing these components, we have developed an automatedsystem for modeling a Hybrid Bond Graph, generatingits state equations, resolving many algebraic loops, ef-ficiently regenerating equations on mode changes, andusing these equations to estimate the state of the systemgiven noisy states and observations.

2.41e+06

2.4105e+06

2.411e+06

2.4115e+06

2.412e+06

2.4125e+06

2.413e+06

2.4135e+06

0 10 20 30 40 50 60 70 80 90 100

Err

or

Time

ADAPT Battery 1 Charge

State.01

.00316.001

.000316.0001

-0.7

-0.6

-0.5

-0.4

-0.3

-0.2

-0.1

0

0 10 20 30 40 50 60 70 80 90 100

Err

or

Time

Battery 1 C1 State Estimate

State.01

.00316.001

.000316.0001

Figure 20: ADAPT battery and load charge estimates

REFERENCES20-sim. ’Algebraic loops,’ http://www.20sim

.com/webhelp/editor/compiling/algebraicloops.htm; accessed April 19,2010.

Agrawal, A., Karsai, G. & Ledeczi, A. (2003). Anend-to-end domain-driven software developmentframework In Conference on Object Oriented Pro-gramming Systems Languages and Applications.

Alur, R., Courcoubetis, C. H. & Ho, P. H. (1993). Hybridautomata: An algorithmic approach to the speci-fication and verification of hybrid systems In InHybrid Systems Vol 736.

Borutzky, W. & Cellier, F. (1996). Tearing in BondGraphs with Dependent Storage Elements InIMACS Multiconference

Broenink, J. F. & Kleijn, C. (1999). Computer AidedDesign of Mechatronic Systems Using 20-sim 3.0In Workshop on European Scientific and IndustrialCollaboration

Bunus, P., Isaksson, O., Frey, Beate. & Mnker, Burkhard.(2009). RODON - A Model-Based Diagnosis Ap-proach for the DX Diagnostic Competition In Pro-ceedings of the 20th International Workshop onPrinciples of Diagnosis

Cuijpers, P. & Reniers, M. (2005). Hybrid Process Al-gebra In The Journal of Logic and Algebraic Pro-gramming

Daigle, M.Roychoudhury, I.Biswas, G. & Koutsoukos,X. (2007). Efficient Simulation of Component-Based Hybrid Models Represented as HybridBond Graphs In Lecture Notes in Computer Sci-ence

Dijk, J. V. & Breedveld, P. (1991). Simulation of Sys-tem Models Containing Zero-Order Causal Paths–II Numerical Implications of Class 1 Zero-OrderCausal Paths In Journal of the Franklin Institute

Gawthrop, P. J. & Smith, L. (1992). Causal Augmen-tation of Bond Graphs with Algebraic Loops InJournal of the Franklin Institute

Geitner, G. H. ’Bond graph add-on block library BGV.2.1.’ http://www.mathworks.com/matlabcentral/fileexchange/11092-bond-graph-add-on-block-library-bg-v-2-1; accessed April19,2010.

Grastien, A. & John, P. K. (2009). Wizards of Oz, de-scription of the 2009 DXC entry In InternationalWorkshop on Principles of Diagnosis (DX-09)

Henzinger, T. A. (1996). The Theory of Hybrid Au-tomata In Proceedings of the 11th Annual Sympo-sium on Logic in Computer Science

Hofbaur, M. W. & Williams, B. C (2002). Mode Esti-mation of Probabilistic Hybrid Systems In HybridSystems: Computation and Control Vol. 2289

Julier, S. J. & Uhlmann, J. K. (1997). A new extensionof the Kalman filter to nonlinear systems

Karnopp, D. C. Margolis, D. L. & Rosenberg, R. C.(2006). System Dynamics: Modeling and Simu-lation of Mechatronic System

Lefebvre, T.Bruyninckx, H. & Schutter, J. D. (2004).Kalman filters for non-linear systems: a compar-ison of performance In International Journal ofControl

Merwe, R. V. & Wan, E. A. (2001). The Square-Root Unscented Kalman Filter For State AndParameter-Estimation In International Conferenceon Acoustics, Speech, and Signal Processing

Mosterman, P. J. (2002). HYBRSIMa modelling andsimulation environment for hybrid bond graphs InProceedings of the Institution of Mechanical Engi-neers, Part I: Journal of Systems and Control En-gineering

Mosterman, P. J. & Biswas, G. (1998). A theory of dis-continuities in physical system models In Journalof the Franklin Institute

Ricks, B. W. & Mengshoel, O. J. (2009). Methods forProbabilistic Fault Diagnosis: An Electrical PowerSystem Case Study In Proceedings of the AnnualConference of the Prognostics and Health Man-agement Society

Romanenko, A. & Castro, J. A. (2003). The unscentedfilter as an alternative to the EKF for nonlinearstate estimation: a simulation case study In Com-puters and Chemical Engineering

Roychoudhury, I., Daigle, M. J. , Biswas, G. & Kout-soukos, X. (2010). Efficient simulation of hybridsystems: A hybrid bond graph approach In Sim-ulation: Transactions of the Society of Modelingand Simulation International

Stevens, M. ’Bayes++ Open Source Bayesian Fil-tering Classes’ http://bayesclasses.sourceforge.net/Bayes++.html; ac-cessed April 26,2010.

Venuti, N. (2001). Bond Graph Empowered by Mathe-matica In Simulation series Vol 33.

Welsh, G. & Bishop, G. (2006). An Introduction to theKalman Filter.

12


Figure 18: Flat schematic of the simplified ADAPT battery (figure 13)

Figure 19: A high level view of the ADAPT DC configuration

13

efficient tracking of behavior in complex hybrid systems via hybrid

Documents