Package Templates Research Articles

Estimating temperatures in a district heating network using smart meter data

Smart meters at consumers create opportunities to improve operation of the district heating sector using data-driven methods. Information from these meter measurements carries the potential to increase the energy efficiency of both individual houses and the utility network, for example by identifying buildings with too high return temperature, or by detecting leakage in the network. This paper proposes a method for using meter data to estimate network temperatures. Network temperatures can subsequently be used to estimate the network characteristics, namely the nonlinear relationship between network temperature and the plants’ temperature and flow. A description of the network characteristics is needed for most temperature-optimisation methods to keep the supply temperature as low as possible without violating the system constraints. Traditionally, measurement wells located in the network have been used. These wells are located at critical points in the network where the largest temperature losses occur. Since the lowest temperature often varies over time, multiple critical points are necessary. The method presented in this paper eliminates the need for these physical critical points in the network. It also makes it possible to change the location of the critical points if needed. The network temperature is estimated using a stochastic state–space model of the heat dynamics from the street level distribution pipe over the service pipe and into individual houses. The parameters in the model are estimated using a maximum likelihood approach, and the Kalman Filter is used to evaluate the likelihood function. The estimation process takes advantage of automatic differentiation using the R package Template Model Builder (TMB) to reduce the computational workload. The proposed method is validated by comparing the estimated temperature with the temperature measured from a measurement well.

UML Templates Distilled

UML templates are possibly the most neglected and misused piece of knowledge in UML modelling. This subject has been disregarded in the research and practice literature and even by modelling tools providers. This paper suggests that such oblivion results from a general misunderstanding that UML templates are just graphical representations of genericity like it is found in programming languages, and from the insufficient support from the modelling tools, with a consequence of poor usage of UML templates in practice. Indeed, the capabilities and potential of UML templates are far-reaching. Increasing awareness around them could bring significant benefits for UML users, namely, higher-level abstraction and reuse. Therefore, this paper provides a distilling tutorial on UML templates to highlight their flexibility and advantages. That presentation follows a tutorial style and is supported by several illustrative examples, varying from simpler to more complex ones. This tutorial reviews the Template construct’s core concepts and terminology, presents constraining classifiers and shows how to define properties and operations as template parameters. Then, it presents and discusses advanced aspects such as operation templates, parameter defaults, the relationship between binding and generalization, and the specific semantics of package templates. Furthermore, the paper discusses the related work and uncovers some of the UML templates’ limitations and opportunities for improvement.

Template-Based Collaborative Design Task Management for Complex Products

The task template system of this system combines the business requirements of the work and provides the classification management function of work packages and work package templates. At the same time, data integration with other systems such as the main data system and resource library is realized. Through this system, users can instantiate a single work package to form a single work item, and can also establish the front and back relationship of the work package through the work package template, thereby realizing the instantiation of the work package process.

A practical method in measurement of perforation size during cartilage tympanoplasty

Cartilage has been used in otologic surgery for ossicular reconstruction and grafting since 1960s. Due to low metabolic rate, stiffness and stability properties with regard to fascia, it is thought to be more effective in tympanoplasty. With the help of this measurement technique, redundant oversized harvesting of cartilage can be prevented and overmanuplation during graft replacement especially after a delicate ossiculoplasty procedure can be avoided. The aim of this study was to demonstrate the preparation of optimal island cartilage composite graft with a simple sterile suture package template for the appropriate size of the tympanic membrane perforation, and to provide a functional surgery with minimal donor site defect and minimal manipulation. With this technique, 143 patients with chronic otitis have been operated in our clinic. No complications with respect to this method, have been observed up to date. Using an easily prepared template is a simple and effective method for measuring the perforation size.

Flexible bivariate Poisson integer-valued GARCH model

Integer-valued time series models have been widely used, especially integer-valued autoregressive models and integer-valued generalized autoregressive conditional heteroscedastic (INGARCH) models. Recently, there has been a growing interest in multivariate count time series. However, existing models restrict the dependence structures imposed by the way they constructed. In this paper, we consider a class of flexible bivariate Poisson INGARCH(1,1) model whose dependence is established by a special multiplicative factor. Stationarity and ergodicity of the process are discussed. The maximization by parts algorithm and its modified version together with the alternative method by using R package Template Model Builder are employed to estimate the parameters of interest. The consistency and asymptotic normality for estimates are obtained, and the finite sample performance of estimators is given via simulations. A real data example is also provided to illustrate the model.

Separating Use and Reuse to Improve Both

Context: Trait composition has inspired new research in the area of code reuse for object oriented (OO) languages. One of the main advantages of this kind of composition is that it makes possible to separate subtyping from subclassing; which is good for code-reuse, design and reasoning. However, handling of state within traits is difficult, verbose or inelegant. Inquiry: We identify the this-leaking problem as the fundamental limitation that prevents the separation of subtyping from subclassing in conventional OO languages. We explain that the concept of trait composition addresses this problem, by distinguishing code designed for use (as a type) from code designed for reuse (i.e. inherited). We are aware of at least 3 concrete independently designed research languages following this methodology: TraitRecordJ, Package Templates and DeepFJig. Approach: In this paper, we design $42_\mu$ a new language, where we improve use and reuse and support the This type and family polymorphism by distinguishing code designed for use from code designed for reuse. In this way $42_\mu$ synthesise the 3 approaches above, and improves them with abstract state operations: a new elegant way to handle state composition in trait based languages. Knowledge and Grounding: Using case studies, we show that $42_\mu$'s model of traits with abstract state operations is more usable and compact than prior work. We formalise our work and prove that type errors cannot arise from composing well typed code. Importance: This work is the logical core of the programming language 42. This shows that the ideas presented in this paper can be applicable to a full general purpose language. This form of composition is very flexible and could be used in many new languages.

Identifiable state‐space models: A case study of the Bay of Fundy sea scallop fishery

AbstractState‐space models (SSMs) are now popular tools in fisheries science for providing management advice when faced with noisy survey and commercial fishery data. Such models are often fitted within a Bayesian framework requiring both the specification of prior distributions for model parameters and simulation‐based approaches for inference. Here we present a frequentist framework as a viable alternative and recommend using the Laplace approximation with automatic differentiation, as implemented in the R package Template Model Builder, for fast fitting and reliable inference. Additionally we highlight some identifiability issues associated with SSMs that fisheries scientists should be aware of and demonstrate how our modelling strategy surmounts these problems. Using the Bay of Fundy sea scallop fishery we show that our implementation yields more conservative advice than that of the reference model. The Canadian Journal of Statistics 47: 27–45; 2019 © 2018 Statistical Society of Canada

Validation of ecological state space models using the Laplace approximation

Many statistical models in ecology follow the state space paradigm. For such models, the important step of model validation rarely receives as much attention as estimation or hypothesis testing, perhaps due to lack of available algorithms and software. Model validation is often based on a naive adaptation of Pearson residuals, i.e. the difference between observations and posterior means, even if this approach is flawed. Here, we consider validation of state space models through one-step prediction errors, and discuss principles and practicalities arising when the model has been fitted with a tool for estimation in general mixed effects models. Implementing one-step predictions in the R package Template Model Builder, we demonstrate that it is possible to perform model validation with little effort, even if the ecological model is multivariate, has non-linear dynamics, and whether observations are continuous or discrete. With both simulated data, and a real data set related to geolocation of seals, we demonstrate both the potential and the limitations of the techniques. Our results fill a need for convenient methods for validating a state space model, or alternatively, rejecting it while indicating useful directions in which the model could be improved.

Fast fitting of non-Gaussian state-space models to animal movement data via Template Model Builder.

State-space models (SSM) are often used for analyzing complex ecological processes that are not observed directly, such as marine animal movement. When outliers are present in the measurements, special care is needed in the analysis to obtain reliable location and process estimates. Here we recommend using the Laplace approximation combined with automatic differentiation (as implemented in the novel R package Template Model Builder; TMB) for the fast fitting of continuous-time multivariate non-Gaussian SSMs. Through Argos satellite tracking data, we demonstrate that the use of continuous-time t-distributed measurement errors for error-prone data is more robust to outliers and improves the location estimation compared to using discretized-time t-distributed errors (implemented with a Gibbs sampler) or using continuous-time Gaussian errors (as with the Kalman filter). Using TMB, we are able to estimate additional parameters compared to previous methods, all without requiring a substantial increase in computational time. The model implementation is made available through the R package argosTrack.

Package templates

Package Templates (PT) is a mechanism designed for writing reusable modules, called templates, each consisting of a set of classes that can be adapted to their use in a program through compile-time specialization. A template must be instantiated in a program before its classes can be used. The mechanism supports type-safe renaming, merging, type parameterization and refinement in the form of static additions and overrides that are orthogonal to the corresponding concepts of ordinary inheritance. In this paper, we consider PT as an extension to Java, and a PT program will then consist of a number of Java packages and templates, where templates are instantiated in packages or other templates. Our aim and main contribution is to define the meaning of such a program, and to show that this definition is consistent. We first show this for a core subset of PT, C-PT, and define a set of source-to-source transformations for converting C-PT programs to plain Java programs using semantics we have described informally in previous papers. We can then define the meaning of a C-PT program in terms of the resulting Java program. Thus, we have to verify that the transformations will always convert a legal C-PT program to a legal Java program. Finally, we briefly discuss how this approach can be extended to full PT. A main challenge is to preserve externally visible names (for classes, methods and fields), and at the same time prevent unwanted subsequent rebindings caused e.g. by over-load resolution in the Java compiler. Names that are bound to declarations in a template should not be rebound to different declarations by subsequent compositions or adaptions. In addition to defining the runtime semantics of PT constructs in terms of their translation to Java, the transformation rules can also be seen as a high-level approach to how a compiler for this language might be implemented.

Controlling dynamic module composition through an extensible meta-level API

In addition to traditional object-oriented (OO) concepts such as inheritance and polymorphism, several modularization and composition mechanisms like e.g. traits, mixins and virtual classes have emerged. The Package Template mechanism is another attempt at providing a flexible mechanism for modularization, composition and adaption. Dynamic languages have traditionally employed strong support for meta-programming, with hooks to control OO concepts such as method invocation and object construction, by utilizing meta-classes and meta-object protocols. In this work, we attempt to bring a corresponding degree of meta-level control to composition primitives, with a concrete starting point in the package template mechanism as developed for the dynamic language Groovy. We wish to support a wide range of possible composition semantics, and to make such choices available to the developer through a meta-level API. This API should be extensible, and the semantic variations should be applied within well-defined scopes.

Groovy package templates

We show how package templates, a modularization mechanism originally developed for statically typed languages like Java and C#, can be applied to and implemented in a dynamic language like Groovy, by using the language's capabilities for meta-programming. We then consider a set of examples and discuss dynamic PT from the viewpoints of code modularization and reuse, and dynamic adaption of classes at runtime.

Exploring the use of Package Templates for flexible re-use of Collections of related Classes.

It has been recognized that there is a need for a language mechanism that support reuse of collections of related classes. Existing approaches either use an enclosing class for this purpose, or introduce a special purpose, new language construct. In this paper we explore the use of packages for the grouping of related classes. Ordinary packages are already grouping of classes, so we explore the combination of packages and templates, i.e. package templates. By instantiating package templates, the classes of the package templates are provided as if ordinary packages are produced and imported.