escript/src/AbstractContinuousDomain.h

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

*/

#if !defined escript_AbstractContinuousDomain_20040528_H
#define escript_AbstractContinuousDomain_20040528_H

#include "system_dep.h"
#include "AbstractDomain.h"

#include <string>
#include <vector>

namespace escript {

//
// Forward declaration
class Data;

/**
   \brief
   AbstractContinuousDomain, base class for continuous domains.

   Description:
   AbstractContinuousDomain, base class for continuous domains.

   NOTE: Most of the virtual functions would be pure virtual except
   boost.python requires a non abstract base class.
*/
class AbstractContinuousDomain : public AbstractDomain {

 public:

  /**
     \brief
     Default constructor for AbstractContinuousDomain

     Description:
     Default constructor for AbstractContinuousDomain

     Preconditions:
     Describe any preconditions

     Throws:
     Describe any exceptions thrown
  */
  ESCRIPT_DLL_API 
  AbstractContinuousDomain();

  /**
     \brief
     Destructor for AbstractContinuousDomain

     Description:
     Destructor for AbstractContinuousDomain

     Preconditions:
     Describe any preconditions

     Throws:
     Describe any exceptions thrown
  */
  ESCRIPT_DLL_API 
  virtual ~AbstractContinuousDomain();

  /**
     \brief
     Returns true if the given integer is a valid function space type
     for this domain.
  */
  ESCRIPT_DLL_API 
  virtual bool isValidFunctionSpaceType(int functionSpaceType) const;

  /**
     \brief
     Return a description for this domain
  */
  ESCRIPT_DLL_API 
  virtual std::string getDescription() const;

  /**
     \brief
     Return a continuous FunctionSpace code
  */
  ESCRIPT_DLL_API 
  virtual int getContinuousFunctionCode() const;

  /**
     \brief
     Return a functon FunctionSpace code
  */
  ESCRIPT_DLL_API 
  virtual int getFunctionCode() const;

  /**
     \brief
     Return a function on boundary FunctionSpace code
  */
  ESCRIPT_DLL_API 
  virtual int getFunctionOnBoundaryCode() const;

  /**
     \brief
     Return a FunctionOnContactZero code
  */
  ESCRIPT_DLL_API 
  virtual int getFunctionOnContactZeroCode() const;

  /**
     \brief
     Return a FunctionOnContactOne code
  */
  ESCRIPT_DLL_API 
  virtual int getFunctionOnContactOneCode() const;

  /**
     \brief
     Return a Solution code
  */
  ESCRIPT_DLL_API 
  virtual int getSolutionCode() const;

  /**
     \brief
     Return a ReducedSolution code
  */
  ESCRIPT_DLL_API 
  virtual int getReducedSolutionCode() const;

  /**
     \brief
     Return a DiracDeltaFunction code
  */
  ESCRIPT_DLL_API 
  virtual int getDiracDeltaFunctionCode() const;

  /**
     \brief
     return the identifier of the matrix type to be used for the global
     stiffness matrix when a particular solver package
     and symmetric matrix is used.
  */
  ESCRIPT_DLL_API 
  virtual int getSystemMatrixTypeId(const int solver, const int package, const bool symmetry) const;

  /**
     \brief
     copies the integrals of the function defined by arg into integrals.
     arg has to be defined on this.
     has to be implemented by the Domain Adapter.
  */
  ESCRIPT_DLL_API 
  virtual void setToIntegrals(std::vector<double>& integrals,const escript::Data& arg) const;

  /**
     \brief
     Return the domain as const AbstractContinuousDomain&
  */
  ESCRIPT_DLL_API 
  static const  AbstractContinuousDomain& asAbstractContinuousDomain(const AbstractDomain& domain);

 protected:

 private:

};

} // end of namespace

#endif
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
15	#if !defined escript_AbstractContinuousDomain_20040528_H
16	#define escript_AbstractContinuousDomain_20040528_H
17
18	#include "system_dep.h"
19	#include "AbstractDomain.h"
20
21	#include <string>
22	#include <vector>
23
24	namespace escript {
25
26	//
27	// Forward declaration
28	class Data;
29
30	/**
31	\brief
32	AbstractContinuousDomain, base class for continuous domains.
33
34	Description:
35	AbstractContinuousDomain, base class for continuous domains.
36
37	NOTE: Most of the virtual functions would be pure virtual except
38	boost.python requires a non abstract base class.
39	*/
40	class AbstractContinuousDomain : public AbstractDomain {
41
42	public:
43
44	/**
45	\brief
46	Default constructor for AbstractContinuousDomain
47
48	Description:
49	Default constructor for AbstractContinuousDomain
50
51	Preconditions:
52	Describe any preconditions
53
54	Throws:
55	Describe any exceptions thrown
56	*/
57	ESCRIPT_DLL_API
58	AbstractContinuousDomain();
59
60	/**
61	\brief
62	Destructor for AbstractContinuousDomain
63
64	Description:
65	Destructor for AbstractContinuousDomain
66
67	Preconditions:
68	Describe any preconditions
69
70	Throws:
71	Describe any exceptions thrown
72	*/
73	ESCRIPT_DLL_API
74	virtual ~AbstractContinuousDomain();
75
76	/**
77	\brief
78	Returns true if the given integer is a valid function space type
79	for this domain.
80	*/
81	ESCRIPT_DLL_API
82	virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
83
84	/**
85	\brief
86	Return a description for this domain
87	*/
88	ESCRIPT_DLL_API
89	virtual std::string getDescription() const;
90
91	/**
92	\brief
93	Return a continuous FunctionSpace code
94	*/
95	ESCRIPT_DLL_API
96	virtual int getContinuousFunctionCode() const;
97
98	/**
99	\brief
100	Return a functon FunctionSpace code
101	*/
102	ESCRIPT_DLL_API
103	virtual int getFunctionCode() const;
104
105	/**
106	\brief
107	Return a function on boundary FunctionSpace code
108	*/
109	ESCRIPT_DLL_API
110	virtual int getFunctionOnBoundaryCode() const;
111
112	/**
113	\brief
114	Return a FunctionOnContactZero code
115	*/
116	ESCRIPT_DLL_API
117	virtual int getFunctionOnContactZeroCode() const;
118
119	/**
120	\brief
121	Return a FunctionOnContactOne code
122	*/
123	ESCRIPT_DLL_API
124	virtual int getFunctionOnContactOneCode() const;
125
126	/**
127	\brief
128	Return a Solution code
129	*/
130	ESCRIPT_DLL_API
131	virtual int getSolutionCode() const;
132
133	/**
134	\brief
135	Return a ReducedSolution code
136	*/
137	ESCRIPT_DLL_API
138	virtual int getReducedSolutionCode() const;
139
140	/**
141	\brief
142	Return a DiracDeltaFunction code
143	*/
144	ESCRIPT_DLL_API
145	virtual int getDiracDeltaFunctionCode() const;
146
147	/**
148	\brief
149	return the identifier of the matrix type to be used for the global
150	stiffness matrix when a particular solver package
151	and symmetric matrix is used.
152	*/
153	ESCRIPT_DLL_API
154	virtual int getSystemMatrixTypeId(const int solver, const int package, const bool symmetry) const;
155
156	/**
157	\brief
158	copies the integrals of the function defined by arg into integrals.
159	arg has to be defined on this.
160	has to be implemented by the Domain Adapter.
161	*/
162	ESCRIPT_DLL_API
163	virtual void setToIntegrals(std::vector<double>& integrals,const escript::Data& arg) const;
164
165	/**
166	\brief
167	Return the domain as const AbstractContinuousDomain&
168	*/
169	ESCRIPT_DLL_API
170	static const AbstractContinuousDomain& asAbstractContinuousDomain(const AbstractDomain& domain);
171
172	protected:
173
174	private:
175
176	};
177
178	} // end of namespace
179
180	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision