Bookmark and Share FiPy: A Finite Volume PDE Solver Using Python
Version 2.1.3

This Page

Contact

FiPy developers
Jonathan Guyer
Daniel Wheeler
James Warren

Join our mailing list

100 Bureau Drive, M/S 6555
Gaithersburg, MD 20899

301-975-5329 Telephone
301-975-4553 Facsimile

tools Package Documentation

This page contains the tools Package documentation.

The commWrapper Module

class fipy.tools.commWrapper.CommWrapper(Epetra=None)

Bases: object

MPI Communicator wrapper

Encapsulates capabilities needed for Epetra. Some capabilities are not parallel.

Barrier()
Norm2(vec)
Nproc
all(a, axis=None)
allclose(a, b, rtol=1e-05, atol=1e-08)
allequal(a, b)
allgather(sendobj=None, recvobj=None)
any(a, axis=None)
bcast(obj=None, root=0)
procID
sum(a, axis=None)

The debug Module

fipy.tools.debug.PRINT(label, arg='', stall=True)

The dummyComm Module

class fipy.tools.dummyComm.DummyComm

Bases: fipy.tools.serialCommWrapper.SerialCommWrapper

Barrier()
sum(a, axis=None)

The dump Module

fipy.tools.dump.read(filename, fileobject=None, communicator=<fipy.tools.commWrapper.CommWrapper object at 0x1068ad790>)

Read a pickled object from a file. Returns the unpickled object. Wrapper for cPickle.load().

Parameters :
  • filename: The name of the file to unpickle the object from.
  • fileobject: Used to remove temporary files
  • communicator: Object with procID and Nproc attributes.
fipy.tools.dump.write(data, filename=None, extension='', communicator=<fipy.tools.commWrapper.CommWrapper object at 0x1068ad790>)

Pickle an object and write it to a file. Wrapper for cPickle.dump().

Parameters :
  • data: The object to be pickled.
  • filename: The name of the file to place the pickled object. If filename is None then a temporary file will be used and the file object and file name will be returned as a tuple
  • extension: Used if filename is not given.
  • communicator: Object with procID and Nproc attributes.

Test to check pickling and unpickling.

>>> from fipy.meshes.grid1D import Grid1D
>>> old = Grid1D(nx = 2)
>>> f, tempfile = write(old)
>>> new = read(tempfile, f)
>>> print old.getNumberOfCells() == new.getNumberOfCells()
True

The inline Module

The memoryLeak Module

This python script is ripped from http://www.nightmare.com/medusa/memory-leaks.html

It outputs the top 100 number of outstanding references for each object.

The memoryLogger Module

class fipy.tools.memoryLogger.MemoryHighWaterThread(pid, sampleTime=1)

Bases: threading.Thread

run()
stop()
class fipy.tools.memoryLogger.MemoryLogger(sampleTime=1)
start()
stop()

The memoryUsage Module

This python script is ripped from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/286222/index_txt

The mpi4pyCommWrapper Module

class fipy.tools.mpi4pyCommWrapper.Mpi4pyCommWrapper(Epetra, MPI)

Bases: fipy.tools.commWrapper.CommWrapper

MPI Communicator wrapper

Encapsulates capabilities needed for both Epetra and mpi4py.

all(a, axis=None)
allclose(a, b, rtol=1e-05, atol=1e-08)
allequal(a, b)
allgather(sendobj=None, recvobj=None)
any(a, axis=None)
bcast(obj=None, root=0)

The numerix Module

The functions provided in ths module replace the Numeric module. The functions work with Variables, arrays or numbers. For example, create a Variable.

>>> from fipy.variables.variable import Variable
>>> var = Variable(value=0)

Take the tangent of such a variable. The returned value is itself a Variable.

>>> v = tan(var)
>>> v
numerix.tan(Variable(value=array(0)))
>>> print float(v)
0.0

Take the tangent of a int.

>>> tan(0)
0.0

Take the tangent of an array.

>>> print tan(array((0,0,0)))
[ 0.  0.  0.]

Eventually, this module will be the only place in the code where Numeric (or numarray (or scipy_core)) is explicitly imported.

fipy.tools.numerix.L1norm(arr)
Parameters :
  • arr: The array to evaluate.
Returns :

\|\mathtt{arr}\|_1 = \sum_{j=1}^{n} |\mathtt{arr}_j| is the L^1-norm of \mathtt{arr}.

fipy.tools.numerix.L2norm(arr)
Parameters :
  • arr: The array to evaluate.
Returns :

\|\mathtt{arr}\|_2 = \sqrt{\sum_{j=1}^{n} |\mathtt{arr}_j|^2} is the L^2-norm of \mathtt{arr}.

fipy.tools.numerix.LINFnorm(arr)
Parameters :
  • arr: The array to evaluate.
Returns :

\|\mathtt{arr}\|_\infty = [\sum_{j=1}^{n}
|\mathtt{arr}_j|^\infty]^\infty = \over{\max}{j} |\mathtt{arr}_j| is the L^\infty-norm of \mathtt{arr}.

fipy.tools.numerix.allclose(first, second, rtol=1e-05, atol=1e-08)

Tests whether or not first and second are equal, subect to the given relative and absolute tolerances, such that:

|first - second| < atol + rtol * |second|

This means essentially that both elements are small compared to atol or their difference divided by second‘s value is small compared to rtol.

fipy.tools.numerix.allequal(first, second)

Returns true if every element of first is equal to the corresponding element of second.

fipy.tools.numerix.arccos(arr)

Inverse cosine of x, \cos^{-1} x

>>> print tostring(arccos(0.0), precision=3)
1.571
>>> isnan(arccos(2.0))
True
>>> print tostring(arccos(array((0,0.5,1.0))), precision=3)
[ 1.571  1.047  0.   ]
>>> from fipy.variables.variable import Variable
>>> arccos(Variable(value=(0,0.5,1.0)))
numerix.arccos(Variable(value=array([ 0. ,  0.5,  1. ])))

Attention

the next should really return radians, but doesn’t

>>> print tostring(arccos(Variable(value=(0,0.5,1.0))), precision=3)
[ 1.571  1.047  0.   ]
fipy.tools.numerix.arccosh(arr)

Inverse hyperbolic cosine of x, \cosh^{-1} x

>>> print arccosh(1.0)
0.0
>>> isnan(arccosh(0.0))
True
>>> print tostring(arccosh(array((1,2,3))), precision=3)
[ 0.     1.317  1.763]
>>> from fipy.variables.variable import Variable
>>> arccosh(Variable(value=(1,2,3)))
numerix.arccosh(Variable(value=array([1, 2, 3])))
>>> print tostring(arccosh(Variable(value=(1,2,3))), precision=3)
[ 0.     1.317  1.763]
fipy.tools.numerix.arcsin(arr)

Inverse sine of x, \sin^{-1} x

>>> print tostring(arcsin(1.0), precision=3)
1.571
>>> isnan(arcsin(2.0))
True
>>> print tostring(arcsin(array((0,0.5,1.0))), precision=3)
[ 0.     0.524  1.571]
>>> from fipy.variables.variable import Variable
>>> arcsin(Variable(value=(0,0.5,1.0)))
numerix.arcsin(Variable(value=array([ 0. ,  0.5,  1. ])))

Attention

the next should really return radians, but doesn’t

>>> print tostring(arcsin(Variable(value=(0,0.5,1.0))), precision=3)
[ 0.     0.524  1.571]
fipy.tools.numerix.arcsinh(arr)

Inverse hyperbolic sine of x, \sinh^{-1} x

>>> print tostring(arcsinh(1.0), precision=3)
0.881
>>> print tostring(arcsinh(array((1,2,3))), precision=3)
[ 0.881  1.444  1.818]
>>> from fipy.variables.variable import Variable
>>> arcsinh(Variable(value=(1,2,3)))
numerix.arcsinh(Variable(value=array([1, 2, 3])))
>>> print tostring(arcsinh(Variable(value=(1,2,3))), precision=3)
[ 0.881  1.444  1.818]
fipy.tools.numerix.arctan(arr)

Inverse tangent of x, \tan^{-1} x

>>> print tostring(arctan(1.0), precision=3)
0.785
>>> print tostring(arctan(array((0,0.5,1.0))), precision=3)
[ 0.     0.464  0.785]
>>> from fipy.variables.variable import Variable
>>> arctan(Variable(value=(0,0.5,1.0)))
numerix.arctan(Variable(value=array([ 0. ,  0.5,  1. ])))

Attention

the next should really return radians, but doesn’t

>>> print tostring(arctan(Variable(value=(0,0.5,1.0))), precision=3)
[ 0.     0.464  0.785]
fipy.tools.numerix.arctan2(arr, other)

Inverse tangent of a ratio x/y, \tan^{-1} \frac{x}{y}

>>> print tostring(arctan2(3.0, 3.0), precision=3)
0.785
>>> print tostring(arctan2(array((0, 1, 2)), 2), precision=3)
[ 0.     0.464  0.785]
>>> from fipy.variables.variable import Variable
>>> arctan2(Variable(value=(0, 1, 2)), 2)
(numerix.arctan2(Variable(value=array([0, 1, 2])), 2))

Attention

the next should really return radians, but doesn’t

>>> print tostring(arctan2(Variable(value=(0, 1, 2)), 2), precision=3)
[ 0.     0.464  0.785]
fipy.tools.numerix.arctanh(arr)

Inverse hyperbolic tangent of x, \tanh^{-1} x

>>> print tostring(arctanh(0.5), precision=3)
0.549
>>> print tostring(arctanh(array((0,0.25,0.5))), precision=3)
[ 0.     0.255  0.549]
>>> from fipy.variables.variable import Variable
>>> arctanh(Variable(value=(0,0.25,0.5)))
numerix.arctanh(Variable(value=array([ 0.  ,  0.25,  0.5 ])))
>>> print tostring(arctanh(Variable(value=(0,0.25,0.5))), precision=3)
[ 0.     0.255  0.549]
fipy.tools.numerix.ceil(arr)

The largest integer \ge x, \lceil x \rceil

>>> print ceil(2.3)
3.0
>>> print ceil(array((-1.5,2,2.5)))
[-1.  2.  3.]
>>> from fipy.variables.variable import Variable
>>> ceil(Variable(value=(-1.5,2,2.5), unit="m**2"))
numerix.ceil(Variable(value=PhysicalField(array([-1.5,  2. ,  2.5]),'m**2')))
>>> print ceil(Variable(value=(-1.5,2,2.5), unit="m**2"))
[-1.  2.  3.] m**2
fipy.tools.numerix.conjugate(arr)

Complex conjugate of z = x + i y, z^\star = x - i y

>>> print conjugate(3 + 4j) == 3 - 4j
True
>>> print allclose(conjugate(array((3 + 4j, -2j, 10))), (3 - 4j, 2j, 10))
1
>>> from fipy.variables.variable import Variable
>>> var = conjugate(Variable(value=(3 + 4j, -2j, 10), unit="ohm"))
>>> print var.getUnit()
<PhysicalUnit ohm>
>>> print allclose(var.getNumericValue(), (3 - 4j, 2j, 10))
1
fipy.tools.numerix.cos(arr)

Cosine of x, \cos x

>>> print allclose(cos(2*pi/6), 0.5)
True
>>> print tostring(cos(array((0,2*pi/6,pi/2))), precision=3, suppress_small=1)
[ 1.   0.5  0. ]
>>> from fipy.variables.variable import Variable
>>> cos(Variable(value=(0,2*pi/6,pi/2), unit="rad"))
numerix.cos(Variable(value=PhysicalField(array([ 0.        ,  1.04719755,  1.57079633]),'rad')))
>>> print tostring(cos(Variable(value=(0,2*pi/6,pi/2), unit="rad")), suppress_small=1)
[ 1.   0.5  0. ]
fipy.tools.numerix.cosh(arr)

Hyperbolic cosine of x, \cosh x

>>> print cosh(0)
1.0
>>> print tostring(cosh(array((0,1,2))), precision=3)
[ 1.     1.543  3.762]
>>> from fipy.variables.variable import Variable
>>> cosh(Variable(value=(0,1,2)))
numerix.cosh(Variable(value=array([0, 1, 2])))
>>> print tostring(cosh(Variable(value=(0,1,2))), precision=3)
[ 1.     1.543  3.762]
fipy.tools.numerix.dot(a1, a2, axis=0)

return array of vector dot-products of v1 and v2 for arrays a1 and a2 of vectors v1 and v2

We can’t use numpy.dot() on an array of vectors

Test that Variables are returned as Variables.

>>> from fipy.meshes.grid2D import Grid2D
>>> mesh = Grid2D(nx=2, ny=1)
>>> from fipy.variables.cellVariable import CellVariable
>>> v1 = CellVariable(mesh=mesh, value=((0,1),(2,3)), rank=1)
>>> v2 = CellVariable(mesh=mesh, value=((0,1),(2,3)), rank=1)
>>> dot(v1, v2)._getVariableClass()
<class 'fipy.variables.cellVariable.CellVariable'>
>>> dot(v2, v1)._getVariableClass()
<class 'fipy.variables.cellVariable.CellVariable'>
>>> print rank(dot(v2, v1))
0
>>> print dot(v1, v2)
[ 4 10]
>>> dot(v1, v1)._getVariableClass()
<class 'fipy.variables.cellVariable.CellVariable'>
>>> print dot(v1, v1)
[ 4 10]
>>> v3 = array(((0,1),(2,3)))
>>> type(dot(v3, v3))
<type 'numpy.ndarray'>
>>> print dot(v3, v3)
[ 4 10]
fipy.tools.numerix.exp(arr)

Natural exponent of x, e^x

fipy.tools.numerix.floor(arr)

The largest integer \le x, \lfloor x \rfloor

>>> print floor(2.3)
2.0
>>> print floor(array((-1.5,2,2.5)))
[-2.  2.  2.]
>>> from fipy.variables.variable import Variable
>>> floor(Variable(value=(-1.5,2,2.5), unit="m**2"))
numerix.floor(Variable(value=PhysicalField(array([-1.5,  2. ,  2.5]),'m**2')))
>>> print floor(Variable(value=(-1.5,2,2.5), unit="m**2"))
[-2.  2.  2.] m**2
fipy.tools.numerix.getShape(arr)

Return the shape of arr

>>> getShape(1)
()
>>> getShape(1.)
()
>>> from fipy.variables.variable import Variable
>>> getShape(Variable(1))
()
>>> getShape(Variable(1.))
()
>>> getShape(Variable(1., unit="m"))
()
>>> getShape(Variable("1 m"))
()
fipy.tools.numerix.getUnit(arr)
fipy.tools.numerix.indices(dimensions, typecode=None)

indices(dimensions,typecode=None) returns an array representing a grid of indices with row-only, and column-only variation.

>>> NUMERIX.allclose(NUMERIX.array(indices((4, 6))), NUMERIX.indices((4,6)))
1
>>> NUMERIX.allclose(NUMERIX.array(indices((4, 6, 2))), NUMERIX.indices((4, 6, 2)))
1
>>> NUMERIX.allclose(NUMERIX.array(indices((1,))), NUMERIX.indices((1,)))
1
>>> NUMERIX.allclose(NUMERIX.array(indices((5,))), NUMERIX.indices((5,)))
1
fipy.tools.numerix.isFloat(arr)
fipy.tools.numerix.isInt(arr)
fipy.tools.numerix.isclose(first, second, rtol=1e-05, atol=1e-08)

Returns which elements of first and second are equal, subect to the given relative and absolute tolerances, such that:

|first - second| < atol + rtol * |second|

This means essentially that both elements are small compared to atol or their difference divided by second‘s value is small compared to rtol.

fipy.tools.numerix.log(arr)

Natural logarithm of x, \ln x \equiv \log_e x

>>> print tostring(log(10), precision=3)
2.303
>>> print tostring(log(array((0.1,1,10))), precision=3)
[-2.303  0.     2.303]
>>> from fipy.variables.variable import Variable
>>> log(Variable(value=(0.1,1,10)))
numerix.log(Variable(value=array([  0.1,   1. ,  10. ])))
>>> print tostring(log(Variable(value=(0.1,1,10))), precision=3)
[-2.303  0.     2.303]
fipy.tools.numerix.log10(arr)

Base-10 logarithm of x, \log_{10} x

>>> print log10(10)
1.0
>>> print log10(array((0.1,1,10)))
[-1.  0.  1.]
>>> from fipy.variables.variable import Variable
>>> log10(Variable(value=(0.1,1,10)))
numerix.log10(Variable(value=array([  0.1,   1. ,  10. ])))
>>> print log10(Variable(value=(0.1,1,10)))
[-1.  0.  1.]
fipy.tools.numerix.obj2sctype(rep, default=None)
fipy.tools.numerix.ones(a, t='l')
fipy.tools.numerix.put(arr, ids, values)

The opposite of take. The values of arr at the locations specified by ids are set to the corresponding value of values.

The following is to test improvments to puts with masked arrays. Places in the code were assuming incorrect put behavior.

>>> maskValue = 999999
>>> arr = zeros(3, 'l')
>>> ids = MA.masked_values((2, maskValue), maskValue)
>>> values = MA.masked_values((4, maskValue), maskValue)
>>> put(arr, ids, values) ## this should work 
>>> print arr
[0 0 4]
>>> arr = MA.masked_values((maskValue, 5, 10), maskValue)
>>> ids = MA.masked_values((2, maskValue), maskValue)
>>> values = MA.masked_values((4, maskValue), maskValue)
>>> put(arr, ids, values) 
>>> print arr ## works as expected
[-- 5 4]
>>> arr = MA.masked_values((maskValue, 5, 10), maskValue)
>>> ids = MA.masked_values((maskValue, 2), maskValue)
>>> values = MA.masked_values((4, maskValue), maskValue)
>>> put(arr, ids, values)
>>> print arr ## should be [-- 5 --] maybe??
[-- 5 999999]
fipy.tools.numerix.rank(a)

Get the rank of sequence a (the number of dimensions, not a matrix rank) The rank of a scalar is zero.

Note

The rank of a MeshVariable is for any single element. E.g., A CellVariable containing scalars at each cell, and defined on a 9 element Grid1D, has rank 0. If it is defined on a 3x3 Grid2D, it is still rank 0.

fipy.tools.numerix.reshape(arr, shape)

Change the shape of arr to shape, as long as the product of all the lenghts of all the axes is constant (the total number of elements does not change).

fipy.tools.numerix.sign(arr)
fipy.tools.numerix.sin(arr)

Sine of x, \sin x

>>> print sin(pi/6)
0.5
>>> print sin(array((0,pi/6,pi/2)))
[ 0.   0.5  1. ]
>>> from fipy.variables.variable import Variable
>>> sin(Variable(value=(0,pi/6,pi/2), unit="rad"))
numerix.sin(Variable(value=PhysicalField(array([ 0.        ,  0.52359878,  1.57079633]),'rad')))
>>> print sin(Variable(value=(0,pi/6,pi/2), unit="rad"))
[ 0.   0.5  1. ]
fipy.tools.numerix.sinh(arr)

Hyperbolic sine of x, \sinh x

>>> print sinh(0)
0.0
>>> print tostring(sinh(array((0,1,2))), precision=3)
[ 0.     1.175  3.627]
>>> from fipy.variables.variable import Variable
>>> sinh(Variable(value=(0,1,2)))
numerix.sinh(Variable(value=array([0, 1, 2])))
>>> print tostring(sinh(Variable(value=(0,1,2))), precision=3)
[ 0.     1.175  3.627]
fipy.tools.numerix.sqrt(arr)

Square root of x, \sqrt{x}

>>> print tostring(sqrt(2), precision=3)
1.414
>>> print tostring(sqrt(array((1,2,3))), precision=3)
[ 1.     1.414  1.732]
>>> from fipy.variables.variable import Variable
>>> sqrt(Variable(value=(1, 2, 3), unit="m**2"))
numerix.sqrt(Variable(value=PhysicalField(array([1, 2, 3]),'m**2')))
>>> print tostring(sqrt(Variable(value=(1, 2, 3), unit="m**2")), precision=3)
[ 1.     1.414  1.732] m
fipy.tools.numerix.sqrtDot(a1, a2)

Return array of square roots of vector dot-products for arrays a1 and a2 of vectors v1 and v2

Usually used with v1==v2 to return magnitude of v1.

fipy.tools.numerix.sum(arr, axis=0)

The sum of all the elements of arr along the specified axis.

fipy.tools.numerix.take(a, indices, axis=0, fill_value=None)

Selects the elements of a corresponding to indices.

fipy.tools.numerix.tan(arr)

Tangent of x, \tan x

>>> print tostring(tan(pi/3), precision=3)
1.732
>>> print tostring(tan(array((0,pi/3,2*pi/3))), precision=3)
[ 0.     1.732 -1.732]
>>> from fipy.variables.variable import Variable
>>> tan(Variable(value=(0,pi/3,2*pi/3), unit="rad"))
numerix.tan(Variable(value=PhysicalField(array([ 0.        ,  1.04719755,  2.0943951 ]),'rad')))
>>> print tostring(tan(Variable(value=(0,pi/3,2*pi/3), unit="rad")), precision=3)
[ 0.     1.732 -1.732]
fipy.tools.numerix.tanh(arr)

Hyperbolic tangent of x, \tanh x

>>> print tostring(tanh(1), precision=3)
0.762
>>> print tostring(tanh(array((0,1,2))), precision=3)
[ 0.     0.762  0.964]
>>> from fipy.variables.variable import Variable
>>> tanh(Variable(value=(0,1,2)))
numerix.tanh(Variable(value=array([0, 1, 2])))
>>> print tostring(tanh(Variable(value=(0,1,2))), precision=3)
[ 0.     0.762  0.964]
fipy.tools.numerix.tostring(arr, max_line_width=75, precision=8, suppress_small=False, separator=' ', array_output=0)

Returns a textual representation of a number or field of numbers. Each dimension is indicated by a pair of matching square brackets ([]), within which each subset of the field is output. The orientation of the dimensions is as follows: the last (rightmost) dimension is always horizontal, so that the frequent rank-1 fields use a minimum of screen real-estate. The next-to-last dimesnion is displayed vertically if present and any earlier dimension is displayed with additional bracket divisions.

Parameters :
  • max_line_width: the maximum number of characters used in a single line. Default is sys.output_line_width or 77.

  • precision: the number of digits after the decimal point. Default is sys.float_output_precision or 8.

  • suppress_small: whether small values should be suppressed (and output as 0). Default is sys.float_output_suppress_small or false.

  • separator: what character string to place between two numbers.

  • array_output: Format output for an eval. Only used if arr is a Numeric array.

    >>> from fipy import Variable
    >>> print tostring(Variable((1,0,11.2345)), precision=1)
    [  1.    0.   11.2]
    >>> print tostring(array((1,2)), precision=5)
    [1 2]
    >>> print tostring(array((1.12345,2.79)), precision=2)
    [ 1.12  2.79]
    >>> print tostring(1)
    1
    >>> print tostring(array(1))
    1
    >>> print tostring(array([1.23345]), precision=2)
    [ 1.23]
    >>> print tostring(array([1]), precision=2)
    [1]
    >>> print tostring(1.123456, precision=2)
    1.12
    >>> print tostring(array(1.123456), precision=3)
    1.123
    
fipy.tools.numerix.zeros(a, t='l')

The parser Module

fipy.tools.parser.parse(larg, action=None, type=None, default=None)

This is a wrapper function for the python optparse module. Unfortunately optparse does not allow command line arguments to be ignored. See the documentation for optparse for more details. Returns the argument value.

Parameters :
  • larg: The argument to be parsed.
  • action: store or store_true are possibilities
  • type: Type of the argument. int or float are possibilities.
  • default: Default value.

The serialCommWrapper Module

class fipy.tools.serialCommWrapper.SerialCommWrapper(Epetra=None)

Bases: fipy.tools.commWrapper.CommWrapper

Norm2(vec)
Nproc
procID

The test Module

The vector Module

Vector utility functions that are inexplicably absent from Numeric

fipy.tools.vector.prune(array, shift, start=0, axis=0)

removes elements with indices i = start + shift * n where n = 0, 1, 2, ...

>>> prune(numerix.arange(10), 3, 5)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> prune(numerix.arange(10), 3, 2)
array([0, 1, 3, 4, 6, 7, 9])
>>> prune(numerix.arange(10), 3)
array([1, 2, 4, 5, 7, 8])
>>> prune(numerix.arange(4, 7), 3)
array([5, 6])
fipy.tools.vector.putAdd(vector, ids, additionVector)

This is a temporary replacement for Numeric.put as it was not doing what we thought it was doing.

The vitals Module

class fipy.tools.vitals.Vitals

Bases: xml.dom.minidom.Document

Returns XML formatted information about current FiPy environment

appendChild(child)
appendInfo(name, svnpath=None, **kwargs)

append some additional information, possibly about a project under a separate svn repository

dictToXML(d, name)
save(fname)
svn(*args)
svncmd(cmd, *args)
tupleToXML(t, name, keys=None)