escript/src/escriptcpp.cpp

//$Id$
/*
 ************************************************************
 *          Copyright 2006 by ACcESS MNRF                   *
 *                                                          *
 *              http://www.access.edu.au                    *
 *       Primary Business: Queensland, Australia            *
 *  Licensed under the Open Software License version 3.0    *
 *     http://www.opensource.org/licenses/osl-3.0.php       *
 *                                                          *
 ************************************************************
*/

#include "Data.h"
#include "FunctionSpace.h"
#include "FunctionSpaceFactory.h"
#include "DataFactory.h"
#include "AbstractContinuousDomain.h"
#include "AbstractDomain.h"
#include "Utils.h"
#include "AbstractSystemMatrix.h"
#include "DataVector.h"

#include "esysUtils/esysExceptionTranslator.h"

#include <boost/python.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/object.hpp>
#include <boost/python/tuple.hpp>
#include <boost/python/numeric.hpp>

using namespace boost::python;

/*! \mainpage Esys Documentation
 *
 * \version 1.0.0
 *
 * - \ref escript
 *
 * - \ref esys_exception "Esys Exception"
 *
 * - \ref finley
 *
 * - <a href=http://iservo.edu.au/esys/epydoc/index.html>Python module documentation (epydoc generated)</a>
 *
 */

/*! \page escript Escript
 * Escript is the python module that contains the interfaces
 * to the C++ side of escript.
 *
 * \version 1.0.0 
 *
 * \section class_desc Class Description:
 * Data
 *
 * \section class_limits Class Limitations:
 * None
 *
 * \section class_conds Class Conditions of Use:
 * None
 *
 * \section class_throws Throws:
 * None
 *
 */

BOOST_PYTHON_MODULE(escriptcpp)
{
  def("setNumberOfThreads",escript::setNumberOfThreads);
  def("getNumberOfThreads",escript::getNumberOfThreads);
  def("releaseUnusedMemory",escript::releaseUnusedMemory);


  //
  // Interface for AbstractDomain
  //
  class_<escript::AbstractDomain>("Domain",no_init)
     .def("getX",&escript::AbstractDomain::getX)
     .def("getNormal",&escript::AbstractDomain::getNormal)
     .def("getSize",&escript::AbstractDomain::getSize)
     .def("saveVTK",&escript::AbstractDomain::saveVTK)
     .def("saveDX",&escript::AbstractDomain::saveDX)
     .def(self == self)
     .def(self != self);

  //
  // Interface for AbstractContinuousDomain
  //
  class_<escript::AbstractContinuousDomain, bases<escript::AbstractDomain> >("ContinuousDomain",no_init)
       .def("getSystemMatrixTypeId",&escript::AbstractContinuousDomain::getSystemMatrixTypeId);

  //
  // Interface for FunctionSpace
  //
  class_<escript::FunctionSpace>("FunctionSpace",init<>())
     .def("getDim",&escript::FunctionSpace::getDim)
     .def("getDomain",&escript::FunctionSpace::getDomain,return_internal_reference<>())
     .def("getX",&escript::FunctionSpace::getX)
     .def("getNormal",&escript::FunctionSpace::getNormal)
     .def("getSize",&escript::FunctionSpace::getSize)
     .def("setTags",&escript::FunctionSpace::setTags)
     .def("getTagFromDataPointNo",&escript::FunctionSpace::getTagFromDataPointNo)
     .def("__str__",&escript::FunctionSpace::toString)
     .def(self == self)
     .def(self != self);
  //
  // Interface for Data
  //
  class_<escript::Data>("Data","TEST DOCUMENTATION",init<>())
    // various constructors for Data objects
    .def(init<const numeric::array&, optional<const escript::FunctionSpace&, bool> >(args("value","what","expand")))
    .def(init<const object&, optional<const escript::FunctionSpace&, bool> >(args("value","what","expand")))
    .def(init<const double, const tuple&, optional<const escript::FunctionSpace&, bool> >(args("value","shape","what","expand")))
    .def(init<const escript::Data&, const escript::FunctionSpace&>(args("value","what")))
    .def(init<const escript::Data&>())
    // Note for Lutz, Need to specify the call policy in order to return a
    // reference. In this case return_internal_reference.
    .def("__str__",&escript::Data::toString)
    .def("getDomain",&escript::Data::getDomain,return_internal_reference<>())
    .def("getFunctionSpace",&escript::Data::getFunctionSpace,return_internal_reference<>())
    .def("isEmpty",&escript::Data::isEmpty)
    .def("isProtected",&escript::Data::isProtected)
    .def("setProtection",&escript::Data::setProtection)
    .def("getShape",&escript::Data::getShapeTuple)
    .def("getRank",&escript::Data::getDataPointRank)
    .def("copyWithMask",&escript::Data::copyWithMask)
    .def("setTaggedValue",&escript::Data::setTaggedValue)
    .def("setRefValue",&escript::Data::setRefValue)
    .def("getRefValue",&escript::Data::getRefValue)
    .def("expand",&escript::Data::expand)
    .def("tag",&escript::Data::tag)
    .def("copy",&escript::Data::copy)
    .def("convertToNumArray",&escript::Data::convertToNumArray)
    .def("convertToNumArrayFromSampleNo",&escript::Data::convertToNumArrayFromSampleNo)
    .def("convertToNumArrayFromDPNo",&escript::Data::convertToNumArrayFromDPNo)
    .def("fillFromNumArray",&escript::Data::fillFromNumArray)
    .def("interpolate",&escript::Data::interpolate)
    .def("mindp",&escript::Data::mindp)
    .def("saveDX",&escript::Data::saveDX)
    .def("saveVTK",&escript::Data::saveVTK)
    .def("getTagNumber",&escript::Data::getTagNumber)
    .def("archiveData",&escript::Data::archiveData)
    .def("extractData",&escript::Data::extractData)
    // Unary functions for Data
    .def("_interpolate",&escript::Data::interpolate)
    .def("_grad",&escript::Data::gradOn)
    .def("_grad",&escript::Data::grad)
    .def("_transpose",&escript::Data::transpose)
    .def("_trace",&escript::Data::trace)
    .def("_maxval",&escript::Data::maxval)
    .def("_minval",&escript::Data::minval)
    .def("_wherePositive",&escript::Data::wherePositive)
    .def("_whereNegative",&escript::Data::whereNegative)
    .def("_whereNonNegative",&escript::Data::whereNonNegative)
    .def("_whereNonPositive",&escript::Data::whereNonPositive)
    .def("_whereZero",&escript::Data::whereZero,(arg("tol")=0.0))
    .def("_whereNonZero",&escript::Data::whereNonZero,(arg("tol")=0.0))
    .def("_sin",&escript::Data::sin)
    .def("_cos",&escript::Data::cos)
    .def("_tan",&escript::Data::tan)
    .def("_asin",&escript::Data::asin)
    .def("_acos",&escript::Data::acos)
    .def("_atan",&escript::Data::atan)
    .def("_sinh",&escript::Data::sinh)
    .def("_cosh",&escript::Data::cosh)
    .def("_tanh",&escript::Data::tanh)
    .def("_asinh",&escript::Data::asinh)
    .def("_acosh",&escript::Data::acosh)
    .def("_atanh",&escript::Data::atanh)
    .def("_exp",&escript::Data::exp)
    .def("_sqrt",&escript::Data::sqrt)
    .def("_log10",&escript::Data::log10)
    .def("_log",&escript::Data::log)
    .def("_sign",&escript::Data::sign)
    .def("_symmetric",&escript::Data::symmetric)
    .def("_nonsymmetric",&escript::Data::nonsymmetric)
    .def("_trace",&escript::Data::trace)
    .def("_swap_axes",&escript::Data::swapaxes)
    .def("_eigenvalues",&escript::Data::eigenvalues)
    .def("_eigenvalues_and_eigenvectors",&escript::Data::eigenvalues_and_eigenvectors,(arg("tol")=1.e-13))
    // functions returning a single real number:
    .def("_Lsup",&escript::Data::Lsup)
    .def("_sup",&escript::Data::sup)
    .def("_inf",&escript::Data::inf)
    .def("_integrate",&escript::Data::integrate)

    // following implements the python abs operator
    .def("__abs__",&escript::Data::abs)
    // following implements the python "-" negation operator
    .def("__neg__",&escript::Data::neg)
    // following implements the python "+" identity operator
    .def("__pos__",&escript::Data::pos)
    // following two functions implement the python [] operator
    .def("__getitem__",&escript::Data::getItem)
    .def("__setitem__",&escript::Data::setItemO)
    .def("__setitem__",&escript::Data::setItemD)
    // following two functions implement the python ** operator
    .def("__pow__",&escript::Data::powO)
    .def("__pow__",&escript::Data::powD)
    .def("__rpow__",&escript::Data::rpowO)
    // NOTE:: The order of these declarations is important. Anything
    // declared before the generic declaration isn't found so the generic
    // version will be called. 
    .def(self + other<object>())
    .def(other<object>() + self)
    .def(self + self)
    .def(self += other<object>())
    .def(self += self)

    .def(self - other<object>())
    .def(other<object>() - self)
    .def(self - self)
    .def(self -= other<object>())
    .def(self -= self)

    .def(self * other<object>())
    .def(other<object>() * self)
    .def(self * self)
    .def(self *= other<object>())
    .def(self *= self)

    .def(self / other<object>())
    .def(other<object>() / self)
    .def(self / self)
    .def(self /= other<object>())
    .def(self /= self)
    // Need scope resolution due to a bug either in the compiler or
    // the boost code. This calls operator << for Data.
    .def(self_ns::str(self));

  //
  // Factory methods for function space
  //
  def("ContinuousFunction",escript::continuousFunction);
  def("Function",escript::function);
  def("FunctionOnBoundary",escript::functionOnBoundary);
  def("FunctionOnContactZero",escript::functionOnContactZero);
  def("FunctionOnContactOne",escript::functionOnContactOne);
  def("Solution",escript::solution);
  def("ReducedSolution",escript::reducedSolution);
  def("DiracDeltaFunction",escript::diracDeltaFunction);

  //
  // Factory methods for Data
  //
  def("Scalar",escript::Scalar,
      (arg("value")=0.0,
       arg("what")=escript::FunctionSpace(),
       arg("expanded")=false));
  def("Vector",escript::Vector,
      (arg("value")=0.0,
       arg("what")=escript::FunctionSpace(),
       arg("expanded")=false));
  def("Tensor",escript::Tensor,
      (arg("value")=0.0,
       arg("what")=escript::FunctionSpace(),
       arg("expanded")=false));
  def("Tensor3",escript::Tensor3,
      (arg("value")=0.0,
       arg("what")=escript::FunctionSpace(),
       arg("expanded")=false));
  def("Tensor4",escript::Tensor4,
      (arg("value")=0.0,
       arg("what")=escript::FunctionSpace(),
       arg("expanded")=false));

  //
  // Binary operators
  //
  def("C_GeneralTensorProduct",escript::C_GeneralTensorProduct,
      (arg("arg0")=escript::Data(),
       arg("arg1")=escript::Data(),
       arg("axis_offset")=0,
       arg("transpose")=0));

  //
  // Interface for AbstractSystemMatrix
  //
  class_<escript::AbstractSystemMatrix>("Operator",init<>())
     .def("isEmpty",&escript::AbstractSystemMatrix::isEmpty)
     .def("solve",&escript::AbstractSystemMatrix::solve)
     .def("of",&escript::AbstractSystemMatrix::vectorMultiply)
     .def("saveMM",&escript::AbstractSystemMatrix::saveMM)
     .def("saveHB",&escript::AbstractSystemMatrix::saveHB)
     .def("resetValues",&escript::AbstractSystemMatrix::resetValues)
     .def(self*other<escript::Data>());

  //
  // Register esysExceptionTranslator
  //
  register_exception_translator<esysUtils::EsysException>(&esysUtils::esysExceptionTranslator);

}
1	//$Id$
2	/*
3	************************************************************
4	* Copyright 2006 by ACcESS MNRF *
5	* *
6	* http://www.access.edu.au *
7	* Primary Business: Queensland, Australia *
8	* Licensed under the Open Software License version 3.0 *
9	* http://www.opensource.org/licenses/osl-3.0.php *
10	* *
11	************************************************************
12	*/
13
14	#include "Data.h"
15	#include "FunctionSpace.h"
16	#include "FunctionSpaceFactory.h"
17	#include "DataFactory.h"
18	#include "AbstractContinuousDomain.h"
19	#include "AbstractDomain.h"
20	#include "Utils.h"
21	#include "AbstractSystemMatrix.h"
22	#include "DataVector.h"
23
24	#include "esysUtils/esysExceptionTranslator.h"
25
26	#include <boost/python.hpp>
27	#include <boost/python/module.hpp>
28	#include <boost/python/def.hpp>
29	#include <boost/python/object.hpp>
30	#include <boost/python/tuple.hpp>
31	#include <boost/python/numeric.hpp>
32
33	using namespace boost::python;
34
35	/*! \mainpage Esys Documentation
36	*
37	* \version 1.0.0
38	*
39	* - \ref escript
40	*
41	* - \ref esys_exception "Esys Exception"
42	*
43	* - \ref finley
44	*
45	* - <a href=http://iservo.edu.au/esys/epydoc/index.html>Python module documentation (epydoc generated)</a>
46	*
47	*/
48
49	/*! \page escript Escript
50	* Escript is the python module that contains the interfaces
51	* to the C++ side of escript.
52	*
53	* \version 1.0.0
54	*
55	* \section class_desc Class Description:
56	* Data
57	*
58	* \section class_limits Class Limitations:
59	* None
60	*
61	* \section class_conds Class Conditions of Use:
62	* None
63	*
64	* \section class_throws Throws:
65	* None
66	*
67	*/
68
69	BOOST_PYTHON_MODULE(escriptcpp)
70	{
71	def("setNumberOfThreads",escript::setNumberOfThreads);
72	def("getNumberOfThreads",escript::getNumberOfThreads);
73	def("releaseUnusedMemory",escript::releaseUnusedMemory);
74
75
76	//
77	// Interface for AbstractDomain
78	//
79	class_<escript::AbstractDomain>("Domain",no_init)
80	.def("getX",&escript::AbstractDomain::getX)
81	.def("getNormal",&escript::AbstractDomain::getNormal)
82	.def("getSize",&escript::AbstractDomain::getSize)
83	.def("saveVTK",&escript::AbstractDomain::saveVTK)
84	.def("saveDX",&escript::AbstractDomain::saveDX)
85	.def(self == self)
86	.def(self != self);
87
88	//
89	// Interface for AbstractContinuousDomain
90	//
91	class_<escript::AbstractContinuousDomain, bases<escript::AbstractDomain> >("ContinuousDomain",no_init)
92	.def("getSystemMatrixTypeId",&escript::AbstractContinuousDomain::getSystemMatrixTypeId);
93
94	//
95	// Interface for FunctionSpace
96	//
97	class_<escript::FunctionSpace>("FunctionSpace",init<>())
98	.def("getDim",&escript::FunctionSpace::getDim)
99	.def("getDomain",&escript::FunctionSpace::getDomain,return_internal_reference<>())
100	.def("getX",&escript::FunctionSpace::getX)
101	.def("getNormal",&escript::FunctionSpace::getNormal)
102	.def("getSize",&escript::FunctionSpace::getSize)
103	.def("setTags",&escript::FunctionSpace::setTags)
104	.def("getTagFromDataPointNo",&escript::FunctionSpace::getTagFromDataPointNo)
105	.def("__str__",&escript::FunctionSpace::toString)
106	.def(self == self)
107	.def(self != self);
108	//
109	// Interface for Data
110	//
111	class_<escript::Data>("Data","TEST DOCUMENTATION",init<>())
112	// various constructors for Data objects
113	.def(init<const numeric::array&, optional<const escript::FunctionSpace&, bool> >(args("value","what","expand")))
114	.def(init<const object&, optional<const escript::FunctionSpace&, bool> >(args("value","what","expand")))
115	.def(init<const double, const tuple&, optional<const escript::FunctionSpace&, bool> >(args("value","shape","what","expand")))
116	.def(init<const escript::Data&, const escript::FunctionSpace&>(args("value","what")))
117	.def(init<const escript::Data&>())
118	// Note for Lutz, Need to specify the call policy in order to return a
119	// reference. In this case return_internal_reference.
120	.def("__str__",&escript::Data::toString)
121	.def("getDomain",&escript::Data::getDomain,return_internal_reference<>())
122	.def("getFunctionSpace",&escript::Data::getFunctionSpace,return_internal_reference<>())
123	.def("isEmpty",&escript::Data::isEmpty)
124	.def("isProtected",&escript::Data::isProtected)
125	.def("setProtection",&escript::Data::setProtection)
126	.def("getShape",&escript::Data::getShapeTuple)
127	.def("getRank",&escript::Data::getDataPointRank)
128	.def("copyWithMask",&escript::Data::copyWithMask)
129	.def("setTaggedValue",&escript::Data::setTaggedValue)
130	.def("setRefValue",&escript::Data::setRefValue)
131	.def("getRefValue",&escript::Data::getRefValue)
132	.def("expand",&escript::Data::expand)
133	.def("tag",&escript::Data::tag)
134	.def("copy",&escript::Data::copy)
135	.def("convertToNumArray",&escript::Data::convertToNumArray)
136	.def("convertToNumArrayFromSampleNo",&escript::Data::convertToNumArrayFromSampleNo)
137	.def("convertToNumArrayFromDPNo",&escript::Data::convertToNumArrayFromDPNo)
138	.def("fillFromNumArray",&escript::Data::fillFromNumArray)
139	.def("interpolate",&escript::Data::interpolate)
140	.def("mindp",&escript::Data::mindp)
141	.def("saveDX",&escript::Data::saveDX)
142	.def("saveVTK",&escript::Data::saveVTK)
143	.def("getTagNumber",&escript::Data::getTagNumber)
144	.def("archiveData",&escript::Data::archiveData)
145	.def("extractData",&escript::Data::extractData)
146	// Unary functions for Data
147	.def("_interpolate",&escript::Data::interpolate)
148	.def("_grad",&escript::Data::gradOn)
149	.def("_grad",&escript::Data::grad)
150	.def("_transpose",&escript::Data::transpose)
151	.def("_trace",&escript::Data::trace)
152	.def("_maxval",&escript::Data::maxval)
153	.def("_minval",&escript::Data::minval)
154	.def("_wherePositive",&escript::Data::wherePositive)
155	.def("_whereNegative",&escript::Data::whereNegative)
156	.def("_whereNonNegative",&escript::Data::whereNonNegative)
157	.def("_whereNonPositive",&escript::Data::whereNonPositive)
158	.def("_whereZero",&escript::Data::whereZero,(arg("tol")=0.0))
159	.def("_whereNonZero",&escript::Data::whereNonZero,(arg("tol")=0.0))
160	.def("_sin",&escript::Data::sin)
161	.def("_cos",&escript::Data::cos)
162	.def("_tan",&escript::Data::tan)
163	.def("_asin",&escript::Data::asin)
164	.def("_acos",&escript::Data::acos)
165	.def("_atan",&escript::Data::atan)
166	.def("_sinh",&escript::Data::sinh)
167	.def("_cosh",&escript::Data::cosh)
168	.def("_tanh",&escript::Data::tanh)
169	.def("_asinh",&escript::Data::asinh)
170	.def("_acosh",&escript::Data::acosh)
171	.def("_atanh",&escript::Data::atanh)
172	.def("_exp",&escript::Data::exp)
173	.def("_sqrt",&escript::Data::sqrt)
174	.def("_log10",&escript::Data::log10)
175	.def("_log",&escript::Data::log)
176	.def("_sign",&escript::Data::sign)
177	.def("_symmetric",&escript::Data::symmetric)
178	.def("_nonsymmetric",&escript::Data::nonsymmetric)
179	.def("_trace",&escript::Data::trace)
180	.def("_swap_axes",&escript::Data::swapaxes)
181	.def("_eigenvalues",&escript::Data::eigenvalues)
182	.def("_eigenvalues_and_eigenvectors",&escript::Data::eigenvalues_and_eigenvectors,(arg("tol")=1.e-13))
183	// functions returning a single real number:
184	.def("_Lsup",&escript::Data::Lsup)
185	.def("_sup",&escript::Data::sup)
186	.def("_inf",&escript::Data::inf)
187	.def("_integrate",&escript::Data::integrate)
188
189	// following implements the python abs operator
190	.def("__abs__",&escript::Data::abs)
191	// following implements the python "-" negation operator
192	.def("__neg__",&escript::Data::neg)
193	// following implements the python "+" identity operator
194	.def("__pos__",&escript::Data::pos)
195	// following two functions implement the python [] operator
196	.def("__getitem__",&escript::Data::getItem)
197	.def("__setitem__",&escript::Data::setItemO)
198	.def("__setitem__",&escript::Data::setItemD)
199	// following two functions implement the python ** operator
200	.def("__pow__",&escript::Data::powO)
201	.def("__pow__",&escript::Data::powD)
202	.def("__rpow__",&escript::Data::rpowO)
203	// NOTE:: The order of these declarations is important. Anything
204	// declared before the generic declaration isn't found so the generic
205	// version will be called.
206	.def(self + other<object>())
207	.def(other<object>() + self)
208	.def(self + self)
209	.def(self += other<object>())
210	.def(self += self)
211
212	.def(self - other<object>())
213	.def(other<object>() - self)
214	.def(self - self)
215	.def(self -= other<object>())
216	.def(self -= self)
217
218	.def(self * other<object>())
219	.def(other<object>() * self)
220	.def(self * self)
221	.def(self *= other<object>())
222	.def(self *= self)
223
224	.def(self / other<object>())
225	.def(other<object>() / self)
226	.def(self / self)
227	.def(self /= other<object>())
228	.def(self /= self)
229	// Need scope resolution due to a bug either in the compiler or
230	// the boost code. This calls operator << for Data.
231	.def(self_ns::str(self));
232
233	//
234	// Factory methods for function space
235	//
236	def("ContinuousFunction",escript::continuousFunction);
237	def("Function",escript::function);
238	def("FunctionOnBoundary",escript::functionOnBoundary);
239	def("FunctionOnContactZero",escript::functionOnContactZero);
240	def("FunctionOnContactOne",escript::functionOnContactOne);
241	def("Solution",escript::solution);
242	def("ReducedSolution",escript::reducedSolution);
243	def("DiracDeltaFunction",escript::diracDeltaFunction);
244
245	//
246	// Factory methods for Data
247	//
248	def("Scalar",escript::Scalar,
249	(arg("value")=0.0,
250	arg("what")=escript::FunctionSpace(),
251	arg("expanded")=false));
252	def("Vector",escript::Vector,
253	(arg("value")=0.0,
254	arg("what")=escript::FunctionSpace(),
255	arg("expanded")=false));
256	def("Tensor",escript::Tensor,
257	(arg("value")=0.0,
258	arg("what")=escript::FunctionSpace(),
259	arg("expanded")=false));
260	def("Tensor3",escript::Tensor3,
261	(arg("value")=0.0,
262	arg("what")=escript::FunctionSpace(),
263	arg("expanded")=false));
264	def("Tensor4",escript::Tensor4,
265	(arg("value")=0.0,
266	arg("what")=escript::FunctionSpace(),
267	arg("expanded")=false));
268
269	//
270	// Binary operators
271	//
272	def("C_GeneralTensorProduct",escript::C_GeneralTensorProduct,
273	(arg("arg0")=escript::Data(),
274	arg("arg1")=escript::Data(),
275	arg("axis_offset")=0,
276	arg("transpose")=0));
277
278	//
279	// Interface for AbstractSystemMatrix
280	//
281	class_<escript::AbstractSystemMatrix>("Operator",init<>())
282	.def("isEmpty",&escript::AbstractSystemMatrix::isEmpty)
283	.def("solve",&escript::AbstractSystemMatrix::solve)
284	.def("of",&escript::AbstractSystemMatrix::vectorMultiply)
285	.def("saveMM",&escript::AbstractSystemMatrix::saveMM)
286	.def("saveHB",&escript::AbstractSystemMatrix::saveHB)
287	.def("resetValues",&escript::AbstractSystemMatrix::resetValues)
288	.def(self*other<escript::Data>());
289
290	//
291	// Register esysExceptionTranslator
292	//
293	register_exception_translator<esysUtils::EsysException>(&esysUtils::esysExceptionTranslator);
294
295	}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision