src/CPPAdapter/finleycpp.cpp

// $Id$
/*
 ******************************************************************************
 *                                                                            *
 *       COPYRIGHT ACcESS 2004 -  All Rights Reserved                         *
 *                                                                            *
 * This software is the property of ACcESS.  No part of this code             *
 * may be copied in any form or by any means without the expressed written    *
 * consent of ACcESS.  Copying, use or modification of this software          *
 * by any unauthorised person is illegal unless that                          *
 * person has a software license agreement with ACcESS.                       *
 *                                                                            *
 ******************************************************************************
 
******************************************************************************/

extern "C" {
#include "../Finley.h"
}

#include "MeshAdapter.h"
#include "MeshAdapterFactory.h"
#include "SystemMatrixAdapter.h"

#include "esysUtils/EsysException.h"
#include "esysUtils/esysExceptionTranslator.h"

#include "escriptcpp/AbstractContinuousDomain.h"

#include <boost/python.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/detail/defaults_gen.hpp>

using namespace boost::python;

/**
   \page finley Finley
   Finley is the python module name that contains the interfaces
   to the C++ wrapper to finley.

   \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 throws Throws:
   None

*/

//
// The BOOST_PYTHON_FUNCTION_OVERLOADS macro generates function overloads for optional
// arguments to the respective finley functions.
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
// NOTE: If the number of arguments to the finley functions change
// the magic numbers in the BOOST_PYTHON_FUNCTION_OVERLOADS call 
// must change.
//
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// BOOST_PYTHON_FUNCTION_OVERLOADS(readMesh_overloads,finley::readMesh,1,2)
// BOOST_PYTHON_FUNCTION_OVERLOADS(brick_overloads,finley::brick,0,12)
// BOOST_PYTHON_FUNCTION_OVERLOADS(rectangle_overloads,finley::rectangle,0,9)
// BOOST_PYTHON_FUNCTION_OVERLOADS(interval_overloads,finley::interval,0,6)
// BOOST_PYTHON_FUNCTION_OVERLOADS(glueFaces_overloads,finley::glueFaces,1,3)
// BOOST_PYTHON_FUNCTION_OVERLOADS(joinFaces_overloads,finley::joinFaces,1,3)

