MCNP Output Data Analysis with ROOT (MODAR)

MCNP Output Data Analysis with ROOT (MODAR) is a tool based on CERN's ROOT software. MODAR has been designed to handle time-energy data issued by MCNP simulations of neutron inspection devices using the associated particle technique. MODAR exploits ROOT's Graphical User Interface and functionalities to visualize and process MCNP simulation results in a fast and user-friendly way. MODAR allows to take into account the detection system time resolution (which is not possible with MCNP) as well as detectors energy response function and counting statistics in a straightforward way.

Program summary

Program title: MODARCatalogue identifier: AEGA_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEGA_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 155 373No. of bytes in distributed program, including test data, etc.: 14 815 461Distribution format: tar.gzProgramming language: C++Computer: Most Unix workstations and PCOperating system: Most Unix systems, Linux and windows, provided the ROOT package has been installed. Examples where tested under Suse Linux and Windows XP.RAM: Depends on the size of the MCNP output file. The example presented in the article, which involves three two-dimensional 139×740 bins histograms, allocates about 60 MB. These data are running under ROOT and include consumption by ROOT itself.Classification: 17.6External routines: ROOT version 5.24.00 (http://root.cern.ch/drupal/)Nature of problem: The output of an MCNP simulation is an ASCII file. The data processing is usually performed by copying and pasting the relevant parts of the ASCII file into Microsoft Excel. Such an approach is satisfactory when the quantity of data is small but is not efficient when the size of the simulated data is large, for example when time-energy correlations are studied in detail such as in problems involving the associated particle technique. In addition, since the finite time resolution of the simulated detector cannot be modeled with MCNP, systems in which time-energy correlation is crucial cannot be described in a satisfactory way. Finally, realistic particle energy deposit in detectors is calculated with MCNP in a two-step process involving type-5 then type-8 tallies. In the first step, the photon flux energy spectrum associated to a time region is selected and serves as a source energy distribution for the second step. Thus, several files must be manipulated before getting the result, which can be time consuming if one needs to study several time regions or different detectors performances. In the same way, modeling counting statistics obtained in a limited acquisition time requires several steps and can also be time consuming.Solution method: In order to overcome the previous limitations, the MODAR C++ code has been written to make use of CERN's ROOT data analysis software. MCNP output data are read from the MCNP output file with dedicated routines. Two-dimensional histograms are filled and can be handled efficiently within the ROOT framework. To keep a user friendly analysis tool, all processing and data display can be done by means of ROOT Graphical User Interface. Specific routines have been written to include detectors finite time resolution and energy response function as well as counting statistics in a straightforward way.Additional comments: The possibility of adding tallies has also been incorporated in MODAR in order to describe systems in which the signal from several detectors can be summed. Moreover, MODAR can be adapted to handle other problems involving two-dimensional data.Running time: The CPU time needed to smear a two-dimensional histogram depends on the size of the histogram. In the presented example, the time-energy smearing of one of the 139×740 two-dimensional histograms takes 3 minutes with a DELL computer equipped with INTEL Core 2.     

TiReX: Replica-exchange molecular dynamics using Tinker

We present a driver program for performing replica-exchange molecular dynamics simulations with the Tinker package. Parallelization is based on the Message Passing Interface, with every replica assigned to a separate process. The algorithm is not communication intensive, which makes the program suitable for running even on loosely coupled cluster systems. Particular attention is paid to the practical aspects of analyzing the program output.

Program summary

Program title: TiReXCatalogue identifier: AEEK_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEEK_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 43 385No. of bytes in distributed program, including test data, etc.: 502 262Distribution format: tar.gzProgramming language: Fortran 90/95Computer: Most UNIX machinesOperating system: LinuxHas the code been vectorized or parallelized?: parallelized with MPIClassification: 16.13External routines: TINKER version 4.2 or 5.0, built as a libraryNature of problem: Replica-exchange molecular dynamics.Solution method: Each replica is assigned to a separate process; temperatures are swapped between replicas at regular time intervals.Running time: The sample run may take up to a few minutes.     

Revised and extended Utilities for the Ratip package

During the last years, the Ratip package has been found useful for calculating the excitation and decay properties of free atoms. Based on the (relativistic) multiconfiguration Dirac-Fock method, this program is used to obtain accurate predictions of atomic properties and to analyze many recent experiments. The daily work with this package made an extension of its Utilities [S. Fritzsche, Comput. Phys. Comm. 141 (2001) 163] desirable in order to facilitate the data handling and interpretation of complex spectra. For this purpose, we make available an enlarged version of the Utilities which mainly supports the comparison with experiment as well as large Auger computations. Altogether 13 additional tasks have been appended to the program together with a new menu structure to improve the interactive control of the program.

Program summary

Title of program: RATIPCatalogue identifier: ADPD_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADPD_v2_0Program obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandLicensing provisions: noneReference in CPC to previous version: S. Fritzsche, Comput. Phys. Comm. 141 (2001) 163Catalogue identifier of previous version: ADPDAuthors of previous version: S. Fritzsche, Department of Physics, University of Kassel, Heinrich-Plett-Strasse 40, D-34132 Kassel, GermanyDoes the new version supersede the original program?: yesComputer for which the new version is designed and others on which it has been tested: IBM RS 6000, PC Pentium II-IVInstallations: University of Kassel (Germany), University of Oulu (Finland)Operating systems: IBM AIX, Linux, UnixProgram language used in the new version: ANSI standard Fortran 90/95Memory required to execute with typical data: 300 kBNo. of bits in a word: All real variables are parameterized by a selected kind parameter and, thus, can be adapted to any required precision if supported by the compiler. Currently, the kind parameter is set to double precision (two 32-bit words) as used also for other components of the Ratip package [S. Fritzsche, C.F. Fischer, C.Z. Dong, Comput. Phys. Comm. 124 (2000) 341; G. Gaigalas, S. Fritzsche, Comput. Phys. Comm. 134 (2001) 86; S. Fritzsche, Comput. Phys. Comm. 141 (2001) 163; S. Fritzsche, J. Elec. Spec. Rel. Phen. 114-116 (2001) 1155]No. of lines in distributed program, including test data, etc.:231 813No. of bytes in distributed program, including test data, etc.: 3 977 387Distribution format: tar.gzip fileNature of the physical problem: In order to describe atomic excitation and decay properties also quantitatively, large-scale computations are often needed. In the framework of the Ratip package, the Utilities support a variety of (small) tasks. For example, these tasks facilitate the file and data handling in large-scale applications or in the interpretation of complex spectra.Method of solution: The revised Utilities now support a total of 29 subtasks which are mainly concerned with the manipulation of output data as obtained from other components of the Ratip package. Each of these tasks are realized by one or several subprocedures which have access to the corresponding modules of the main components. While the main menu defines seven groups of subtasks for data manipulations and computations, a particular task is selected from one of these group menus. This allows to enlarge the program later if technical support for further tasks will become necessary. For each selected task, an interactive dialog about the required input and output data as well as a few additional information are printed during the execution of the program.Reasons for the new version: The requirement for enlarging the previous version of the Utilities [S. Fritzsche, Comput. Phys. Comm. 141 (2001) 163] arose from the recent application of the Ratip package for large-scale radiative and Auger computations. A number of new subtasks now refer to the handling of Auger amplitudes and their proper combination in order to facilitate the interpretation of complex spectra. A few further tasks, such as the direct access to the one-electron matrix elements for some given set of orbital functions, have been found useful also in the analysis of data.Summary of revisions: extraction and handling of atomic data within the framework of Ratip. With the revised version, we now ‘add’ another 13 tasks which refer to the manipulation of data files, the generation and interpretation of Auger spectra, the computation of various one- and two-electron matrix elements as well as the evaluation of momentum densities and grid parameters. Owing to the rather large number of subtasks, the main menu has been divided into seven groups from which the individual tasks can be selected very similarly as before.Typical running time: The program responds promptly for most of the tasks. The responding time for some tasks, such as the generation of a relativistic momentum density, strongly depends on the size of the corresponding data files and the number of grid points.Unusual features of the program: A total of 29 different tasks are supported by the program. Starting from the main menu, the user is guided interactively through the program by a dialog and a few additional explanations. For each task, a short summary about its function is displayed before the program prompts for all the required input data.     

Enterprise modeling and Data Warehousing in Telecom Italia

We present a methodology for Data Warehouse design and its application within the Telecom Italia information system. The methodology is based on a conceptual representation of the Enterprise, which is exploited both in the integration phase of the Warehouse information sources and during the knowledge discovery activity on the information stored in the Warehouse. The application of the methodology in the Telecom Italia framework has been supported by prototype software tools both for conceptual modeling and for data integration and reconciliation.     

Merging the autoview image processing language with prolog

A new computer language, called provision, is defined. It combines features of both prolog (for artificial intelligence) and autoview (for image processing). Predicates for image processing, controlling cameras, illumination sources, optics, a video multiplexor and simple robotic devices are all integrated with PROLOG2, an extension of standard core prolog. The result is a powerful medium for expressing a wide range of algorithms for the visual control of robots and advanced industrial inspection. Several provision applications (i.e. ‘programs’) are presented.     

Rule-Based Programming with Diaplan

Diaplan is a language for programming with graphs and diagrams that is currently being designed and implemented by the authors. In this paper, a programming example, declaration grids, shall illustrate how Diaplan supports a functional and object-oriented style of programming. The example also indicates which features are needed beyond those discussed in previous work on the language [B. Hoffmann, Abstraction and control for shapely nested graph transformation, Fundamenta Informaticae 58 (2003) 39–56].     

Concise: Compressed ‘n’ Composable Integer Set

Bit arrays, or bitmaps, are used to significantly speed up set operations in several areas, such as data warehousing, information retrieval, and data mining, to cite a few. However, bitmaps usually use a large storage space, thus requiring compression. Consequently, there is a space-time tradeoff among compression schemes. The Word Aligned Hybrid (WAH) bitmap compression trades some space to allow for bitwise operations without first decompressing bitmaps. WAH has been recognized as the most efficient scheme in terms of computation time. In this paper we present Concise (Compressed ‘n’ Composable Integer Set), a new scheme that enjoys significantly better performances than WAH. In particular, when compared to WAH our algorithm is able to reduce the required memory up to 50%, while having comparable computation time. Further, we show that Concise can be efficiently used to represent sets of integral numbers in lieu of well-known data structures such as arrays, lists, hashtables, and self-balancing binary search trees. Extensive experiments over synthetic data show the effectiveness of our proposal.     

Pomwig: Herwig for diffractive interactions

We have modified the Herwig event generator to incorporate diffractive interactions. All standard Herwig hard subprocesses are available.     

Supervised ranking in the weka environment

Software for solving the supervised ranking problem is presented. Four variants of the Ordinal Stochastic Dominance Learner (OSDL) are given, together with the space and time complexity of their implementations. It is shown that the described software, which includes two further algorithms for supervised ranking, fits seamlessly into the weka environment.     

-XSummer- Transcendental functions and symbolic summation in Form

Harmonic sums and their generalizations are extremely useful in the evaluation of higher-order perturbative corrections in quantum field theory. Of particular interest have been the so-called nested sums, where the harmonic sums and their generalizations appear as building blocks, originating for example, from the expansion of generalized hypergeometric functions around integer values of the parameters. In this paper we discuss the implementation of several algorithms to solve these sums by algebraic means, using the computer algebra system Form.

Program summary

Title of program:XSummerCatalogue identifier:ADXQ_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADXQ_v1_0Program obtainable from:CPC Program Library, Queen's University of Belfast, N. IrelandLicense:GNU Public License and Form LicenseComputers:allOperating system:allProgram language:FormMemory required to execute:Depending on the complexity of the problem, recommended at least 64 MB RAMNo. of lines in distributed program, including test data, etc.:9854No. of bytes in distributed program, including test data, etc.:126 551Distribution format:tar.gzOther programs called:noneExternal files needed:noneNature of the physical problem:Systematic expansion of higher transcendental functions in a small parameter. The expansions arise in the calculation of loop integrals in perturbative quantum field theory.Method of solution:Algebraic manipulations of nested sums.Restrictions on complexity of the problem:Usually limited only by the available disk space.Typical running time:Dependent on the complexity of the problem.     

Muse: Multi-algorithm collaborative crystal structure prediction

The algorithm and testing of the Multi-algorithm-collaborative Universal Structure-prediction Environment (Muse) are detailed. Presently, in Muse I combined the evolutionary, the simulated annealing, and the basin hopping algorithms to realize high-efficiency structure predictions of materials under certain conditions. Muse is kept open and other algorithms can be added in future. I introduced two new operators, slip and twist, to increase the diversity of structures. In order to realize the self-adaptive evolution of structures, I also introduced the competition scheme among the ten variation operators, as is proved to further increase the diversity of structures. The symmetry constraints in the first generation, the multi-algorithm collaboration, the ten variation operators, and the self-adaptive scheme are all key to enhancing the performance of Muse. To study the search ability of Muse, I performed extensive tests on different systems, including the metallic, covalent, and ionic systems. All these present tests show that Muse has very high efficiency and 100% success rate.     

The modpn library: Bringing fast polynomial arithmetic into Maple

We investigate the integration of C implementation of fast arithmetic operations into Maple, focusing on triangular decomposition algorithms. We show substantial improvements over existing Maple implementations; our code also outperforms Magma on many examples. Profiling data show that data conversion can become a bottleneck for some algorithms, leaving room for further improvements.     

Proofs of randomized algorithms in Coq

Randomized algorithms are widely used for finding efficiently approximated solutions to complex problems, for instance primality testing and for obtaining good average behavior. Proving properties of such algorithms requires subtle reasoning both on algorithmic and probabilistic aspects of programs. Thus, providing tools for the mechanization of reasoning is an important issue. This paper presents a new method for proving properties of randomized algorithms in a proof assistant based on higher-order logic. It is based on the monadic interpretation of randomized programs as probabilistic distributions (Giry, Ramsey and Pfeffer). It does not require the definition of an operational semantics for the language nor the development of a complex formalization of measure theory. Instead it uses functional and algebraic properties of unit interval. Using this model, we show the validity of general rules for estimating the probability for a randomized algorithm to satisfy specified properties. This approach addresses only discrete distributions and gives rules for analyzing general recursive functions.We apply this theory to the formal proof of a program implementing a Bernoulli distribution from a coin flip and to the (partial) termination of several programs. All the theories and results presented in this paper have been fully formalized and proved in the Coq proof assistant.     

An integrated tool for loop calculations: aITALC

aITALC, a new tool for automating loop calculations in high energy physics, is described. The package creates Fortran code for two-fermion scattering processes automatically, starting from the generation and analysis of the Feynman graphs. We describe the modules of the tool, the intercommunication between them and illustrate its use with three examples.

Program summary

Title of the program:aITALC version 1.2.1 (9 August 2005)Catalogue identifier:ADWOProgram summary URL:http://cpc.cs.qub.ac.uk/summaries/ADWOProgram obtainable from:CPC Program Library, Queen's University of Belfast, N. IrelandComputer:PC i386Operating system:GNU/Linux, tested on different distributions SuSE 8.2 to 9.3, Red Hat 7.2, Debian 3.0, Ubuntu 5.04. Also on SolarisProgramming language used:GNU Make, Diana, Form, Fortran77Additional programs/libraries used:Diana 2.35 (Qgraf 2.0), Form 3.1, LoopTools 2.1 (FF)Memory required to execute with typical data:Up to about 10 MBNo. of processors used:1No. of lines in distributed program, including test data, etc.:40 926No. of bytes in distributed program, including test data, etc.:371 424Distribution format:tar gzip fileHigh-speed storage required:from 1.5 to 30 MB, depending on modules present and unfolding of examplesNature of the physical problem:Calculation of differential cross sections for e⁺e⁻ annihilation in one-loop approximation.Method of solution:Generation and perturbative analysis of Feynman diagrams with later evaluation of matrix elements and form factors.Restriction of the complexity of the problem:The limit of application is, for the moment, the 2→2 particle reactions in the electro-weak standard model.Typical running time:Few minutes, being highly depending on the complexity of the process and the Fortran compiler.     

Relativistic central-field Green's functions for the Ratip package

From perturbation theory, Green's functions are known for providing a simple and convenient access to the (complete) spectrum of atoms and ions. Having these functions available, they may help carry out perturbation expansions to any order beyond the first one. For most realistic potentials, however, the Green's functions need to be calculated numerically since an analytic form is known only for free electrons or for their motion in a pure Coulomb field. Therefore, in order to facilitate the use of Green's functions also for atoms and ions other than the hydrogen-like ions, here we provide an extension to the Ratip program which supports the computation of relativistic (one-electron) Green's functions in an—arbitrarily given—central-field potential V(r). Different computational modes have been implemented to define these effective potentials and to generate the radial Green's functions for all bound-state energies E<0. In addition, care has been taken to provide a user-friendly component of the Ratip package by utilizing features of the Fortran 90/95 standard such as data structures, allocatable arrays, or a module-oriented design.

Program summary

Title of program:XgreensCatalogue number: ADWMProgram summary URL:http://cpc.cs.qub.ac.uk/summaries/ADWMProgram obtainable from: CPC Program Library, Queen's University of Belfast, N. IrelandLicensing provisions:NoneComputer for which the new version has been tested: PC Pentium II, III, IV, AthlonInstallations: University of Kassel (Germany)Operating systems: SuSE Linux 8.2, SuSE Linux 9.0Program language used in the new version: ANSI standard Fortran 90/95Memory required to execute with typical data: On a standard grid (400 nodes), one central-field Green's function requires about 50 kBytes in RAM while approximately 3 MBytes are needed if saved as two-dimensional array on some external disc spaceNo. of bits in a word: Real variables of double- and quad-precision are usedPeripheral used: Disk for input/outputCPU time required to execute test data: 2 min on a 450 MHz Pentium III processorNo. of lines in distributed program, including test data etc.: 82 042No. of bytes in distributed program, including test data etc.: 814 096Distribution format: tar.gzNature of the physical problem: In atomic perturbation theory, Green's functions may help carry out the summation over the complete spectrum of atom and ions, including the (summation over the) bound states as well as an integration over the continuum [R.A. Swainson, G.W.F. Drake, J. Phys. A 24 (1991) 95]. Analytically, however, these functions are known only for free electrons (V(r)≡0) and for electrons in a pure Coulomb field (V(r)=−Z/r). For all other choices of the potential, in contrast, the Green's functions must be determined numerically.Method of solution: Relativistic Green's functions are generated for an arbitrary central-field potential V(r)=−Z(r)/r by using a piecewise linear approximation of the effective nuclear charge function Z(r) on some grid : Zi(r)=Z0i+Z1ir. Then, following McGuire's algorithm [E.J. McGuire, Phys. Rev. A 23 (1981) 186], the radial Green's functions are constructed from the (two) linear-independent solutions of the homogeneous equation [P. Morse, H. Feshbach, Methods of Theoretical Physics, McGraw-Hill, New York 1953 (Part 1, p. 825)]. In the computation of these radial functions, the Kummer and Tricomi functions [J. Spanier, B. Keith, An Atlas of Functions, Springer, New York, 1987] are used extensively.Restrictions onto the complexity of the problem: The main restrictions of the program concern the shape of the effective nuclear charge Z(r)=−rV(r), i.e. the choice of the potential, and the allowed energies. Apart from obeying the proper boundary conditions for a point-like nucleus, namely, Z(r→0)=Znuc>0 and Z(r→∞)=Znuc−Nelectrons?0, the first derivative of the charge function Z(r) must be smaller than the (absolute value of the) energy of the Green's function, .Unusual features of the program:Xgreens has been designed as a part of the Ratip package [S. Fritzsche, J. Elec. Spec. Rel. Phen. 114-116 (2001) 1155] for the calculation of relativistic atomic transition and ionization properties. In a short dialog at the beginning of the execution, the user can specify the choice of the potential as well as the energies and the symmetries of the radial Green's functions to be calculated. Apart from central-field Green's functions, of course, the Coulomb Green's function [P. Koval, S. Fritzsche, Comput. Phys. Comm. 152 (2003) 191] can also be computed by selecting a constant nuclear charge Z(r)=Zeff. In order to test the generated Green's functions, moreover, we compare the two lowest bound-state orbitals which are calculated from the Green's functions with those as generated separately for the given potential. Like the other components of the Ratip package, Xgreens makes careful use of the Fortran 90/95 standard.     

Helac-Phegas: A generator for all parton level processes

The updated version of the Helac-Phegas¹ event generator is presented. The matrix elements are calculated through Dyson-Schwinger recursive equations using color connection representation. Phase-space generation is based on a multichannel approach, including optimization. Helac-Phegas generates parton level events with all necessary information, in the most recent Les Houches Accord format, for the study of any process within the Standard Model in hadron and lepton colliders.

New version program summary

Program title: HELAC-PHEGASCatalogue identifier: ADMS_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADMS_v2_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 35 986No. of bytes in distributed program, including test data, etc.: 380 214Distribution format: tar.gzProgramming language: FortranComputer: AllOperating system: LinuxClassification: 11.1, 11.2External routines: Optionally Les Houches Accord (LHA) PDF Interface library (http://projects.hepforge.org/lhapdf/)Catalogue identifier of previous version: ADMS_v1_0Journal reference of previous version: Comput. Phys. Comm. 132 (2000) 306Does the new version supersede the previous version?: Yes, partlyNature of problem: One of the most striking features of final states in current and future colliders is the large number of events with several jets. Being able to predict their features is essential. To achieve this, the calculations need to describe as accurately as possible the full matrix elements for the underlying hard processes. Even at leading order, perturbation theory based on Feynman graphs runs into computational problems, since the number of graphs contributing to the amplitude grows as n!.Solution method: Recursive algorithms based on Dyson-Schwinger equations have been developed recently in order to overcome the computational obstacles. The calculation of the amplitude, using Dyson-Schwinger recursive equations, results in a computational cost growing asymptotically as 3n, where n is the number of particles involved in the process. Off-shell subamplitudes are introduced, for which a recursion relation has been obtained allowing to express an n-particle amplitude in terms of subamplitudes, with 1-, 2-, …  up to (n−1) particles. The color connection representation is used in order to treat amplitudes involving colored particles. In the present version HELAC-PHEGAS can be used to efficiently obtain helicity amplitudes, total cross sections, parton-level event samples in LHA format, for arbitrary multiparticle processes in the Standard Model in leptonic, and pp collisions.Reasons for new version: Substantial improvements, major functionality upgrade.Summary of revisions: Color connection representation, efficient integration over PDF via the PARNI algorithm, interface to LHAPDF, parton level events generated in the most recent LHA format, k_⊥ reweighting for Parton Shower matching, numerical predictions for amplitudes for arbitrary processes for phase-space points provided by the user, new user interface and the possibility to run over computer clusters.Running time: Depending on the process studied. Usually from seconds to hours.References:

[1]

A. Kanaki, C.G. Papadopoulos, Comput. Phys. Comm. 132 (2000) 306.

[2]

C.G. Papadopoulos, Comput. Phys. Comm. 137 (2001) 247.

     

Exoskeleton: Curve network abstraction for 3D shapes

In this paper, we introduce the concept of an exoskeleton as a new abstraction of arbitrary shapes that succinctly conveys both the perceptual and the geometric structure of a 3D model. We extract exoskeletons via a principled framework that combines segmentation and shape approximation. Our method starts from a segmentation of the shape into perceptually relevant parts and then constructs the exoskeleton using a novel extension of the Variational Shape Approximation method. Benefits of the exoskeleton abstraction to graphics applications such as simplification and chartification are presented.     

auto_deriv: Tool for automatic differentiation of a Fortran code

auto_deriv is a module comprised of a set of fortran 95 procedures which can be used to calculate the first and second partial derivatives (mixed or not) of any continuous function with many independent variables. The mathematical function should be expressed as one or more fortran 77/90/95 procedures. A new type of variables is defined and the overloading mechanism of functions and operators provided by the fortran 95 language is extensively used to define the differentiation rules. Proper (standard complying) handling of floating-point exceptions is provided by using the IEEE_EXCEPTIONS intrinsic module (Technical Report 15580, incorporated in fortran 2003).

New version program summary

Program title: AUTO_DERIVCatalogue identifier: ADLS_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/ADLS_v2_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 2963No. of bytes in distributed program, including test data, etc.: 10 314Distribution format: tar.gzProgramming language: Fortran 95 + (optionally) TR-15580 (Floating-point exception handling)Computer: all platforms with a Fortran 95 compilerOperating system: Linux, Windows, MacOSClassification: 4.12, 6.2Catalogue identifier of previous version: ADLS_v1_0Journal reference of previous version: Comput. Phys. Comm. 127 (2000) 343Does the new version supersede the previous version?: YesNature of problem: The need to calculate accurate derivatives of a multivariate function frequently arises in computational physics and chemistry. The most versatile approach to evaluate them by a computer, automatically and to machine precision, is via user-defined types and operator overloading. AUTO_DERIV is a Fortran 95 implementation of them, designed to evaluate the first and second derivatives of a function of many variables.Solution method: The mathematical rules for differentiation of sums, products, quotients, elementary functions in conjunction with the chain rule for compound functions are applied. The function should be expressed as one or more Fortran 77/90/95 procedures. A new type of variables is defined and the overloading mechanism of functions and operators provided by the Fortran 95 language is extensively used to implement the differentiation rules.Reasons for new version: The new version supports Fortran 95, handles properly the floating-point exceptions, and is faster due to internal reorganization. All discovered bugs are fixed.Summary of revisions:

•

The code was rewritten extensively to benefit from features introduced in Fortran 95. Additionally, there was a major internal reorganization of the code, resulting in faster execution. The user interface described in the original paper was not changed. The values that the user must or should specify before compilation (essentially, the number of independent variables) were moved into ad_types module.

•

There were many minor bug fixes. One important bug was found and fixed; the code did not handle correctly the overloading of in a∗∗λ when a=0.

•

The case of division by zero and the discontinuity of the function at the requested point are indicated by standard IEEE exceptions (IEEE_DIVIDE_BY_ZERO and IEEE_INVALID respectively). If the compiler does not support IEEE exceptions, a module with the appropriate name is provided, imitating the behavior of the ‘standard’ module in the sense that it raises the corresponding exceptions. It is up to the compiler (through certain flags probably) to detect them.

Restrictions: None imposed by the program. There are certain limitations that may appear mostly due to the specific implementation chosen in the user code. They can always be overcome by recoding parts of the routines developed by the user or by modifying AUTO_DERIV according to specific instructions given in [1]. The common restrictions of available memory and the capabilities of the compiler are the same as the original version.Additional comments: The program has been tested using the following compilers: Intel ifort, GNU gfortran, NAGWare f95, g95.Running time: The typical running time for the program depends on the compiler and the complexity of the differentiated function. A rough estimate is that AUTO_DERIV is ten times slower than the evaluation of the analytical (‘by hand’) function value and derivatives (if they are available).References:

[1]

S. Stamatiadis, R. Prosmiti, S.C. Farantos, AUTO_DERIV: tool for automatic differentiation of a Fortran code, Comput. Phys. Comm. 127 (2000) 343.