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.                       *
 *                                                                            *
 ******************************************************************************
 
******************************************************************************/

#ifdef PASO_MPI
#include <mpi.h>
#endif
extern "C" {
#include "../Finley.h"
}

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

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

#include "escript/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")="file.fly",arg("integrationOrder")=-1,  arg("reducedIntegrationOrder")=-1,  arg("optimizeLabeling")=true),
      return_value_policy<manage_new_object>());

  def("ReadGmsh",finley::readGmsh,
      (arg("fileName")="file.msh",arg("numDim"), arg("integrationOrder")=-1, arg("reducedIntegrationOrder")=-1, arg("optimizeLabeling")=true),
      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("reducedIntegrationOrder")=-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("reducedIntegrationOrder")=-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("reducedIntegrationOrder")=-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")=1.e-8,
      arg("optimizeLabeling")=true),
      return_value_policy<manage_new_object>());

  def("JoinFaces",finley::joinFaces,
      (arg("safetyFactor")=0.2,
      arg("tolerance")=1.e-8,
      arg("optimizeLabeling")=true),
      return_value_policy<manage_new_object>());

  register_exception_translator<finley::FinleyAdapterException>(&(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)
      .def("setTagMap",&finley::MeshAdapter::setTagMap)
      .def("getTag",&finley::MeshAdapter::getTag)
      .def("isValidTagName",&finley::MeshAdapter::isValidTagName)
      .def("showTagNames",&finley::MeshAdapter::showTagNames);


  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	// $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	#ifdef PASO_MPI
18	#include <mpi.h>
19	#endif
20	extern "C" {
21	#include "../Finley.h"
22	}
23
24	#include "MeshAdapter.h"
25	#include "MeshAdapterFactory.h"
26	#include "SystemMatrixAdapter.h"
27
28	#include "FinleyAdapterException.h"
29	// #include "esysUtils/EsysException.h"
30	#include "esysUtils/esysExceptionTranslator.h"
31
32	#include "escript/AbstractContinuousDomain.h"
33
34	#include <boost/python.hpp>
35	#include <boost/python/module.hpp>
36	#include <boost/python/def.hpp>
37	#include <boost/python/detail/defaults_gen.hpp>
38
39	using namespace boost::python;
40
41	/**
42	\page finley Finley
43	Finley is the python module name that contains the interfaces
44	to the C++ wrapper to finley.
45
46	\version 1.0.0
47
48	\section class_desc Class Description:
49	Data
50
51	\section class_limits Class Limitations:
52	None
53
54	\section class_conds Class Conditions of Use:
55	None
56
57	\section throws Throws:
58	None
59
60	*/
61
62	//
63	// The BOOST_PYTHON_FUNCTION_OVERLOADS macro generates function overloads for optional
64	// arguments to the respective finley functions.
65	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
66	//
67	// NOTE: If the number of arguments to the finley functions change
68	// the magic numbers in the BOOST_PYTHON_FUNCTION_OVERLOADS call
69	// must change.
70	//
71	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
72	// BOOST_PYTHON_FUNCTION_OVERLOADS(readMesh_overloads,finley::readMesh,1,2)
73	// BOOST_PYTHON_FUNCTION_OVERLOADS(brick_overloads,finley::brick,0,12)
74	// BOOST_PYTHON_FUNCTION_OVERLOADS(rectangle_overloads,finley::rectangle,0,9)
75	// BOOST_PYTHON_FUNCTION_OVERLOADS(interval_overloads,finley::interval,0,6)
76	// BOOST_PYTHON_FUNCTION_OVERLOADS(glueFaces_overloads,finley::glueFaces,1,3)
77	// BOOST_PYTHON_FUNCTION_OVERLOADS(joinFaces_overloads,finley::joinFaces,1,3)
78
79	BOOST_PYTHON_MODULE(finleycpp)
80	{
81
82	// def("ReadMesh",finley::readMesh,readMesh_overloads());
83	// def("Brick",finley::brick,brick_overloads());
84	// def("Rectangle",finley::rectangle,rectangle_overloads());
85	// def("Interval",finley::interval,interval_overloads());
86	// def("GlueFaces",finley::glueFaces,glueFaces_overloads());
87	// def("JoinFaces",finley::joinFaces,joinFaces_overloads());
88	//
89	// NOTE: The return_value_policy is necessary for functions that
90	// return pointers.
91
92	def("ReadMesh",finley::readMesh,
93	(arg("fileName")="file.fly",arg("integrationOrder")=-1, arg("reducedIntegrationOrder")=-1, arg("optimizeLabeling")=true),
94	return_value_policy<manage_new_object>());
95
96	def("ReadGmsh",finley::readGmsh,
97	(arg("fileName")="file.msh",arg("numDim"), arg("integrationOrder")=-1, arg("reducedIntegrationOrder")=-1, arg("optimizeLabeling")=true),
98	return_value_policy<manage_new_object>());
99
100	def ("Brick",finley::brick,
101	(arg("n0")=1,arg("n1")=1,arg("n2")=1,
102	arg("order")=1,
103	arg("l0")=1.0,arg("l1")=1.0,arg("l2")=1.0,
104	arg("periodic0")=false,arg("periodic1")=false,arg("periodic2")=false,
105	arg("integrationOrder")=-1, arg("reducedIntegrationOrder")=-1,
106	arg("useElementsOnFace")=false),
107	return_value_policy<manage_new_object>());
108
109	def ("Rectangle",finley::rectangle,
110	(arg("n0")=1,arg("n1")=1,arg("order")=1,
111	arg("l0")=1.0,arg("l1")=1.0,
112	arg("periodic0")=false,arg("periodic1")=false,
113	arg("integrationOrder")=-1, arg("reducedIntegrationOrder")=-1,
114	arg("useElementsOnFace")=false),
115	return_value_policy<manage_new_object>());
116
117	def("Interval",finley::interval,
118	(arg("n1")=1,arg("order")=1,
119	arg("l1")=1.0,arg("periodic0")=false,
120	arg("integrationOrder")=-1, arg("reducedIntegrationOrder")=-1,
121	arg("useElementsOnFace")=false),
122	return_value_policy<manage_new_object>());
123
124	def("Merge",finley::meshMerge,
125	return_value_policy<manage_new_object>());
126
127	def("GlueFaces",finley::glueFaces,
128	(arg("safetyFactor")=0.2,
129	arg("tolerance")=1.e-8,
130	arg("optimizeLabeling")=true),
131	return_value_policy<manage_new_object>());
132
133	def("JoinFaces",finley::joinFaces,
134	(arg("safetyFactor")=0.2,
135	arg("tolerance")=1.e-8,
136	arg("optimizeLabeling")=true),
137	return_value_policy<manage_new_object>());
138
139	register_exception_translator<finley::FinleyAdapterException>(&(esysUtils::esysExceptionTranslator));
140
141	class_<finley::MeshAdapter, bases<escript::AbstractContinuousDomain> >
142	("MeshAdapter",init<optional <Finley_Mesh*> >())
143	.def(init<const finley::MeshAdapter&>())
144	.def("write",&finley::MeshAdapter::write)
145	.def("getDescription",&finley::MeshAdapter::getDescription)
146	.def("getDim",&finley::MeshAdapter::getDim)
147	.def("getDataShape",&finley::MeshAdapter::getDataShape)
148	.def("addPDEToSystem",&finley::MeshAdapter::addPDEToSystem)
149	.def("addPDEToRHS",&finley::MeshAdapter::addPDEToRHS)
150	.def("newOperator",&finley::MeshAdapter::newSystemMatrix)
151	.def("getSystemMatrixTypeId",&finley::MeshAdapter::getSystemMatrixTypeId)
152	.def("setX",&finley::MeshAdapter::setNewX)
153	.def("getX",&finley::MeshAdapter::getX)
154	.def("getNormal",&finley::MeshAdapter::getNormal)
155	.def("getSize",&finley::MeshAdapter::getSize)
156	.def("saveDX",&finley::MeshAdapter::saveDX)
157	.def("saveVTK",&finley::MeshAdapter::saveVTK)
158	.def("setTagMap",&finley::MeshAdapter::setTagMap)
159	.def("getTag",&finley::MeshAdapter::getTag)
160	.def("isValidTagName",&finley::MeshAdapter::isValidTagName)
161	.def("showTagNames",&finley::MeshAdapter::showTagNames);
162
163
164	class_<finley::SystemMatrixAdapter, bases<escript::AbstractSystemMatrix> >
165	("OperatorAdapter",no_init)
166	.def("nullifyRowsAndCols",&finley::SystemMatrixAdapter::nullifyRowsAndCols)
167	.def("resetValues",&finley::SystemMatrixAdapter::resetValues)
168	.def("saveMM",&finley::SystemMatrixAdapter::saveMM)
169	.def("saveHB",&finley::SystemMatrixAdapter::saveHB);
170
171	}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision