McStas perl tools to aid in running neutron ray tracing simulations.
McStas is a tool for simulating neutron instrumentation and experiments using
a ray-tracing formalism. Currently the main use of McStas is in the field of
instrumentation design.
This port contains a few perl-based helper tools (including a GUI) to aid the
user in setting up and running simulations. The tools are:
mcgui: A Tk/Perl based GUI.
mcrun: A Script that makes it easy to run sims and perform
point scans and simple optimizations.
mcdoc: Script for viewing inline component documentation.
mcplot: Tool for plotting McXtrace-generated results.
mcdisplay: Visual ray-tracing displaying neutron trajectories.
mcformatgui: Front-end to mxformat to help reformat data-files (obsolescent).
mcdaemon: Deamon to dynamically monitor and plot results (obsolescent).
mcstas2vitess: Tool to transfer a McStas simulation to ViTESS.
mcresplot: Script to help plotting resolution functions.
bchunk is a Unix/C rewrite of the fine BinChunker software for some
non-Unix systems.
binchunker converts a CD image in a ".bin / .cue" format
(sometimes ".raw / .cue") to a set of .iso and .cdr tracks. The
bin/cue format is used by some non-Unix cd-writing software, but
is not supported on most other cd-writing programs.
The .iso track contains an ISO file system, which can be mounted
through a vn device on FreeBSD systems, or written on a CD-R
using cdrecord. The .cdr tracks are in the native CD audio format. (pcm)
They can be either written on a CD-R using cdrecord -audio, or
converted to WAV (or any other sound format for that matter)
using sox.
Chess::PGN::Parse offers a range of methods to read and manipulate
Portable Game Notation files. PGN files contain chess games produced by
chess programs following a standard format
(http://www.schachprobleme.de/chessml/faq/pgn/). It is among the preferred
means of chess games distribution. Being a public, well established
standard, PGN is understood by many chess archive programs. Parsing simple
PGN files is not difficult. However, dealing with some of the intricacies
of the Standard is less than trivial. This module offers a clean handle
toward reading and parsing complex PGN files.
A PGN file has several tags, which are key/values pairs at the header of
each game, in the format [key "value"]
After the header, the game follows. A string of numbered chess moves,
optionally interrupted by braced comments and recursive parenthesized
variants and comments. While dealing with simple braced comments is
straightforward, parsing nested comments can give you more than a
headache.
The confget utility examines a INI-style configuration file and retrieves
the value of the specified variables from the specified section.
Its intended use is to let shell scripts use the same INI-style
configuration files as other programs, to avoid duplication of data.
The confget utility may retrieve the values of one or more variables,
list all the variables in a specified section, list only those whose names
or values match a specified pattern (shell glob or regular expression), or
check if a variable is present in the file at all. It has a "shell-quoting"
output mode that quotes the variable values in a way suitable for passing
them directly to a Bourne-style shell.
PyStemmer provides access to efficient algorithms for calculating a
"stemmed" form of a word. This is a form with most of the common
morphological endings removed; hopefully representing a common
linguistic base form. This is most useful in building search engines
and information retrieval software; for example, a search with stemming
enabled should be able to find a document containing "cycling" given the
query "cycles".
PyStemmer provides algorithms for several (mainly european) languages,
by wrapping the libstemmer library from the Snowball project in a Python
module. It also provides access to the classic Porter stemming algorithm
for english: although this has been superceded by an improved algorithm,
the original algorithm may be of interest to information retrieval
researchers wishing to reproduce results of earlier experiments.
Redet allows the user to construct regular expressions and test them against
input data by executing any of a variety of search programs, editors, and
programming languages that make use of regular expressions. When a suitable
regular expression has been constructed it may be saved to a file. redet stands
for Regular Expression Development and Execution Tool. For each program, a
palette showing the available regular expression syntax is provided. Selections
from the palette may be copied to the regular expression window with a mouse
click. Users may add their own definitions to the palette via their
initialization file. Redet also keeps a list of the regular expressions
executed, from which entries may be copied back into the regular expression
under construction. The history list is saved to a file and restored on
startup, so it persists across sessions. So long as the underlying program
supports Unicode, redet allows UTF-8 Unicode in both test data and regular
expressions
The HTML::Field set of modules creates objects that represent HTML form fields
which try to make it easier to interact with CGI objects, databases, and
HTML::Template objects.
The objective of an HTML::Field object is to know how to write its own HTML,
how to get its value out of a CGI object or from a hash,
how to add their value to a hash suitable for passing into a HTML::Template
or into a SQL::Abstract object, for example, and thus re-use some of the code
which is typically repeated several times in a CGI script.
This bundle includes also HTML::FieldForm, which is a very simple module to
manage sets of HTML::Field objects.
Load, configure, and compose WSGI applications and servers
Paste Deployment is a system for finding and configuring WSGI
applications and servers. For WSGI application consumers it provides a
single, simple function (loadapp) for loading a WSGI application from
a configuration file or a Python Egg. For WSGI application providers
it only asks for a single, simple entry point to your application, so
that application users don't need to be exposed to the implementation
details of your application.
The result is something a system administrator can install and manage
without knowing any Python, or the details of the WSGI application or
its container.
This tool provides code to load WSGI applications and servers from
URIs; these URIs can refer to Python Eggs for INI-style configuration
files. Paste Script provides commands to serve applications based on
this configuration file.
TurboGears 2 is a reinvention of the TurboGears project to take
advantage of new components, and to provide a fully customizable
WSGI (Web Server Gateway Interface) stack. From the beginning
TurboGears was designed to be a Full Stack framework built from
best-of-breed components. New components have been released which
improved on the ones in the original TGstack, and the Python web
world has been increasingly designed around WSGI.
This has enabled a whole new world of reuse, and TG2 is designed
to take advantage of this fact in order to make a framework which
provides easy to use, productive defaults, while still providing
flexibility where it is useful.
TG2 represents a change from some of the components in TurboGears 1,
but we have now invested in a set of components that we think will
continue to be at the center of python web development for years to
come.
Wysiwyg API allows to use client-side editors (a.k.a. WYSIWYG editors) for
editing content in the Drupal CMS. It simplifies installation of editors
and allows you to define which editor to use depending on the input format.
This module replaces all existing editor integration modules and no other
Drupal module is required.
It is capable of supporting any kind of client-side editor as long as there
are support files for it that integrate the external library with Wysiwyg
API. A client-side editor can be a regular HTML-based editor, a
"pseudo-editor" (that just provides buttons to insert HTML markup into a
plain textarea), or even a Flash-based editor. Support for various editor
libraries is built-in.
The Wysiwyg API also allows Drupal modules to register plugins (or
"buttons") for editors.