Cantera/Adding Python Class Via C++ - Revision history

Admin at 04:47, 13 August 2014

2014-08-13T04:47:50Z

← Older revision		Revision as of 04:47, 13 August 2014
Line 31:		Line 31:
	===Think Properties===		===Think Properties===

			Rather than try and get fancy with new classes or class hierarchies, you can keep it simple by using accessors, or properties.

			That means that you extend classes and simply define a set of new properties, which are accessible with get/set methods.

	===The Way Things Ought To Be===		===The Way Things Ought To Be===
Line 41:		Line 43:
	[[Numpy]] provides a great model for how this outsourcing of numerics could be done, as does [[Fipy]].		[[Numpy]] provides a great model for how this outsourcing of numerics could be done, as does [[Fipy]].

			=Getting Started: The C++=

			We are going to do something simple and straightforward: we are going to add a new class that redefines a few methods. (Remember - keep it simple!)

			=Wrapping with the C API=

			(...)

			=Creating the Python-C Interface=

			(Is this necessary?)

			=Creating the Cython-C Interface=

			(...)

	[[Category:Cantera]]		[[Category:Cantera]]

Admin: /* This Example */

2014-08-13T04:44:40Z

This Example

← Older revision		Revision as of 04:44, 13 August 2014
Line 17:		Line 17:
	4. Create a Cython object (this fourth step was added between Cantera 2.0 and Cantera 2.1)		4. Create a Cython object (this fourth step was added between Cantera 2.0 and Cantera 2.1)

	==~~This~~ Example==		==The Example==

	This example will show you how to extend the FlowController class to create a new mass flow controller type - specifically, a mass flow controller that controls the flow of a single species. (Note that this is analogous to [http://en.wikipedia.org/wiki/Maxwell's_demon Maxwell's Demon].)		This example will show you how to extend the FlowController class to create a new mass flow controller type - specifically, a mass flow controller that controls the flow of a single species. (Note that this is analogous to [http://en.wikipedia.org/wiki/Maxwell's_demon Maxwell's Demon].)


	==Strategies==		==Strategies==

Admin: /* The Way Things Ought To Be */

2014-08-13T04:44:21Z

The Way Things Ought To Be

← Older revision		Revision as of 04:44, 13 August 2014
Line 40:		Line 40:
	Ultimately, the ideal solution (to quote Rush Limbaugh: "the way things ought to be") is for the library to be implemented in Python, which provides much more flexibility and sanity than C++. Some underlying Cython would add speed, as would some C, but really, you should be interfacing with external Python and/or C libraries for the heavy lifting (ODEs, solvers, matrices, and such).		Ultimately, the ideal solution (to quote Rush Limbaugh: "the way things ought to be") is for the library to be implemented in Python, which provides much more flexibility and sanity than C++. Some underlying Cython would add speed, as would some C, but really, you should be interfacing with external Python and/or C libraries for the heavy lifting (ODEs, solvers, matrices, and such).

	Numpy provides a great model for how this could be done, as does Fipy.		[[Numpy]] provides a great model for how this outsourcing of numerics could be done, as does [[Fipy]].

Admin: /* The Way Things Ought To Be */

2014-08-13T04:44:05Z

The Way Things Ought To Be

← Older revision		Revision as of 04:44, 13 August 2014
Line 40:		Line 40:
	Ultimately, the ideal solution (to quote Rush Limbaugh: "the way things ought to be") is for the library to be implemented in Python, which provides much more flexibility and sanity than C++. Some underlying Cython would add speed, as would some C, but really, you should be interfacing with external Python and/or C libraries for the heavy lifting (ODEs, solvers, matrices, and such).		Ultimately, the ideal solution (to quote Rush Limbaugh: "the way things ought to be") is for the library to be implemented in Python, which provides much more flexibility and sanity than C++. Some underlying Cython would add speed, as would some C, but really, you should be interfacing with external Python and/or C libraries for the heavy lifting (ODEs, solvers, matrices, and such).

	Numpy does ~~this particularly well~~.		Numpy provides a great model for how this could be done, as does Fipy.

Admin: /* Strategies */

2014-08-13T04:43:33Z

Strategies

← Older revision		Revision as of 04:43, 13 August 2014
Line 20:		Line 20:

	This example will show you how to extend the FlowController class to create a new mass flow controller type - specifically, a mass flow controller that controls the flow of a single species. (Note that this is analogous to [http://en.wikipedia.org/wiki/Maxwell's_demon Maxwell's Demon].)		This example will show you how to extend the FlowController class to create a new mass flow controller type - specifically, a mass flow controller that controls the flow of a single species. (Note that this is analogous to [http://en.wikipedia.org/wiki/Maxwell's_demon Maxwell's Demon].)


	==Strategies==		==Strategies==
Line 25:		Line 26:
	Before jumping into Cantera with both feet (and spending hours thrashing around in the code base), it's important that you step back for a moment and strategize how you want to go about adding your class.		Before jumping into Cantera with both feet (and spending hours thrashing around in the code base), it's important that you step back for a moment and strategize how you want to go about adding your class.

	~~'''FIRST''':~~ The Cantera code base has a lot of layers. That means that for every function or object you implement, you'll be writing 3 or 4 APIs for it. That means that complicated input arguments, non-trivial (well, even trivial) class inheritance diagrams, or modifications to existing functionality is NOT RECOMMENDED.		===Keep It Simple===

			The Cantera code base has a lot of layers. That means that for every function or object you implement, you'll be writing 3 or 4 APIs for it. That means that complicated input arguments, non-trivial (well, even trivial) class inheritance diagrams, or modifications to existing functionality is NOT RECOMMENDED.

			===Think Properties===



	~~'''SECOND''': Keep it as simple as possible.~~		===The Way Things Ought To Be===

	''~~'THIRD~~''~~': Don't overthink it~~.		It is unfortunate that Cantera is so cumbersome to extend, given the philosophy behind Cantera: it was intended to be an ''easily-extendable library'' with modular functionality. However, with the additional layers of the C API, the Python-C wrappers, and most recently, Cython, you end up doing a lot of code gymnastics for even the simplest extensions.

	~~'''FOURTH'''~~: ~~Did I mention~~ you ~~want to keep it simple?~~		Ultimately, the ideal solution (to quote Rush Limbaugh: "the way things ought to be") is for the library to be implemented in Python, which provides much more flexibility and sanity than C++. Some underlying Cython would add speed, as would some C, but really, you should be interfacing with external Python and/or C libraries for the heavy lifting (ODEs, solvers, matrices, and such).

	It is unfortunate that Cantera is so cumbersome to extend, given the philosophy behind Cantera: it was intended to be an ''easily-extendable library'' with modular functionality. Dave Goodwin, the creator of Cantera, left many comments and dummy classes to illustrate how Cantera functionality might be extended. However, with the additional layers of the C API, the Python-C wrappers, and most recently, Cython, you end up doing a lot of code gymnastics for even the simplest extensions.		Numpy does this particularly well.

Admin: /* Strategies */

2014-08-13T04:39:21Z

Strategies

← Older revision		Revision as of 04:39, 13 August 2014
Line 25:		Line 25:
	Before jumping into Cantera with both feet (and spending hours thrashing around in the code base), it's important that you step back for a moment and strategize how you want to go about adding your class.		Before jumping into Cantera with both feet (and spending hours thrashing around in the code base), it's important that you step back for a moment and strategize how you want to go about adding your class.

	~~Some words of advice~~:		'''FIRST''': The Cantera code base has a lot of layers. That means that for every function or object you implement, you'll be writing 3 or 4 APIs for it. That means that complicated input arguments, non-trivial (well, even trivial) class inheritance diagrams, or modifications to existing functionality is NOT RECOMMENDED.
	* The Cantera code base has a lot of layers. That means that for every function or object you implement, you'll be writing 3 or 4 APIs for it. That means that complicated input arguments, non-trivial (well, even trivial) class inheritance diagrams, or modifications to existing functionality is NOT RECOMMENDED.
	* Keep it as simple as possible.		'''SECOND''': Keep it as simple as possible.
	* Don't overthink it.
	* Did I mention you want to keep it simple?		'''THIRD''': Don't overthink it.

			'''FOURTH''': Did I mention you want to keep it simple?

	It is unfortunate that Cantera is so cumbersome to extend, given the philosophy behind Cantera: it was intended to be an ''easily-extendable library'' with modular functionality. Dave Goodwin, the creator of Cantera, left many comments and dummy classes to illustrate how Cantera functionality might be extended. However, with the additional layers of the C API, the Python-C wrappers, and most recently, Cython, you end up doing a lot of code gymnastics for even the simplest extensions.		It is unfortunate that Cantera is so cumbersome to extend, given the philosophy behind Cantera: it was intended to be an ''easily-extendable library'' with modular functionality. Dave Goodwin, the creator of Cantera, left many comments and dummy classes to illustrate how Cantera functionality might be extended. However, with the additional layers of the C API, the Python-C wrappers, and most recently, Cython, you end up doing a lot of code gymnastics for even the simplest extensions.

Admin: /* Overview */

2014-08-13T04:38:44Z

Overview

← Older revision		Revision as of 04:38, 13 August 2014
Line 16:		Line 16:

	4. Create a Cython object (this fourth step was added between Cantera 2.0 and Cantera 2.1)		4. Create a Cython object (this fourth step was added between Cantera 2.0 and Cantera 2.1)

			==This Example==

			This example will show you how to extend the FlowController class to create a new mass flow controller type - specifically, a mass flow controller that controls the flow of a single species. (Note that this is analogous to [http://en.wikipedia.org/wiki/Maxwell's_demon Maxwell's Demon].)

			==Strategies==

			Before jumping into Cantera with both feet (and spending hours thrashing around in the code base), it's important that you step back for a moment and strategize how you want to go about adding your class.

			Some words of advice:
			* The Cantera code base has a lot of layers. That means that for every function or object you implement, you'll be writing 3 or 4 APIs for it. That means that complicated input arguments, non-trivial (well, even trivial) class inheritance diagrams, or modifications to existing functionality is NOT RECOMMENDED.
			* Keep it as simple as possible.
			* Don't overthink it.
			* Did I mention you want to keep it simple?

			It is unfortunate that Cantera is so cumbersome to extend, given the philosophy behind Cantera: it was intended to be an ''easily-extendable library'' with modular functionality. Dave Goodwin, the creator of Cantera, left many comments and dummy classes to illustrate how Cantera functionality might be extended. However, with the additional layers of the C API, the Python-C wrappers, and most recently, Cython, you end up doing a lot of code gymnastics for even the simplest extensions.




	[[Category:Cantera]]		[[Category:Cantera]]

Admin: /* Overview */

2014-08-13T03:11:52Z

Overview

← Older revision		Revision as of 03:11, 13 August 2014
Line 16:		Line 16:

	4. Create a Cython object (this fourth step was added between Cantera 2.0 and Cantera 2.1)		4. Create a Cython object (this fourth step was added between Cantera 2.0 and Cantera 2.1)


			[[Category:Cantera]]

Admin: /* Overview */

2014-08-13T03:11:39Z

Overview

← Older revision		Revision as of 03:11, 13 August 2014
Line 13:		Line 13:
	2. Wrap the new C++ code with the C API		2. Wrap the new C++ code with the C API

	3. Create a Python object that calls the C API code		3. Create a Python object that calls the C API code (is this even necessary?)

	4. Create a Cython object		4. Create a Cython object (this fourth step was added between Cantera 2.0 and Cantera 2.1)

	~~This~~ fourth step ~~is new to~~ Cantera 2.1.

Admin: moved Cantera/Adding Python Class to Cantera/Adding Python Class Via C++

2014-08-12T19:06:27Z

moved Cantera/Adding Python Class to Cantera/Adding Python Class Via C++

← Older revision	Revision as of 19:06, 12 August 2014
(No difference)