/[escript]/trunk/escript/src/escriptcpp.cpp
ViewVC logotype

Diff of /trunk/escript/src/escriptcpp.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1796 by jfenwick, Wed Sep 17 01:45:46 2008 UTC revision 3360 by jfenwick, Thu Nov 18 00:20:21 2010 UTC
# Line 1  Line 1 
1    
 /* $Id$ */  
   
2  /*******************************************************  /*******************************************************
3   *  *
4   *           Copyright 2003-2007 by ACceSS MNRF  * Copyright (c) 2003-2010 by University of Queensland
5   *       Copyright 2007 by University of Queensland  * Earth Systems Science Computational Center (ESSCC)
6   *  * http://www.uq.edu.au/esscc
7   *                http://esscc.uq.edu.au  *
8   *        Primary Business: Queensland, Australia  * Primary Business: Queensland, Australia
9   *  Licensed under the Open Software License version 3.0  * Licensed under the Open Software License version 3.0
10   *     http://www.opensource.org/licenses/osl-3.0.php  * http://www.opensource.org/licenses/osl-3.0.php
11   *  *
12   *******************************************************/  *******************************************************/
13    
14    
15  #include "Data.h"  #include "Data.h"
16  #include "FunctionSpace.h"  #include "FunctionSpace.h"
# Line 23  Line 22 
22  #include "AbstractSystemMatrix.h"  #include "AbstractSystemMatrix.h"
23  #include "AbstractTransportProblem.h"  #include "AbstractTransportProblem.h"
24  #include "DataVector.h"  #include "DataVector.h"
25    #include "esysUtils/Esys_MPI.h"
26    #include "EscriptParams.h"
27    #include "TestDomain.h"
28    
29    
30  extern "C" {  extern "C" {
31  #include "escript/blocktimer.h"  #include "esysUtils/blocktimer.h"
32  }  }
33    
34  #include "esysUtils/esysExceptionTranslator.h"  #include "esysUtils/esysExceptionTranslator.h"
35    
36    #include <boost/version.hpp>
37  #include <boost/python.hpp>  #include <boost/python.hpp>
38  #include <boost/python/module.hpp>  #include <boost/python/module.hpp>
39  #include <boost/python/def.hpp>  #include <boost/python/def.hpp>
40  #include <boost/python/object.hpp>  #include <boost/python/object.hpp>
41  #include <boost/python/tuple.hpp>  #include <boost/python/tuple.hpp>
42  #include <boost/python/numeric.hpp>  #include <boost/smart_ptr.hpp>
43    #include <boost/version.hpp>
44    
45  using namespace boost::python;  using namespace boost::python;
46    
47  /*! \mainpage Esys Documentation  /*! \mainpage Esys Documentation
48   *   *
49   * \version 1.0.0   * \version 3.0.0
50   *   *
51   * - \ref escript   * - \ref escript
52   *   *
53   * - \ref esys_exception "Esys Exception"   * - \ref esys_exception "Esys Exception"
54   *   *
55   * - \ref finley   * - \ref dudley
56   *   *
57   * - <a href=http://iservo.edu.au/esys/epydoc/index.html>Python module documentation (epydoc generated)</a>   * - <a href="../../epydoc/index.html">Python module documentation (epydoc generated)</a>
58   *   *
59   */   */
60    
# Line 57  using namespace boost::python; Line 62  using namespace boost::python;
62   * Escript is the python module that contains the interfaces   * Escript is the python module that contains the interfaces
63   * to the C++ side of escript.   * to the C++ side of escript.
64   *   *
65   * \version 1.0.0   *
66   *   *
67   * \section class_desc Class Description:   * \section class_desc Class Description:
68   * Data   * Data
# Line 75  using namespace boost::python; Line 80  using namespace boost::python;
80    
81  BOOST_PYTHON_MODULE(escriptcpp)  BOOST_PYTHON_MODULE(escriptcpp)
82  {  {
83    def("setNumberOfThreads",escript::setNumberOfThreads);  
84    def("getNumberOfThreads",escript::getNumberOfThreads);    #if BOOST_VERSION >= 103500
85    // params are: bool show_user_defined, bool show_py_signatures, bool show_cpp_signatures
86      docstring_options docopt(true,true,false);
87      #endif
88    
89      def("setNumberOfThreads",escript::setNumberOfThreads,"Use of this method is strongly discouraged.");
90      def("getNumberOfThreads",escript::getNumberOfThreads,"Return the maximum number of threads"
91    " available to OpenMP.");
92    def("releaseUnusedMemory",escript::releaseUnusedMemory);    def("releaseUnusedMemory",escript::releaseUnusedMemory);
93    def("blocktimer_initialize",blocktimer_initialize);    def("blocktimer_initialize",blocktimer_initialize);
94    def("blocktimer_reportSortByName",blocktimer_reportSortByName);    def("blocktimer_reportSortByName",blocktimer_reportSortByName);
95    def("blocktimer_reportSortByTime",blocktimer_reportSortByTime);    def("blocktimer_reportSortByTime",blocktimer_reportSortByTime);
96    def("blocktimer_increment",blocktimer_increment);    def("blocktimer_increment",blocktimer_increment);
97    def("blocktimer_time",blocktimer_time);    def("blocktimer_time",blocktimer_time);
98    def("getVersion",escript::getSvnVersion);    def("getVersion",escript::getSvnVersion,"This method will only report accurate version numbers for clean checkouts.");
99    def("printParallelThreadCounts",escript::printParallelThreadCnt);    def("printParallelThreadCounts",escript::printParallelThreadCnt);
100      def("getMPISizeWorld",escript::getMPISizeWorld,"Return number of MPI processes in the job.");
101      def("getMPIRankWorld",escript::getMPIRankWorld,"Return the rank of this process in the MPI World.");
102      def("MPIBarrierWorld",escript::MPIBarrierWorld,"Wait until all MPI processes have reached this point.");
103      def("getMPIWorldMax",escript::getMPIWorldMax,"\nEach MPI process calls this function with a"
104    " value for arg1. The maximum value is computed and returned.\n\n:rtype: int");
105      def("getMPIWorldSum",escript::getMPIWorldSum,"\nEach MPI process calls this function with a"
106    " value for arg1. The values are added up and the total value is returned.\n\n:rtype: int");
107      def("getMachinePrecision",escript::getMachinePrecision);
108      def("getMaxFloat",escript::getMaxFloat);
109      def("_saveDataCSV",escript::saveDataCSV, (args("filename","arg","sep","csep"), arg("append")=false),
110    "Saves data objects passed in a python dictionary to a file.\n"
111    "The data objects must be over the same domain and be able to be interpolated to the same FunctionSpace.\n"
112    "If one of the dictionary keys is named ``mask``, then only samples where ``mask`` has a positive\n"
113    "value will be written to the file.\n\n"
114    "A header line giving the names of each column will be output first.\n"
115    "The keys given in the dictionary will be used to name columns.\n"
116    "Then the data will be output, one line per sample (for all data).\n"
117    "That is, items in each column will be printed in the same order.\n"
118    "So you can be sure that values in the same row correspond to the same input value.\n\n"
119    "\n:param filename:\n:type filename: ``string``\n"
120    ":param arg: dictionary of named `Data` objects. If one is called ``mask`` it must be scalar data.\n"
121    ":type arg: ``dict``\n"
122    ":param sep: separator for columns (defaults to ',')\n"
123    ":type sep: ``string``\n"
124    ":param csep: separator for fields within data object (defaults to \"_\")\n:type csep: ``string``\n"
125    ":param append: If True, write to the end of ``filename``\n:type append: ``string``\n");
126    
127    
128    //    //
129    // Interface for AbstractDomain    // Interface for AbstractDomain
130    //    //
131    class_<escript::AbstractDomain>("Domain",no_init)    class_<escript::AbstractDomain, escript::Domain_ptr>("Domain","Base class for all domains.",no_init)
132       .def("setTagMap",&escript::AbstractDomain::setTagMap)       .def("getStatus",&escript::AbstractDomain::getStatus,"The status of a domain changes whenever the domain is modified\n\n:rtype: int")
133       .def("getTag",&escript::AbstractDomain::getTag)       .def("setTagMap",&escript::AbstractDomain::setTagMap,args("name","tag"),
134       .def("isValidTagName",&escript::AbstractDomain::isValidTagName)  "Give a tag number a name.\n\n:param name: Name for the tag\n:type name: ``string``\n"
135       .def("showTagNames",&escript::AbstractDomain::showTagNames)  ":param tag: numeric id\n:type tag: ``int``\n:note: Tag names must be unique within a domain")
136       .def("getX",&escript::AbstractDomain::getX)       .def("getTag",&escript::AbstractDomain::getTag,args("name"),":return: tag id for "
137       .def("getNormal",&escript::AbstractDomain::getNormal)  "``name``\n:rtype: ``string``")
138       .def("getSize",&escript::AbstractDomain::getSize)       .def("isValidTagName",&escript::AbstractDomain::isValidTagName,args("name"),
139       .def("saveVTK",&escript::AbstractDomain::saveVTK)  ":return: True is ``name`` corresponds to a tag\n:rtype: ``bool``")
140       .def("saveDX",&escript::AbstractDomain::saveDX)       .def("showTagNames",&escript::AbstractDomain::showTagNames,":return: A space separated list of tag names\n:rtype: ``string``")
141       .def("getMPISize",&escript::AbstractDomain::getMPISize)       .def("getX",&escript::AbstractDomain::getX,":rtype: `Data`\n:return: Locations in the"
142       .def("getMPIRank",&escript::AbstractDomain::getMPIRank)  "`Domain`. FunctionSpace is chosen appropriately")
143         .def("getDim",&escript::AbstractDomain::getDim,":rtype: `int`\n:return: Spatial dimension of the `Domain`")
144         .def("getNormal",&escript::AbstractDomain::getNormal,":rtype: `escript`\n:return: Boundary normals")
145         .def("getSize",&escript::AbstractDomain::getSize,":return: the local size of samples. The function space is chosen appropriately\n:rtype: `Data`")
146         .def("saveVTK",&escript::AbstractDomain::saveVTK,args("filename","arg", "metadata"
147    , "metadata_schema"),
148    ":param filename: \n:type filename: ``string``\n:param arg: items to be added"
149    "\n:type arg: ``dict``\n:param metadata: string representing some meta data to be added\n:type metadata: ``string``"
150    "\n:param metadata_schema: schema type for metadata\n:type metadata_schema: ``string``")
151         .def("dump",&escript::AbstractDomain::dump,args("filename"),"Dumps the domain to a file"
152    ":param filename:\n:type filename: string")
153         .def("saveDX",&escript::AbstractDomain::saveDX,args("filename","arg"),"Saves a dictonary of Data objects to an OpenDX input file.\n\n:param filename:\n:type filename: ``string``"
154    "\n:param arg:\n:type arg: `dict`")
155         .def("getMPISize",&escript::AbstractDomain::getMPISize,":return: the number of processes used for this `Domain`\n:rtype: ``int``")
156         .def("getMPIRank",&escript::AbstractDomain::getMPIRank,":return: the rank of this process\n:rtype: ``int``")
157         .def("MPIBarrier",&escript::AbstractDomain::MPIBarrier,"Wait until all processes have reached this point")
158         .def("onMasterProcessor",&escript::AbstractDomain::onMasterProcessor,":return: True if this code is executing on the master process\n:rtype: `bool`")
159         .def("supportsContactElements", &escript::AbstractDomain::supportsContactElements,"Does this domain support contact elements.")
160       .def(self == self)       .def(self == self)
161       .def(self != self);       .def(self != self);
162    
163    //    //
164    // Interface for AbstractContinuousDomain    // Interface for AbstractContinuousDomain
165    //    //
166    class_<escript::AbstractContinuousDomain, bases<escript::AbstractDomain> >("ContinuousDomain",no_init)    class_<escript::AbstractContinuousDomain, bases<escript::AbstractDomain> >("ContinuousDomain","Class representing continuous domains",no_init)
167         .def("getSystemMatrixTypeId",&escript::AbstractContinuousDomain::getSystemMatrixTypeId);         .def("getSystemMatrixTypeId",&escript::AbstractContinuousDomain::getSystemMatrixTypeId,
168    args("solver", "preconditioner", "package", "symmetry"),
169    ":return: the identifier of the matrix type to be used for the global stiffness matrix "
170    "when a particular solver package and symmetric matrix is used.\n"
171    ":rtype: int")
172           .def("getTransportTypeId",&escript::AbstractContinuousDomain::getTransportTypeId,
173    args("solver", "preconditioner", "package", "symmetry"))
174    
175          .def("addPDEToSystem",&escript::AbstractContinuousDomain::addPDEToSystem,
176    args("mat", "rhs","A", "B", "C", "D", "X", "Y", "d", "y", "d_contact", "y_contact"),
177    "adds a PDE onto the stiffness matrix mat and a rhs\n\n"
178    ":param mat:\n:type mat: `OperatorAdapter`\n:param rhs:\n:type rhs: `Data`\n"
179    ":param A:\n:type A: `Data`\n"
180    ":param B:\n:type B: `Data`\n"
181    ":param C:\n:type C: `Data`\n"
182    ":param D:\n:type D: `Data`\n"
183    ":param X:\n:type X: `Data`\n"
184    ":param Y:\n:type Y: `Data`\n"
185    ":param d:\n:type d: `Data`\n"
186    ":param d_contact:\n:type d_contact: `Data`\n"
187    ":param y_contact:\n:type y_contact: `Data`\n"
188    )
189          .def("addPDEToRHS",&escript::AbstractContinuousDomain::addPDEToRHS,
190    args("rhs", "X", "Y", "y", "y_contact"),
191    "adds a PDE onto the stiffness matrix mat and a rhs\n\n"
192    ":param rhs:\n:type rhs: `Data`\n"
193    ":param X:\n:type X: `Data`\n"
194    ":param Y:\n:type Y: `Data`\n"
195    ":param y:\n:type y: `Data`\n"
196    ":param y_contact:\n:type y_contact: `Data`"
197    )
198          .def("addPDEToTransportProblem",&escript::AbstractContinuousDomain::addPDEToTransportProblem,
199    args( "tp", "source", "M", "A", "B", "C", "D", "X", "Y", "d", "y", "d_contact", "y_contact"),
200    ":param tp:\n:type tp: `TransportProblemAdapter`\n"
201    ":param source:\n:type source: `Data`\n"
202    ":param M:\n:type M: `Data`\n"
203    ":param A:\n:type A: `Data`\n"
204    ":param B:\n:type B: `Data`\n"
205    ":param C:\n:type C: `Data`\n"
206    ":param D:\n:type D: `Data`\n"
207    ":param X:\n:type X: `Data`\n"
208    ":param Y:\n:type Y: `Data`\n"
209    ":param d:\n:type d: `Data`\n"
210    ":param y:\n:type y: `Data`\n"
211    ":param d_contact:\n:type d_contact: `Data`\n"
212    ":param y_contact:\n:type y_contact: `Data`\n"
213    )
214          .def("newOperator",&escript::AbstractContinuousDomain::newSystemMatrix,
215    args("row_blocksize", "row_functionspace", "column_blocksize", "column_functionspace", "type"),
216    "creates a SystemMatrixAdapter stiffness matrix and initializes it with zeros\n\n"
217    ":param row_blocksize:\n:type row_blocksize: ``int``\n"
218    ":param row_functionspace:\n:type row_functionspace: `FunctionSpace`\n"
219    ":param column_blocksize:\n:type column_blocksize: ``int``\n"
220    ":param column_functionspace:\n:type column_functionspace: `FunctionSpace`\n"
221    ":param type:\n:type type: ``int``\n"
222    )
223          .def("newTransportProblem",&escript::AbstractContinuousDomain::newTransportProblem,
224    args("theta", "blocksize", "functionspace", "type"),
225    "creates a TransportProblemAdapter\n\n"
226    ":param theta:\n:type theta: ``float``\n"
227    ":param blocksize:\n:type blocksize: ``int``\n"
228    ":param functionspace:\n:type functionspace: `FunctionSpace`\n"
229    ":param type:\n:type type: ``int``\n"
230    )
231          .def("getDataShape",&escript::AbstractContinuousDomain::getDataShape, args("functionSpaceCode"),
232    ":return: a pair (dps, ns) where dps=the number of data points per sample, and ns=the number of samples\n:rtype: ``tuple``")
233          .def("print_mesh_info",&escript::AbstractContinuousDomain::Print_Mesh_Info,(arg("full")=false),
234    ":param full:\n:type full: ``bool``")
235          .def("getDescription",&escript::AbstractContinuousDomain::getDescription,
236    ":return: a description for this domain\n:rtype: ``string``")
237          .def("setX",&escript::AbstractContinuousDomain::setNewX,
238    args("arg"), "assigns new location to the domain\n\n:param arg:\n:type arg: `Data`")
239          .def("getNumDataPointsGlobal",&escript::AbstractContinuousDomain::getNumDataPointsGlobal,
240    ":return: the number of data points summed across all MPI processes\n"
241    ":rtype: ``int``");
242    
243    
244    
245    
246      //
247      // Interface for TestDomain
248      //
249      class_ <escript::TestDomain, bases<escript::AbstractDomain> >("TestDomain", "Test Class for domains with no structure. May be removed from future releases without notice.", init<int,int>());
250    
251      // This is the only python visible way to get a TestDomain
252      def("getTestDomainFunctionSpace",&escript::getTestDomainFunctionSpace, args("dpps",
253     "samples"),
254    "For testing only. May be removed without notice.");
255    
256    //    //
257    // Interface for FunctionSpace    // Interface for FunctionSpace
258    //    //
259    class_<escript::FunctionSpace> fs_definer("FunctionSpace",init<>());    class_<escript::FunctionSpace> fs_definer("FunctionSpace","A FunctionSpace describes which points from the `Domain` to use to represent functions.",init<>());    // Doco goes in the empty string param
260    fs_definer.def("getDim",&escript::FunctionSpace::getDim);    fs_definer.def("getDim",&escript::FunctionSpace::getDim,":return: the spatial dimension of the underlying domain.\n:rtype: int");
261    fs_definer.def("getDomain",&escript::FunctionSpace::getDomain,  //   fs_definer.def("getDomain",&escript::FunctionSpace::getDomain,
262                   return_internal_reference<>());  //                  return_internal_reference<>());
263    fs_definer.def("getX",&escript::FunctionSpace::getX);    fs_definer.def("getDomain",&escript::FunctionSpace::getDomainPython,":return: the underlying `Domain` for this FunctionSpace.\n:rtype: `Domain`");
264    fs_definer.def("getNormal",&escript::FunctionSpace::getNormal);    fs_definer.def("getX",&escript::FunctionSpace::getX,"\n:return: a function whose values are its input coordinates. ie an identity function.\n:rtype: `Data`");
265    fs_definer.def("getSize",&escript::FunctionSpace::getSize);    fs_definer.def("getNormal",&escript::FunctionSpace::getNormal,":return: the surface normal field.\n\n:rtype: `Data`");
266    fs_definer.def("setTags",&escript::FunctionSpace::setTags);    fs_definer.def("getSize",&escript::FunctionSpace::getSize,":return: sample size\n:rtype: `Data`");
267      fs_definer.def("setTags",&escript::FunctionSpace::setTags,args("newtag","mask"),
268    "Set tags according to a mask\n\n:param newtag: tag number to set\n:type newtag: string, non-zero ``int``\n:param mask: Samples which correspond to positive values in the mask will be set to ``newtag``.\n:type mask: scalar `Data`");
269      fs_definer.def("setTags",&escript::FunctionSpace::setTagsByString,args("newtag","mask"));
270    fs_definer.def("getTagFromDataPointNo",    fs_definer.def("getTagFromDataPointNo",
271                   &escript::FunctionSpace::getTagFromDataPointNo);                   &escript::FunctionSpace::getTagFromDataPointNo,":return: the tag associated with the given sample number.\n:rtype: int");
272    fs_definer.def("getReferenceIDFromDataPointNo", &escript::FunctionSpace::getReferenceIDFromDataPointNo);    fs_definer.def("getReferenceIDFromDataPointNo", &escript::FunctionSpace::getReferenceIDFromDataPointNo,args("dataPointNo"),":return: the reference number associated with ``dataPointNo``\n:rtype: int ");
273    fs_definer.def("getListOfTags",&escript::FunctionSpace::getListOfTags);    fs_definer.def("getListOfTags",&escript::FunctionSpace::getListOfTags,":return: a list of the tags used in this function space\n:rtype: ``list``");
274      fs_definer.def("getApproximationOrder", &escript::FunctionSpace::getApproximationOrder,":return: the approximation order refering to the maximum degree of a polynomial which can be represenred exactly in interplation and/or integration.\n:rtype: ``int``");
275    fs_definer.def("__str__", &escript::FunctionSpace::toString);    fs_definer.def("__str__", &escript::FunctionSpace::toString);
276    fs_definer.def(self == self);    fs_definer.def(self == self);
277    fs_definer.def(self != self);    fs_definer.def(self != self);
278    //    //
279    // Interface for Data    // Interface for Data
280    //    //
281    class_<escript::Data>("Data","TEST DOCUMENTATION",init<>())    class_<escript::Data>("Data","Represents a collection of datapoints. It is used to store the values of a function. For more details please consult the c++ class documentation.",init<>() )
282      // various constructors for Data objects      // various constructors for Data objects
     .def(init<const numeric::array&, optional<const escript::FunctionSpace&, bool> >(args("value","what","expand")))  
283      .def(init<const object&, optional<const escript::FunctionSpace&, bool> >(args("value","what","expand")))      .def(init<const object&, optional<const escript::FunctionSpace&, bool> >(args("value","what","expand")))
284      .def(init<const double, const tuple&, optional<const escript::FunctionSpace&, bool> >(args("value","shape","what","expand")))      .def(init<const double, const tuple&, optional<const escript::FunctionSpace&, bool> >(args("value","shape","what","expand")))
285      .def(init<const escript::Data&, const escript::FunctionSpace&>(args("value","what")))      .def(init<const escript::Data&, const escript::FunctionSpace&>(args("value","what")))
# Line 143  BOOST_PYTHON_MODULE(escriptcpp) Line 287  BOOST_PYTHON_MODULE(escriptcpp)
287      // Note for Lutz, Need to specify the call policy in order to return a      // Note for Lutz, Need to specify the call policy in order to return a
288      // reference. In this case return_internal_reference.      // reference. In this case return_internal_reference.
289      .def("__str__",&escript::Data::toString)      .def("__str__",&escript::Data::toString)
290      .def("getDomain",&escript::Data::getDomain,return_internal_reference<>())      .def("getDomain",&escript::Data::getDomainPython,":rtype: `Domain`")
291      .def("getFunctionSpace",&escript::Data::getFunctionSpace,return_internal_reference<>())      .def("getFunctionSpace",&escript::Data::getFunctionSpace,return_value_policy<copy_const_reference>(),":rtype: `FunctionSpace`")
292      .def("isEmpty",&escript::Data::isEmpty)      .def("isEmpty",&escript::Data::isEmpty,"Is this object an instance of ``DataEmpty``\n\n:rtype: ``bool``\n:note: This is not the same thing as asking if the object contains datapoints.")
293      .def("isProtected",&escript::Data::isProtected)      .def("isProtected",&escript::Data::isProtected,"Can this instance be modified.\n:rtype: ``bool``")
294      .def("setProtection",&escript::Data::setProtection)      .def("setProtection",&escript::Data::setProtection,"Disallow modifications to this data object\n\n:note: This method does not allow you to undo protection.")
295      .def("getShape",&escript::Data::getShapeTuple)      .def("getShape",&escript::Data::getShapeTuple,"\nReturns the shape of the datapoints in this object as a python tuple. Scalar data has the shape ``()``\n\n:rtype: ``tuple``")
296      .def("getRank",&escript::Data::getDataPointRank)      .def("getRank",&escript::Data::getDataPointRank,":return: the number of indicies required to address a component of a datapoints\n:rtype: positive ``int``")
297      .def("dump",&escript::Data::dump)      .def("dump",&escript::Data::dump,args("fileName"),"Save the data as a netCDF file\n\n:param fileName: \n:type fileName: ``string``")
298      .def("copyWithMask",&escript::Data::copyWithMask)      .def("toListOfTuples",&escript::Data::toListOfTuples, (arg("scalarastuple")=false),
299      .def("setTaggedValue",&escript::Data::setTaggedValue)  "Return the datapoints of this object in a list. Each datapoint is stored as a tuple.\n\n"
300      .def("setTaggedValue",&escript::Data::setTaggedValueByName)  ":param scalarastuple: if True, scalar data will be wrapped as a tuple."
301      .def("getNumberOfDataPoints",&escript::Data::getNumDataPoints)  " True => [(0), (1), (2)]; False => [0, 1, 2]")
302      .def("isExpanded",&escript::Data::isExpanded)      .def("copyWithMask",&escript::Data::copyWithMask,args("other","mask"),
303      .def("isTagged",&escript::Data::isTagged)  "Selectively copy values from ``other`` `Data`."
304      .def("expand",&escript::Data::expand)  "Datapoints which correspond to postive values in ``mask`` will be copied from ``other``\n"
305      .def("tag",&escript::Data::tag)  "\n:param other: source of values\n"
306      .def("copy",&escript::Data::copy)  ":type other: `Data`\n:param mask:\n:type mask: Scalar `Data`")
307      .def("setValueOfDataPoint",&escript::Data::setValueOfDataPointToPyObject)      .def("setTaggedValue",&escript::Data::setTaggedValue,args("tagKey","value"),
308    "Set the value of tagged Data.\n\n:param tagKey: tag to update\n:type tagKey: ``int``\n")
309        .def("setTaggedValue",&escript::Data::setTaggedValueByName,args("name","value"),":param name: tag to update\n:type name: ``string``\n"
310    ":param value: value to set tagged data to\n:type value: ``object`` which acts like an array, ``tuple`` or ``list``\n")
311        .def("getNumberOfDataPoints",&escript::Data::getNumDataPoints,":rtype: ``int``\n:return: Number of datapoints in the object")
312        .def("isExpanded",&escript::Data::isExpanded,":rtype: ``bool``\n:return: True if this ``Data`` is expanded.")
313        .def("isTagged",&escript::Data::isTagged,":rtype: ``bool``\n:return: True if this ``Data`` is expanded.")
314        .def("isConstant",&escript::Data::isConstant,":rtype: ``bool``\n:return: True if this ``Data`` is an instance of ``DataConstant``\n:note: This does not mean the data is immutable.")
315        .def("isLazy",&escript::Data::isLazy,":rtype: ``bool``\n:return: True if this ``Data`` is lazy.")
316        .def("isReady",&escript::Data::isReady,":rtype: ``bool``\n:return: True if this ``Data`` is not lazy.")
317        .def("expand",&escript::Data::expand,"Convert the data to expanded representation if it is not expanded already.")
318        .def("tag",&escript::Data::tag,"Convert data to tagged representation if it is not already tagged or expanded")
319        .def("resolve",&escript::Data::resolve,"Convert the data to non-lazy representation.")
320        .def("copy",&escript::Data::copy,args("other"),"Make this object a copy of ``other``\n"
321    "\n:note: The two objects will act independently from now on. That is, changing ``other`` "
322    "after this call will not change this object and vice versa.")
323        .def("copy",&escript::Data::copySelf,":note: In the no argument form, a new object will be returned which is an independent copy of this object.")
324        .def("delay",&escript::Data::delay,"Convert this object into lazy representation")
325        .def("setValueOfDataPoint",&escript::Data::setValueOfDataPointToPyObject,args("dataPointNo","value"))
326      .def("setValueOfDataPoint",&escript::Data::setValueOfDataPointToArray)      .def("setValueOfDataPoint",&escript::Data::setValueOfDataPointToArray)
327      .def("setValueOfDataPoint",&escript::Data::setValueOfDataPoint)      .def("setValueOfDataPoint",&escript::Data::setValueOfDataPoint,"\nModify the value of a single datapoint.\n\n:param dataPointNo:\n"
328      .def("getValueOfDataPoint",&escript::Data::getValueOfDataPoint)  ":type dataPointNo: int\n:param value: \n:type value: ``float`` or an object which acts like an array, ``tuple`` or ``list``\n:warning: Use of this operation is discouraged. It prevents some optimisations from operating.")
329      .def("getValueOfGlobalDataPoint",&escript::Data::getValueOfGlobalDataPoint)      .def("getTupleForDataPoint",&escript::Data::getValueOfDataPointAsTuple,args("dataPointNo"),
330      .def("setToZero",&escript::Data::setToZero)  ":return: Value of the specified datapoint\n:rtype: ``tuple``\n:param dataPointNo: datapoint to access\n:type dataPointNo: ``int``")
331      .def("interpolate",&escript::Data::interpolate)      .def("getTupleForGlobalDataPoint",&escript::Data::getValueOfGlobalDataPointAsTuple,args("procNo","dataPointNo"),"Get a specific datapoint from a specific process\n\n"
332      .def("minGlobalDataPoint",&escript::Data::minGlobalDataPoint)  ":rtype: ``tuple``\n:param procNo: MPI rank of the process\n:type procNo: positive ``int``"
333      .def("saveDX",&escript::Data::saveDX)  "\n:param dataPointNo: datapoint to access\n:type dataPointNo: int")
334      .def("saveVTK",&escript::Data::saveVTK)      .def("setToZero",&escript::Data::setToZero,"After this call the object will store values of the same shape as before but all components will be zero.")
335      .def("getTagNumber",&escript::Data::getTagNumber)      .def("interpolate",&escript::Data::interpolate,args("functionspace"),"Interpolate this object's values into a new functionspace.")
336        .def("interpolateTable", &escript::Data::interpolateFromTable2DP,
337    (arg("table"),arg("Amin"),arg("Astep"), arg("B"), arg("Bmin"), arg("Bstep"), arg("undef")=1.e50, arg("check_boundaries")=false),
338    "Creates a new Data object by interpolating using the source data (which are\n"
339    "looked up in ``table``)\n``A`` must be the outer dimension on the table\n\n"
340    ":param table: two dimensional collection of values\n"
341    ":param Amin: The base of locations in table\n:type Amin: float\n"
342    ":param Astep: size of gap between each item in the table\n:type Astep: float\n"
343    ":param undef: upper bound on interpolated values\n:type undef: float\n"
344    ":param B: Scalar representing the second coordinate to be mapped into the table\n"
345    ":type B: `Data`\n"
346    ":param Bmin: The base of locations in table for 2nd dimension\n:type Bmin: float\n"
347    ":param Bstep: size of gap between each item in the table for 2nd dimension\n:type Bstep: float\n"
348    ":param check_boundaries: if true, then values outside the boundaries will be rejected. If false, then boundary values will be used.\n"
349    ":raise RuntimeError(DataException): if the cordinates do not map into the table or if the interpolated value is above ``undef``"
350    "\n:rtype: `Data`"
351    )
352        .def("interpolateTable", &escript::Data::interpolateFromTable1DP,
353    (arg("table"),arg("Amin"),arg("Astep"), arg("undef")=1.e50, arg("check_boundaries")=false)/*,
354    "Creates a new Data object by interpolating using the source data (which are\n"
355    "looked up in ``table``)\n\n"
356    ":param table: one dimensional collection of values\n"
357    ":param Amin: The base of locations in table\n:type Amin: float\n"
358    ":param Astep: size of gap between each item in the table\n:type Astep: float\n"
359    ":param undef: upper bound on interpolated values\n:type undef: float\n"
360    ":param check_boundaries: if true, then values outside the boundaries will be rejected. If false, then boundary values will be used.\n"
361    ":raise RuntimeError(DataException): if the cordinates do not map into the table or if the interpolated value is above ``undef``"
362    "\n:rtype: `Data`"
363    */
364    )
365    
366    
367        .def("minGlobalDataPoint",&escript::Data::minGlobalDataPoint,"Please consider using getInfLocator() from pdetools instead.")
368        .def("maxGlobalDataPoint",&escript::Data::maxGlobalDataPoint, "Please consider using getSupLocator() from pdetools instead.")
369        .def("saveDX",&escript::Data::saveDX,args("fileName"),"Save the object in DX format.\n\n"
370    ":param fileName: filename\n:type fileName: string")
371        .def("saveVTK",&escript::Data::saveVTK, args("fileName"),"Save the object in VTK format.\n\n"
372    ":param fileName: \n:type fileName: string")
373        .def("getTagNumber",&escript::Data::getTagNumber,args("dpno"),"Return tag number for the specified datapoint\n\n:rtype: int\n:param dpno: datapoint number\n:type dpno: int")
374      // Unary functions for Data      // Unary functions for Data
375      .def("_interpolate",&escript::Data::interpolate)      .def("_interpolate",&escript::Data::interpolate)
376      .def("_grad",&escript::Data::gradOn)      .def("_grad",&escript::Data::gradOn)
# Line 210  BOOST_PYTHON_MODULE(escriptcpp) Line 410  BOOST_PYTHON_MODULE(escriptcpp)
410      .def("_eigenvalues",&escript::Data::eigenvalues)      .def("_eigenvalues",&escript::Data::eigenvalues)
411      .def("_eigenvalues_and_eigenvectors",&escript::Data::eigenvalues_and_eigenvectors,(arg("tol")=1.e-13))      .def("_eigenvalues_and_eigenvectors",&escript::Data::eigenvalues_and_eigenvectors,(arg("tol")=1.e-13))
412      // functions returning a single real number:      // functions returning a single real number:
413      .def("_Lsup",&escript::Data::Lsup)      .def("_Lsup",&escript::Data::Lsup,":return: the Lsup-norm of the object\n:rtype: float\n:note: If the ``Data`` contains no values, zero will be returned instead.")
414      .def("_sup",&escript::Data::sup)      .def("_sup",&escript::Data::sup,":return: the maximum value over all data points.\n:rtype: float\n:note: If the ``Data`` contains no values a large negative value will be returned instead.")
415      .def("_inf",&escript::Data::inf)      .def("_inf",&escript::Data::inf,":return: minimum value over all components and all data points\n:rtype: float\n:note: If the ``Data`` contains no values a large positive value will be returned instead.")
416      .def("_integrate",&escript::Data::integrate)      .def("_integrateToTuple",&escript::Data::integrateToTuple,":return: Calculate the integral over the function space domain as a python tuple\n:rtype: tuple")
   
417      // following implements the python abs operator      // following implements the python abs operator
418      .def("__abs__",&escript::Data::abs)      .def("__abs__",&escript::Data::abs,":return: absolute value\n\n:rtype: `Data`")
419      // following implements the python "-" negation operator      // following implements the python "-" negation operator
420      .def("__neg__",&escript::Data::neg)      .def("__neg__",&escript::Data::neg, ":return: negation of the values in this object\n:rtype: `Data`")
421      // following implements the python "+" identity operator      // following implements the python "+" identity operator
422      .def("__pos__",&escript::Data::pos)      .def("__pos__",&escript::Data::pos, "\nThe unary + operator\n\n:rtype: `Data`")
423      // following two functions implement the python [] operator      // following two functions implement the python [] operator
424      .def("__getitem__",&escript::Data::getItem)      .def("__getitem__",&escript::Data::getItem,"Used by the python [] operator\n\n:rtype: `Data`")
425      .def("__setitem__",&escript::Data::setItemO)      .def("__setitem__",&escript::Data::setItemO,"Used by the python [] operator")
426      .def("__setitem__",&escript::Data::setItemD)      .def("__setitem__",&escript::Data::setItemD,"Used by the python [] operator")
427      // following two functions implement the python ** operator      // following two functions implement the python ** operator
428      .def("__pow__",&escript::Data::powO)      .def("__pow__",&escript::Data::powO,"Used by the python ** operator\n\n:rtype: `Data`")
429      .def("__pow__",&escript::Data::powD)      .def("__pow__",&escript::Data::powD)
430      .def("__rpow__",&escript::Data::rpowO)      .def("__rpow__",&escript::Data::rpowO,"\nUsed by the python ** operator\n\n:rtype: `Data`")
431      // NOTE:: The order of these declarations is important. Anything      // NOTE:: The order of these declarations is important. Anything
432      // declared before the generic declaration isn't found so the generic      // declared before the generic declaration isn't found so the generic
433      // version will be called.      // version will be called.
# Line 257  BOOST_PYTHON_MODULE(escriptcpp) Line 456  BOOST_PYTHON_MODULE(escriptcpp)
456      .def(self /= self)      .def(self /= self)
457      // Need scope resolution due to a bug either in the compiler or      // Need scope resolution due to a bug either in the compiler or
458      // the boost code. This calls operator << for Data.      // the boost code. This calls operator << for Data.
459      .def(self_ns::str(self));      .def(self_ns::str(self))
460        .def("_inverse", &escript::Data::matrixInverse, ":return: inverse of square matricies\n");
461    
462    
463    //    //
464    // Factory methods for function space    // Factory methods for function space
465    //    //
466    def("ContinuousFunction",escript::continuousFunction);    def("ContinuousFunction",escript::continuousFunction,args("domain"),
467    def("ReducedContinuousFunction",escript::reducedContinuousFunction);  ":return: a continuous FunctionSpace (overlapped node values)\n"
468    def("Function",escript::function);  ":rtype: `FunctionSpace`");
469    def("ReducedFunction",escript::reducedFunction);    def("ReducedContinuousFunction",escript::reducedContinuousFunction,args("domain"),
470    def("FunctionOnBoundary",escript::functionOnBoundary);  ":return: a continuous with reduced order FunctionSpace (overlapped node values on reduced element order)\n"
471    def("ReducedFunctionOnBoundary",escript::reducedFunctionOnBoundary);  ":rtype: `FunctionSpace`");
472    def("FunctionOnContactZero",escript::functionOnContactZero);    def("Function",escript::function,args("domain"),":return: a function `FunctionSpace`\n"
473    def("ReducedFunctionOnContactZero",escript::reducedFunctionOnContactZero);  ":rtype: `FunctionSpace`");
474    def("FunctionOnContactOne",escript::functionOnContactOne);    def("ReducedFunction",escript::reducedFunction, args("domain"),":return: a function FunctionSpace with reduced integration order\n:rtype: `FunctionSpace`");
475    def("ReducedFunctionOnContactOne",escript::reducedFunctionOnContactOne);    def("FunctionOnBoundary",escript::functionOnBoundary, args("domain"), ":return: a function on boundary FunctionSpace\n:rtype: `FunctionSpace`");
476    def("Solution",escript::solution);    def("ReducedFunctionOnBoundary",escript::reducedFunctionOnBoundary, args("domain"),
477    def("ReducedSolution",escript::reducedSolution);  ":return: a function on boundary FunctionSpace with reduced integration order\n"
478    def("DiracDeltaFunction",escript::diracDeltaFunction);  ":rtype: `FunctionSpace`");
479      def("FunctionOnContactZero",escript::functionOnContactZero, args("domain"), ":return: Return a FunctionSpace on left side of contact\n:rtype: `FunctionSpace`");
480      def("ReducedFunctionOnContactZero",escript::reducedFunctionOnContactZero, args("domain"),
481     ":return: a FunctionSpace  on left side of contact with reduced integration order\n:rtype: `FunctionSpace`");
482      def("FunctionOnContactOne",escript::functionOnContactOne, args("domain"), ":return: Return a FunctionSpace on right side of contact\n:rtype: `FunctionSpace`");
483      def("ReducedFunctionOnContactOne",escript::reducedFunctionOnContactOne, args("domain"),
484     ":return: Return a FunctionSpace on right side of contact with reduced integration order\n"
485    ":rtype: `FunctionSpace`");
486      def("Solution",escript::solution, args("domain"), ":rtype: `FunctionSpace`");
487      def("ReducedSolution",escript::reducedSolution, args("domain"), ":rtype: `FunctionSpace`");
488      def("DiracDeltaFunction",escript::diracDeltaFunction, args("domain"), ":rtype: `FunctionSpace`");
489    
490    
491    
492    
493    
494    //    //
495    // Factory methods for Data    // Factory methods for Data
496    //    //
497    def("load",escript::load);    def("load",escript::load, args("fileName","domain"), "reads Data on domain from file in netCDF format\n\n:param fileName:\n:type fileName: ``string``\n:param domain:\n:type domain: `Domain`");
498    def("loadIsConfigured",escript::loadConfigured);    def("loadIsConfigured",escript::loadConfigured,":return: True if the load function is configured.");
499    def("Scalar",escript::Scalar,    def("Scalar",escript::Scalar,
500        (arg("value")=0.0,        (arg("value")=0.0,
501         arg("what")=escript::FunctionSpace(),         arg("what")=escript::FunctionSpace(),
502         arg("expanded")=false));         arg("expanded")=false),
503    "Construct a Data object containing scalar data-points.\n\n:param value: scalar value for all points\n"
504    "\n:rtype: `Data`\n:type value: float\n:param what: FunctionSpace for Data\n:type what: `FunctionSpace`\n"
505    ":param expanded: If True, a value is stored for each point. If False, more efficient representations may be used\n"
506    ":type expanded: ``bool``");
507    def("Vector",escript::Vector,    def("Vector",escript::Vector,
508        (arg("value")=0.0,        (arg("value")=0.0,
509         arg("what")=escript::FunctionSpace(),         arg("what")=escript::FunctionSpace(),
510         arg("expanded")=false));         arg("expanded")=false),
511    "Construct a Data object containing rank1 data-points.\n\n:param value: scalar value for all points\n"
512    "\n:rtype: `Data`\n:type value: float\n:param what: FunctionSpace for Data\n:type what: `FunctionSpace`\n"
513    ":param expanded: If True, a value is stored for each point. If False, more efficient representations may be used\n"
514    ":type expanded: ``bool``");
515     def("Vector", escript::VectorFromObj,
516          (arg("value"),
517        arg("what")=escript::FunctionSpace(),
518        arg("expanded")=false));
519    def("Tensor",escript::Tensor,    def("Tensor",escript::Tensor,
520        (arg("value")=0.0,        (arg("value")=0.0,
521         arg("what")=escript::FunctionSpace(),         arg("what")=escript::FunctionSpace(),
522         arg("expanded")=false));         arg("expanded")=false),
523    "Construct a Data object containing rank2 data-points.\n\n:param value: scalar value for all points\n"
524    "\n:rtype: `Data`\n:type value: float\n:param what: FunctionSpace for Data\n:type what: `FunctionSpace`\n"
525    ":param expanded: If True, a value is stored for each point. If False, more efficient representations may be used\n"
526    ":type expanded: ``bool``");
527     def("Tensor", escript::TensorFromObj,
528          (arg("value"),
529        arg("what")=escript::FunctionSpace(),
530        arg("expanded")=false));
531    def("Tensor3",escript::Tensor3,    def("Tensor3",escript::Tensor3,
532        (arg("value")=0.0,        (arg("value")=0.0,
533         arg("what")=escript::FunctionSpace(),         arg("what")=escript::FunctionSpace(),
534         arg("expanded")=false));         arg("expanded")=false),
535    "Construct a Data object containing rank3 data-points.\n\n:param value: scalar value for all points\n"
536    "\n:rtype: `Data`\n:type value: float\n:param what: FunctionSpace for Data\n:type what: `FunctionSpace`\n"
537    ":param expanded: If True, a value is stored for each point. If False, more efficient representations may be used\n"
538    ":type expanded: ``bool``"
539    );
540     def("Tensor3", escript::Tensor3FromObj,
541          (arg("value"),
542        arg("what")=escript::FunctionSpace(),
543        arg("expanded")=false));
544    def("Tensor4",escript::Tensor4,    def("Tensor4",escript::Tensor4,
545        (arg("value")=0.0,        (arg("value")=0.0,
546         arg("what")=escript::FunctionSpace(),         arg("what")=escript::FunctionSpace(),
547         arg("expanded")=false));         arg("expanded")=false),
548    "Construct a Data object containing rank4 data-points.\n\n:param value: scalar value for all points\n"
549    "\n:rtype: `Data`\n:type value: float\n:param what: FunctionSpace for Data\n:type what: `FunctionSpace`\n"
550    ":param expanded: If True, a value is stored for each point. If False, more efficient representations may be used\n"
551    ":type expanded: ``bool``"
552    );
553     def("Tensor4", escript::Tensor4FromObj,
554          (arg("value"),
555        arg("what")=escript::FunctionSpace(),
556        arg("expanded")=false));
557    
558    //    //
559    // Binary operators    // Binary operators
560    //    //
561    def("C_GeneralTensorProduct",escript::C_GeneralTensorProduct,    def("C_GeneralTensorProduct",escript::C_GeneralTensorProduct,
562        (arg("arg0")=escript::Data(),        (arg("arg0"),
563         arg("arg1")=escript::Data(),         arg("arg1"),
564         arg("axis_offset")=0,         arg("axis_offset")=0,
565         arg("transpose")=0));         arg("transpose")=0),
566    "Compute a tensor product of two Data objects.\n\n:rtype: `Data`\n:param arg0:\n"
567    ":param arg1:\n:param axis_offset:\n:type axis_offset: ``int``\n"
568    ":param transpose: 0: transpose neither, 1: transpose arg0, 2: transpose arg1\n"
569    ":type transpose: int");
570    
571    //    //
572    // Interface for AbstractSystemMatrix    // Interface for AbstractSystemMatrix
573    //    //
574    class_<escript::AbstractSystemMatrix>("Operator",init<>())    class_<escript::AbstractSystemMatrix,escript::ASM_ptr>("Operator","",init<>())    // Doco goes in the empty string param
575       .def("isEmpty",&escript::AbstractSystemMatrix::isEmpty)       .def("isEmpty",&escript::AbstractSystemMatrix::isEmpty,":rtype: ``bool``\n"
576       .def("solve",&escript::AbstractSystemMatrix::solve)  ":return: True if matrix is empty")
577       .def("of",&escript::AbstractSystemMatrix::vectorMultiply)       .def("solve",&escript::AbstractSystemMatrix::solve, args("in","options"),
578       .def("saveMM",&escript::AbstractSystemMatrix::saveMM)  ":return: the solution *u* of the linear system *this*u=in*\n\n:param in:\n:type in: `Data`")
579       .def("saveHB",&escript::AbstractSystemMatrix::saveHB)       .def("of",&escript::AbstractSystemMatrix::vectorMultiply,args("right"),
580       .def("resetValues",&escript::AbstractSystemMatrix::resetValues)  "matrix*vector multiplication")
581         .def("saveMM",&escript::AbstractSystemMatrix::saveMM, args("fileName"),
582    "writes the matrix to a file using the Matrix Market file format")
583         .def("saveHB",&escript::AbstractSystemMatrix::saveHB, args("filename"),
584    "writes the matrix to a file using the Harwell-Boeing file format")
585         .def("resetValues",&escript::AbstractSystemMatrix::resetValues, "resets the matrix entries")
586       .def(self*other<escript::Data>());       .def(self*other<escript::Data>());
587    //    //
588    // Interface for AbstractTransportProblem    // Interface for AbstractTransportProblem
589    //    //
590    class_<escript::AbstractTransportProblem>("TransportProblem",init<>())    class_<escript::AbstractTransportProblem, escript::ATP_ptr>("TransportProblem","",init<>())    // Doco goes in the empty string param
591       .def("isEmpty",&escript::AbstractTransportProblem::isEmpty)       .def("isEmpty",&escript::AbstractTransportProblem::isEmpty,":rtype: ``int``")
592       .def("solve",&escript::AbstractTransportProblem::solve)       .def("solve",&escript::AbstractTransportProblem::solve, args("u0","source","dt", "options"),
593       .def("setInitialValue",&escript::AbstractTransportProblem::setInitialValue)  "returns the solution *u* for a time step *dt>0* with initial value u0\n\n:rtype: `Data`\n"
594       .def("insertConstraint",&escript::AbstractTransportProblem::insertConstraint)  ":param source:\n:type source: `Data`")
595       .def("reset",&escript::AbstractTransportProblem::resetTransport)       .def("insertConstraint",&escript::AbstractTransportProblem::insertConstraint,
596       .def("getSafeTimeStepSize",&escript::AbstractTransportProblem::getSafeTimeStepSize);  args("source", "q", "r","factor"),
597    "inserts constraint *u_{,t}=r* where *q>0*  into the problem using a weighting factor")
598         .def("reset",&escript::AbstractTransportProblem::resetTransport,
599    "resets the transport operator typically as they have been updated.")
600         .def("resetValues",&escript::AbstractTransportProblem::resetTransport)
601         .def("getSafeTimeStepSize",&escript::AbstractTransportProblem::getSafeTimeStepSize)
602         .def("getUnlimitedTimeStepSize",&escript::AbstractTransportProblem::getUnlimitedTimeStepSize);
603    
604      // Functions to modify global parameters
605      def("setEscriptParamInt",escript::setEscriptParamInt,
606          (arg("name"), arg("value")=0), "Modify the value of an escript tuning parameter\n\n"
607    ":param name:\n:type name: ``string``\n:param value:\n:type value: ``int``");
608      def("getEscriptParamInt",escript::getEscriptParamInt,
609          (arg("name"),arg("sentinel")=0), "Read the value of an escript tuning paramter\n\n"
610    ":param name: parameter to lookup\n:type name: ``string``\n:param sentinel: Value to be returned if ``name`` is not a known parameter\n"
611    ":type sentinel: ``int``");
612      def("listEscriptParams",escript::listEscriptParams,":return: A list of pairs (p,d) where p is the name of a parameter for escript and d is a description.");
613    
614    
615      def("resolveGroup", escript::resolveGroup);
616    
617    #ifdef IKNOWWHATIMDOING
618    
619      def("applyBinaryCFunction", escript::applyBinaryCFunction, (arg("function"), arg("outshape"),
620    arg("in1"),
621    arg("in2"))
622    );
623    #endif
624    
625      def("_condEval", escript::condEval, (arg("mask"), arg("trueval"), arg("falseval")));
626    
627    //    //
628    // Register esysExceptionTranslator    // Register esysExceptionTranslator
629    //    //
630    register_exception_translator<esysUtils::EsysException>(&esysUtils::esysExceptionTranslator);    register_exception_translator<esysUtils::EsysException>(&esysUtils::esysExceptionTranslator);
   
631  }  }

Legend:
Removed from v.1796  
changed lines
  Added in v.3360

  ViewVC Help
Powered by ViewVC 1.1.26