398 research outputs found
Adaptive Binning of X-ray data with Weighted Voronoi Tesselations
We present a technique to adaptively bin sparse X-ray data using weighted
Voronoi tesselations (WVTs). WVT binning is a generalisation of Cappellari &
Copin's (2001) Voronoi binning algorithm, developed for integral field
spectroscopy. WVT binning is applicable to many types of data and creates
unbiased binning structures with compact bins that do not lead the eye. We
apply the algorithm to simulated data, as well as several X-ray data sets, to
create adaptively binned intensity images, hardness ratio maps and temperature
maps with constant signal-to-noise ratio per bin. We also illustrate the
separation of diffuse gas emission from contributions of unresolved point
sources in elliptical galaxies. We compare the performance of WVT binning with
other adaptive binning and adaptive smoothing techniques. We find that the CIAO
tool csmooth creates serious artefacts and advise against its use to interpret
diffuse X-ray emission.Comment: 14 pages; submitted to MNRAS; code freely available at
http://www.phy.ohiou.edu/~diehl/WVT/index.html with user manual, examples and
high-resolution version of this pape
The Hot Interstellar Medium in Normal Elliptical Galaxies III: The Thermal Structure of the Gas
This is the third paper in a series analyzing X-ray emission from the hot
interstellar medium in a sample of 54 normal elliptical galaxies observed by
Chandra, focusing on 36 galaxies with sufficient signal to compute radial
temperature profiles. We distinguish four qualitatively different types of
profile: positive gradient (outwardly rising), negative gradients (falling),
quasi-isothermal (flat) and hybrid (falling at small radii, then rising). We
measure the mean logarithmic temperature gradients in two radial regions: from
0--2 -band effective radii (excluding the central point source), and
from 2--. We find the outer gradient to be uncorrelated with intrinsic
host galaxy properties, but strongly influenced by the environment: galaxies in
low-density environments tend to show negative outer gradients, while those in
high-density environments show positive outer gradients, suggesting influence
of circumgalactic hot gas. The inner temperature gradient is unaffected by the
environment but strongly correlated with intrinsic host galaxy characteristics:
negative inner gradients are more common for smaller, optically faint, low
radio-luminosity galaxies, whereas positive gradients are found in bright
galaxies with stronger radio sources. There is no evidence for bimodality in
the distribution of inner or outer gradients. We propose three scenarios to
explain the inner temperature gradients: (1) Weak AGN heat the ISM locally,
higher-luminosity AGN heat the system globally through jets inflating cavities
at larger radii; (2) The onset of negative inner gradients indicates a
declining importance of AGN heating relative to other sources, such as
compressional heating or supernovae; (3) The variety of temperature profiles
are snapshots of different stages of a time-dependent flow.Comment: 18 pages, emulateapj, 55 figures (36 online-only figures included in
astro-ph version), submitted to Ap
Shared memory parallelism in Modern C++ and HPX
Parallel programming remains a daunting challenge, from the struggle to
express a parallel algorithm without cluttering the underlying synchronous
logic, to describing which devices to employ in a calculation, to correctness.
Over the years, numerous solutions have arisen, many of them requiring new
programming languages, extensions to programming languages, or the addition of
pragmas. Support for these various tools and extensions is available to a
varying degree. In recent years, the C++ standards committee has worked to
refine the language features and libraries needed to support parallel
programming on a single computational node. Eventually, all major vendors and
compilers will provide robust and performant implementations of these
standards. Until then, the HPX library and runtime provides cutting edge
implementations of the standards, as well as proposed standards and extensions.
Because of these advances, it is now possible to write high performance
parallel code without custom extensions to C++. We provide an overview of
modern parallel programming in C++, describing the language and library
features, and providing brief examples of how to use them
Asynchronous Execution of Python Code on Task Based Runtime Systems
Despite advancements in the areas of parallel and distributed computing, the
complexity of programming on High Performance Computing (HPC) resources has
deterred many domain experts, especially in the areas of machine learning and
artificial intelligence (AI), from utilizing performance benefits of such
systems. Researchers and scientists favor high-productivity languages to avoid
the inconvenience of programming in low-level languages and costs of acquiring
the necessary skills required for programming at this level. In recent years,
Python, with the support of linear algebra libraries like NumPy, has gained
popularity despite facing limitations which prevent this code from distributed
runs. Here we present a solution which maintains both high level programming
abstractions as well as parallel and distributed efficiency. Phylanx, is an
asynchronous array processing toolkit which transforms Python and NumPy
operations into code which can be executed in parallel on HPC resources by
mapping Python and NumPy functions and variables into a dependency tree
executed by HPX, a general purpose, parallel, task-based runtime system written
in C++. Phylanx additionally provides introspection and visualization
capabilities for debugging and performance analysis. We have tested the
foundations of our approach by comparing our implementation of widely used
machine learning algorithms to accepted NumPy standards
Benchmarking the Parallel 1D Heat Equation Solver in Chapel, Charm++, C++, HPX, Go, Julia, Python, Rust, Swift, and Java
Many scientific high performance codes that simulate e.g. black holes,
coastal waves, climate and weather, etc. rely on block-structured meshes and
use finite differencing methods to iteratively solve the appropriate systems of
differential equations. In this paper we investigate implementations of an
extremely simple simulation of this type using various programming systems and
languages. We focus on a shared memory, parallelized algorithm that simulates a
1D heat diffusion using asynchronous queues for the ghost zone exchange. We
discuss the advantages of the various platforms and explore the performance of
this model code on different computing architectures: Intel, AMD, and ARM64FX.
As a result, Python was the slowest of the set we compared. Java, Go, Swift,
and Julia were the intermediate performers. The higher performing platforms
were C++, Rust, Chapel, Charm++, and HPX
- …