BOOST_PYTHON_MODULE(finleycpp)
{

  // def("ReadMesh",finley::readMesh,readMesh_overloads());
  // def("Brick",finley::brick,brick_overloads());
  // def("Rectangle",finley::rectangle,rectangle_overloads());
  // def("Interval",finley::interval,interval_overloads());
  // def("GlueFaces",finley::glueFaces,glueFaces_overloads());
  // def("JoinFaces",finley::joinFaces,joinFaces_overloads());
  //
  // NOTE: The return_value_policy is necessary for functions that
  // return pointers.

  def("ReadMesh",finley::readMesh,
      (arg("fileName"),arg("integrationOrder")=-1),
      return_value_policy<manage_new_object>());

  def ("Brick",finley::brick,
      (arg("n0")=1,arg("n1")=1,arg("n2")=1,
      arg("order")=1,
      arg("l0")=1.0,arg("l1")=1.0,arg("l2")=1.0,
      arg("periodic0")=false,arg("periodic1")=false,arg("periodic2")=false,
      arg("integrationOrder")=-1,
      arg("useElementsOnFace")=false),
      return_value_policy<manage_new_object>());

  def ("Rectangle",finley::rectangle,
      (arg("n0")=1,arg("n1")=1,arg("order")=1,
      arg("l0")=1.0,arg("l1")=1.0,
      arg("periodic0")=false,arg("periodic1")=false,
      arg("integrationOrder")=-1,
      arg("useElementsOnFace")=false),
      return_value_policy<manage_new_object>());

  def("Interval",finley::interval,
      (arg("n1")=1,arg("order")=1,
      arg("l1")=1.0,arg("periodic0")=false,
      arg("integrationOrder")=-1,
      arg("useElementsOnFace")=false),
      return_value_policy<manage_new_object>());

  def("Merge",finley::meshMerge,
      return_value_policy<manage_new_object>());

  def("GlueFaces",finley::glueFaces,
      (arg("safetyFactor")=0.2,
      arg("tolerance")=std::numeric_limits<double>::epsilon()),
      return_value_policy<manage_new_object>());

  def("JoinFaces",finley::joinFaces,
      (arg("safetyFactor")=0.2,
      arg("tolerance")=std::numeric_limits<double>::epsilon()),
      return_value_policy<manage_new_object>());

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

  class_<finley::MeshAdapter, bases<escript::AbstractContinuousDomain> >
      ("MeshAdapter",init<optional <Finley_Mesh*> >())
      .def(init<const finley::MeshAdapter&>())
      .def("write",&finley::MeshAdapter::write)
      .def("getDescription",&finley::MeshAdapter::getDescription)
      .def("getDim",&finley::MeshAdapter::getDim)
      .def("getDataShape",&finley::MeshAdapter::getDataShape)
      .def("addPDEToSystem",&finley::MeshAdapter::addPDEToSystem)
      .def("addPDEToRHS",&finley::MeshAdapter::addPDEToRHS)
      .def("newOperator",&finley::MeshAdapter::newSystemMatrix)
      .def("getSystemMatrixTypeId",&finley::MeshAdapter::getSystemMatrixTypeId)
      .def("setX",&finley::MeshAdapter::setNewX)
      .def("getX",&finley::MeshAdapter::getX)
      .def("getNormal",&finley::MeshAdapter::getNormal)
      .def("getSize",&finley::MeshAdapter::getSize)
      .def("saveDX",&finley::MeshAdapter::saveDX)
      .def("saveVTK",&finley::MeshAdapter::saveVTK);


  class_<finley::SystemMatrixAdapter, bases<escript::AbstractSystemMatrix> >
      ("OperatorAdapter",no_init)
      .def("nullifyRowsAndCols",&finley::SystemMatrixAdapter::nullifyRowsAndCols)
      .def("resetValues",&finley::SystemMatrixAdapter::resetValues)
      .def("saveMM",&finley::SystemMatrixAdapter::saveMM)
      .def("saveHB",&finley::SystemMatrixAdapter::saveHB);

}
1	jgs	102	// $Id$
2			/*
3			******************************************************************************
4			* *
5			* COPYRIGHT ACcESS 2004 - All Rights Reserved *
6			* *
7			* This software is the property of ACcESS. No part of this code *
8			* may be copied in any form or by any means without the expressed written *
9			* consent of ACcESS. Copying, use or modification of this software *
10			* by any unauthorised person is illegal unless that *
11			* person has a software license agreement with ACcESS. *
12			* *
13			******************************************************************************
14
15			******************************************************************************/
16
17			extern "C" {
18	robwdcock	624	#include "../Finley.h"
19	jgs	102	}
20	jgs	472
21	jgs	203	#include "MeshAdapter.h"
22			#include "MeshAdapterFactory.h"
23			#include "SystemMatrixAdapter.h"
24	jgs	102
25	robwdcock	624	#include "esysUtils/EsysException.h"
26			#include "esysUtils/esysExceptionTranslator.h"
27	jgs	102
28	robwdcock	624	#include "escriptcpp/AbstractContinuousDomain.h"
29	jgs	102
30			#include <boost/python.hpp>
31			#include <boost/python/module.hpp>
32			#include <boost/python/def.hpp>
33			#include <boost/python/detail/defaults_gen.hpp>
34
35			using namespace boost::python;
36
37			/**
38	jgs	121	\page finley Finley
39			Finley is the python module name that contains the interfaces
40	jgs	102	to the C++ wrapper to finley.
41
42	jgs	121	\version 1.0.0
43	jgs	102
44	jgs	121	\section class_desc Class Description:
45	jgs	102	Data
46
47	jgs	121	\section class_limits Class Limitations:
48	jgs	102	None
49
50	jgs	121	\section class_conds Class Conditions of Use:
51	jgs	102	None
52
53	jgs	121	\section throws Throws:
54	jgs	102	None
55
56			*/
57
58			//
59			// The BOOST_PYTHON_FUNCTION_OVERLOADS macro generates function overloads for optional
60			// arguments to the respective finley functions.
61			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
62			//
63			// NOTE: If the number of arguments to the finley functions change
64			// the magic numbers in the BOOST_PYTHON_FUNCTION_OVERLOADS call
65			// must change.
66			//
67			// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
68			// BOOST_PYTHON_FUNCTION_OVERLOADS(readMesh_overloads,finley::readMesh,1,2)
69			// BOOST_PYTHON_FUNCTION_OVERLOADS(brick_overloads,finley::brick,0,12)
70			// BOOST_PYTHON_FUNCTION_OVERLOADS(rectangle_overloads,finley::rectangle,0,9)
71			// BOOST_PYTHON_FUNCTION_OVERLOADS(interval_overloads,finley::interval,0,6)
72			// BOOST_PYTHON_FUNCTION_OVERLOADS(glueFaces_overloads,finley::glueFaces,1,3)
73			// BOOST_PYTHON_FUNCTION_OVERLOADS(joinFaces_overloads,finley::joinFaces,1,3)
74
75			BOOST_PYTHON_MODULE(finleycpp)
76			{
77
78			// def("ReadMesh",finley::readMesh,readMesh_overloads());
79			// def("Brick",finley::brick,brick_overloads());
80			// def("Rectangle",finley::rectangle,rectangle_overloads());
81			// def("Interval",finley::interval,interval_overloads());
82			// def("GlueFaces",finley::glueFaces,glueFaces_overloads());
83			// def("JoinFaces",finley::joinFaces,joinFaces_overloads());
84			//
85			// NOTE: The return_value_policy is necessary for functions that
86			// return pointers.
87
88			def("ReadMesh",finley::readMesh,
89			(arg("fileName"),arg("integrationOrder")=-1),
90			return_value_policy<manage_new_object>());
91
92			def ("Brick",finley::brick,
93			(arg("n0")=1,arg("n1")=1,arg("n2")=1,
94			arg("order")=1,
95			arg("l0")=1.0,arg("l1")=1.0,arg("l2")=1.0,
96			arg("periodic0")=false,arg("periodic1")=false,arg("periodic2")=false,
97			arg("integrationOrder")=-1,
98			arg("useElementsOnFace")=false),
99			return_value_policy<manage_new_object>());
100
101			def ("Rectangle",finley::rectangle,
102			(arg("n0")=1,arg("n1")=1,arg("order")=1,
103			arg("l0")=1.0,arg("l1")=1.0,
104			arg("periodic0")=false,arg("periodic1")=false,
105			arg("integrationOrder")=-1,
106			arg("useElementsOnFace")=false),
107			return_value_policy<manage_new_object>());
108
109			def("Interval",finley::interval,
110			(arg("n1")=1,arg("order")=1,
111			arg("l1")=1.0,arg("periodic0")=false,
112			arg("integrationOrder")=-1,
113			arg("useElementsOnFace")=false),
114			return_value_policy<manage_new_object>());
115
116	jgs	110	def("Merge",finley::meshMerge,
117			return_value_policy<manage_new_object>());
118
119	jgs	102	def("GlueFaces",finley::glueFaces,
120			(arg("safetyFactor")=0.2,
121			arg("tolerance")=std::numeric_limits<double>::epsilon()),
122			return_value_policy<manage_new_object>());
123
124			def("JoinFaces",finley::joinFaces,
125			(arg("safetyFactor")=0.2,
126			arg("tolerance")=std::numeric_limits<double>::epsilon()),
127			return_value_policy<manage_new_object>());
128
129			register_exception_translator<esysUtils::EsysException>(&esysUtils::esysExceptionTranslator);
130
131			class_<finley::MeshAdapter, bases<escript::AbstractContinuousDomain> >
132			("MeshAdapter",init<optional <Finley_Mesh*> >())
133			.def(init<const finley::MeshAdapter&>())
134			.def("write",&finley::MeshAdapter::write)
135			.def("getDescription",&finley::MeshAdapter::getDescription)
136			.def("getDim",&finley::MeshAdapter::getDim)
137			.def("getDataShape",&finley::MeshAdapter::getDataShape)
138			.def("addPDEToSystem",&finley::MeshAdapter::addPDEToSystem)
139			.def("addPDEToRHS",&finley::MeshAdapter::addPDEToRHS)
140			.def("newOperator",&finley::MeshAdapter::newSystemMatrix)
141			.def("getSystemMatrixTypeId",&finley::MeshAdapter::getSystemMatrixTypeId)
142	jgs	110	.def("setX",&finley::MeshAdapter::setNewX)
143	jgs	102	.def("getX",&finley::MeshAdapter::getX)
144			.def("getNormal",&finley::MeshAdapter::getNormal)
145	jgs	153	.def("getSize",&finley::MeshAdapter::getSize)
146			.def("saveDX",&finley::MeshAdapter::saveDX)
147			.def("saveVTK",&finley::MeshAdapter::saveVTK);
148	jgs	102
149	jgs	153
150	jgs	102	class_<finley::SystemMatrixAdapter, bases<escript::AbstractSystemMatrix> >
151			("OperatorAdapter",no_init)
152			.def("nullifyRowsAndCols",&finley::SystemMatrixAdapter::nullifyRowsAndCols)
153	jgs	149	.def("resetValues",&finley::SystemMatrixAdapter::resetValues)
154	jgs	123	.def("saveMM",&finley::SystemMatrixAdapter::saveMM)
155			.def("saveHB",&finley::SystemMatrixAdapter::saveHB);
156	jgs	102
157			}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision