/[escript]/trunk/finley/src/CPPAdapter/MeshAdapter.h
ViewVC logotype

Annotation of /trunk/finley/src/CPPAdapter/MeshAdapter.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2519 - (hide annotations)
Mon Jul 6 00:43:08 2009 UTC (9 years, 8 months ago) by jfenwick
File MIME type: text/plain
File size: 17696 byte(s)
Correcting some doxygen errors
1 ksteube 1312
2     /*******************************************************
3 ksteube 1811 *
4     * Copyright (c) 2003-2008 by University of Queensland
5     * Earth Systems Science Computational Center (ESSCC)
6     * http://www.uq.edu.au/esscc
7     *
8     * Primary Business: Queensland, Australia
9     * Licensed under the Open Software License version 3.0
10     * http://www.opensource.org/licenses/osl-3.0.php
11     *
12     *******************************************************/
13 ksteube 1312
14 ksteube 1811
15 jgs 149 #if !defined finley_MeshAdapter_20040526_H
16 jgs 82 #define finley_MeshAdapter_20040526_H
17 woo409 757 #include "system_dep.h"
18 jgs 82
19     extern "C" {
20 robwdcock 682 #include "../Mesh.h"
21     #include "../Finley.h"
22     #include "../Assemble.h"
23     #include "paso/SystemMatrix.h"
24 gross 1366 #include "paso/SolverFCT.h"
25 ksteube 1800 #include "paso/Paso_MPI.h"
26 jgs 82 }
27 jgs 472
28     #include "FinleyError.h"
29     #include "FinleyAdapterException.h"
30 jgs 149
31 jgs 480 #include "SystemMatrixAdapter.h"
32 gross 1366 #include "TransportProblemAdapter.h"
33 robwdcock 682 #include "escript/AbstractContinuousDomain.h"
34     #include "escript/FunctionSpace.h"
35     #include "escript/FunctionSpaceFactory.h"
36 jgs 472
37 jgs 82 #include <boost/shared_ptr.hpp>
38 jgs 153 #include <boost/python/dict.hpp>
39 jgs 472 #include <boost/python/extract.hpp>
40    
41 jgs 82 #include <map>
42     #include <vector>
43     #include <string>
44 jgs 472 #include <sstream>
45 jgs 82
46 jgs 480 //
47     // forward declarations
48     class Data;
49    
50     //using namespace escript;
51    
52 jgs 82 namespace finley {
53    
54 jgs 123 struct null_deleter
55     {
56     void operator()(void const *ptr) const
57     {
58     }
59     };
60    
61    
62 jgs 82 /**
63     \brief
64     MeshAdapter implements the AbstractContinuousDomain
65     interface for the Finley library.
66    
67     Description:
68     MeshAdapter implements the AbstractContinuousDomain
69     interface for the Finley library.
70     */
71    
72 jgs 480 class MeshAdapter : public escript::AbstractContinuousDomain {
73 jgs 82
74     public:
75    
76     //
77     // Codes for function space types supported
78     static const int DegreesOfFreedom;
79     static const int ReducedDegreesOfFreedom;
80     static const int Nodes;
81 gross 1062 static const int ReducedNodes;
82 jgs 82 static const int Elements;
83 gross 1059 static const int ReducedElements;
84 jgs 82 static const int FaceElements;
85 gross 1059 static const int ReducedFaceElements;
86 jgs 82 static const int Points;
87     static const int ContactElementsZero;
88 gross 1059 static const int ReducedContactElementsZero;
89 jgs 82 static const int ContactElementsOne;
90 gross 1059 static const int ReducedContactElementsOne;
91 jgs 82
92     /**
93     \brief
94     Constructor for MeshAdapter
95    
96     Description:
97     Constructor for MeshAdapter. The pointer passed to MeshAdapter
98 ksteube 1312 is deleted using a call to Finley_Mesh_free in the
99 jgs 82 MeshAdapter destructor.
100    
101     Throws:
102     May throw an exception derived from EsysException
103    
104     \param finleyMesh Input - A pointer to the externally constructed
105     finley mesh.The pointer passed to MeshAdapter
106     is deleted using a call to
107 ksteube 1312 Finley_Mesh_free in the MeshAdapter
108 jgs 82 destructor.
109     */
110 woo409 757 FINLEY_DLL_API
111 jgs 82 MeshAdapter(Finley_Mesh* finleyMesh=0);
112 jgs 149
113 jgs 82 /**
114     \brief
115     Copy constructor.
116     */
117 woo409 757 FINLEY_DLL_API
118 jgs 82 MeshAdapter(const MeshAdapter& in);
119 jgs 149
120 jgs 82 /**
121     \brief
122     Destructor for MeshAdapter. As specified in the constructor
123 ksteube 1312 this calls Finley_Mesh_free for the pointer given to the
124 jgs 82 constructor.
125     */
126 woo409 757 FINLEY_DLL_API
127 jgs 82 ~MeshAdapter();
128 jgs 149
129 jgs 82 /**
130     \brief
131 ksteube 1312 return the number of processors used for this domain
132     */
133     FINLEY_DLL_API
134     virtual int getMPISize() const;
135     /**
136     \brief
137     return the number MPI rank of this processor
138     */
139    
140     FINLEY_DLL_API
141     virtual int getMPIRank() const;
142    
143     /**
144     \brief
145 ksteube 1877 If compiled for MPI then execute an MPI_Barrier, else do nothing
146     */
147    
148     FINLEY_DLL_API
149     virtual void MPIBarrier() const;
150    
151     /**
152     \brief
153     Return true if on MPI processor 0, else false
154     */
155    
156     FINLEY_DLL_API
157     virtual bool onMasterProcessor() const;
158    
159     /**
160     \brief
161 jgs 82 return this as an AbstractContinuousDomain.
162     */
163     inline const AbstractContinuousDomain& asAbstractContinuousDomain() const
164     {
165     return *(static_cast<const AbstractContinuousDomain*>(this));
166     }
167    
168     /**
169     \brief
170     return this as an AbstractDomain.
171     */
172     inline const AbstractDomain& asAbstractDomain() const
173     {
174     return *(static_cast<const AbstractDomain*>(this));
175     }
176 jgs 149
177 jgs 82 /**
178     \brief
179     Write the current mesh to a file with the given name.
180     \param fileName Input - The name of the file to write to.
181     */
182 woo409 757 FINLEY_DLL_API
183 jgs 82 void write(const std::string& fileName) const;
184 jgs 149
185 jgs 82 /**
186     \brief
187 jfenwick 2519 \param full
188 ksteube 1326 */
189     FINLEY_DLL_API
190 jfenwick 2519 void Print_Mesh_Info(const bool full=false) const;
191 ksteube 1326
192     /**
193     \brief
194 ksteube 1312 dumps the mesh to a file with the given name.
195     \param fileName Input - The name of the file
196     */
197     FINLEY_DLL_API
198     void dump(const std::string& fileName) const;
199    
200     /**
201     \brief
202 jgs 149 return the pointer to the underlying finley mesh structure
203 jgs 82 */
204 woo409 757 FINLEY_DLL_API
205 jgs 82 Finley_Mesh* getFinley_Mesh() const;
206 jgs 149
207 jgs 110 /**
208     \brief
209     Return the tag key for the given sample number.
210     \param functionSpaceType Input - The function space type.
211     \param sampleNo Input - The sample number.
212     */
213 woo409 757 FINLEY_DLL_API
214 jgs 110 int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;
215 jgs 149
216 jgs 110 /**
217     \brief
218     Return the reference number of the given sample number.
219     \param functionSpaceType Input - The function space type.
220     */
221 woo409 757 FINLEY_DLL_API
222 jfenwick 2487 const int* borrowSampleReferenceIDs(int functionSpaceType) const;
223 jgs 110
224     /**
225     \brief
226 jgs 82 Returns true if the given integer is a valid function space type
227     for this domain.
228     */
229 woo409 757 FINLEY_DLL_API
230 jgs 82 virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
231 jgs 149
232 jgs 82 /**
233     \brief
234     Return a description for this domain
235     */
236 woo409 757 FINLEY_DLL_API
237 jgs 82 virtual std::string getDescription() const;
238 jgs 149
239 jgs 82 /**
240     \brief
241     Return a description for the given function space type code
242     */
243 woo409 757 FINLEY_DLL_API
244 jgs 82 virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;
245 jgs 110
246 jgs 82 /**
247     \brief
248     Build the table of function space type names
249     */
250 woo409 757 FINLEY_DLL_API
251 jgs 82 void setFunctionSpaceTypeNames();
252 jgs 149
253 jgs 82 /**
254     \brief
255     Return a continuous FunctionSpace code
256     */
257 woo409 757 FINLEY_DLL_API
258 jgs 82 virtual int getContinuousFunctionCode() const;
259 jgs 149
260 jgs 82 /**
261     \brief
262 gross 1062 Return a continuous on reduced order nodes FunctionSpace code
263     */
264     FINLEY_DLL_API
265     virtual int getReducedContinuousFunctionCode() const;
266    
267     /**
268     \brief
269 gross 1059 Return a function FunctionSpace code
270 jgs 82 */
271 woo409 757 FINLEY_DLL_API
272 jgs 82 virtual int getFunctionCode() const;
273 jgs 149
274 jgs 82 /**
275     \brief
276 gross 1059 Return a function with reduced integration order FunctionSpace code
277     */
278     FINLEY_DLL_API
279     virtual int getReducedFunctionCode() const;
280    
281     /**
282     \brief
283 jgs 82 Return a function on boundary FunctionSpace code
284     */
285 woo409 757 FINLEY_DLL_API
286 jgs 82 virtual int getFunctionOnBoundaryCode() const;
287 jgs 149
288 jgs 82 /**
289     \brief
290 gross 1059 Return a function on boundary with reduced integration order FunctionSpace code
291     */
292     FINLEY_DLL_API
293     virtual int getReducedFunctionOnBoundaryCode() const;
294    
295     /**
296     \brief
297 jgs 82 Return a FunctionOnContactZero code
298     */
299 woo409 757 FINLEY_DLL_API
300 jgs 82 virtual int getFunctionOnContactZeroCode() const;
301 jgs 149
302 jgs 82 /**
303     \brief
304 gross 1059 Return a FunctionOnContactZero code with reduced integration order
305     */
306     FINLEY_DLL_API
307     virtual int getReducedFunctionOnContactZeroCode() const;
308    
309     /**
310     \brief
311 jgs 82 Return a FunctionOnContactOne code
312     */
313 woo409 757 FINLEY_DLL_API
314 jgs 82 virtual int getFunctionOnContactOneCode() const;
315 jgs 149
316 jgs 82 /**
317     \brief
318 gross 1059 Return a FunctionOnContactOne code with reduced integration order
319     */
320     FINLEY_DLL_API
321     virtual int getReducedFunctionOnContactOneCode() const;
322    
323     /**
324     \brief
325 jgs 82 Return a Solution code
326     */
327 woo409 757 FINLEY_DLL_API
328 jgs 82 virtual int getSolutionCode() const;
329 jgs 149
330 jgs 82 /**
331     \brief
332     Return a ReducedSolution code
333     */
334 woo409 757 FINLEY_DLL_API
335 jgs 82 virtual int getReducedSolutionCode() const;
336 jgs 149
337 jgs 82 /**
338     \brief
339     Return a DiracDeltaFunction code
340     */
341 woo409 757 FINLEY_DLL_API
342 jgs 82 virtual int getDiracDeltaFunctionCode() const;
343 jgs 149
344     /**
345 bcumming 782 5B
346 jgs 149 \brief
347     */
348 jgs 82 typedef std::map<int, std::string> FunctionSpaceNamesMapType;
349 jgs 149
350 jgs 82 /**
351     \brief
352     */
353 woo409 757 FINLEY_DLL_API
354 jgs 82 virtual int getDim() const;
355 jgs 149
356     /**
357 jgs 82 \brief
358 ksteube 1754 Return the number of data points summed across all MPI processes
359     */
360     FINLEY_DLL_API
361     virtual int getNumDataPointsGlobal() const;
362    
363     /**
364     \brief
365 jgs 82 Return the number of data points per sample, and the number of samples as a pair.
366 jgs 121 \param functionSpaceCode Input -
367 jgs 82 */
368 woo409 757 FINLEY_DLL_API
369 jgs 82 virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;
370    
371     /**
372     \brief
373     copies the location of data points into arg. The domain of arg has to match this.
374     has to be implemented by the actual Domain adapter.
375     */
376 woo409 757 FINLEY_DLL_API
377 jgs 82 virtual void setToX(escript::Data& arg) const;
378 jgs 149
379 jgs 82 /**
380     \brief
381 gross 1044 sets a map from a clear tag name to a tag key
382     \param name Input - tag name.
383     \param tag Input - tag key.
384     */
385     FINLEY_DLL_API
386     virtual void setTagMap(const std::string& name, int tag);
387    
388     /**
389     \brief
390     Return the tag key for tag name.
391     \param name Input - tag name
392     */
393     FINLEY_DLL_API
394     virtual int getTag(const std::string& name) const;
395    
396     /**
397     \brief
398     Returns true if name is a defined tage name.
399     \param name Input - tag name to be checked.
400     */
401     FINLEY_DLL_API
402     virtual bool isValidTagName(const std::string& name) const;
403    
404     /**
405     \brief
406     Returns all tag names in a single string sperated by commas
407     */
408     FINLEY_DLL_API
409     virtual std::string showTagNames() const;
410    
411     /**
412     \brief
413 jgs 82 assigns new location to the domain
414     */
415 woo409 757 FINLEY_DLL_API
416 jgs 82 virtual void setNewX(const escript::Data& arg);
417 jgs 149
418 jgs 82 /**
419     \brief
420     interpolates data given on source onto target where source and target have to be given on the same domain.
421     */
422 woo409 757 FINLEY_DLL_API
423 jgs 82 virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
424 woo409 757 FINLEY_DLL_API
425 jgs 82 virtual bool probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const;
426 jgs 149
427 jgs 82 /**
428     \brief
429     interpolates data given on source onto target where source and target are given on different domains.
430     has to be implemented by the actual Domain adapter.
431     */
432 woo409 757 FINLEY_DLL_API
433 jgs 82 virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
434 woo409 757 FINLEY_DLL_API
435 jgs 82 virtual bool probeInterpolationACross(int functionSpaceType_source,const AbstractDomain& targetDomain, int functionSpaceType_target) const;
436 jgs 149
437 jgs 82 /**
438     \brief
439 jgs 149 copies the surface normals at data points into out. The actual function space to be considered
440 jgs 82 is defined by out. out has to be defined on this.
441     */
442 woo409 757 FINLEY_DLL_API
443 jgs 82 virtual void setToNormal(escript::Data& out) const;
444 jgs 149
445 jgs 82 /**
446     \brief
447     copies the size of samples into out. The actual function space to be considered
448     is defined by out. out has to be defined on this.
449     */
450 woo409 757 FINLEY_DLL_API
451 jgs 82 virtual void setToSize(escript::Data& out) const;
452    
453     /**
454     \brief
455     copies the gradient of arg into grad. The actual function space to be considered
456     for the gradient is defined by grad. arg and grad have to be defined on this.
457     */
458 woo409 757 FINLEY_DLL_API
459 jgs 82 virtual void setToGradient(escript::Data& grad,const escript::Data& arg) const;
460    
461     /**
462     \brief
463     copies the integrals of the function defined by arg into integrals.
464     arg has to be defined on this.
465     */
466 woo409 757 FINLEY_DLL_API
467 jgs 82 virtual void setToIntegrals(std::vector<double>& integrals,const escript::Data& arg) const;
468    
469 jgs 149 /**
470 jgs 102 \brief
471 gross 1859 return the identifier of the matrix type to be used for the global stiffness matrix when a particular solver, package, perconditioner,
472 jgs 102 and symmetric matrix is used.
473     \param solver
474 jfenwick 2519 \param preconditioner
475     \param package
476 jgs 102 \param symmetry
477     */
478 woo409 757 FINLEY_DLL_API
479 gross 1859 virtual int getSystemMatrixTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;
480 jgs 102
481 jgs 82 /**
482     \brief
483 gross 1859 return the identifier of the transport problem type to be used when a particular solver, perconditioner, package
484     and symmetric matrix is used.
485     \param solver
486 jfenwick 2519 \param preconditioner
487     \param package
488 gross 1859 \param symmetry
489     */
490     FINLEY_DLL_API
491     virtual int getTransportTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;
492    
493     /**
494     \brief
495 jgs 82 returns true if data on this domain and a function space of type functionSpaceCode has to
496     considered as cell centered data.
497     */
498 woo409 757 FINLEY_DLL_API
499 jgs 82 virtual bool isCellOriented(int functionSpaceCode) const;
500 jgs 149
501 jgs 82 /**
502     \brief
503 jgs 153 Saves a dictonary of Data objects to an OpenDX input file. The keywords are used as identifier
504    
505     This has to be implemented by the actual Domain adapter.
506 jgs 82 */
507 woo409 757 FINLEY_DLL_API
508 jgs 153 virtual void saveDX(const std::string& filename,const boost::python::dict& arg) const;
509 jgs 149
510 jgs 153
511 jgs 82 /**
512     \brief
513 jgs 153 Saves a dictonary of Data objects to an VTK XML input file. The keywords are used as identifier
514    
515     This has to be implemented by the actual Domain adapter.
516 jgs 110 */
517 woo409 757 FINLEY_DLL_API
518 gross 2421 virtual void saveVTK(const std::string& filename,const boost::python::dict& arg, const std::string& metadata, const std::string& metadata_schema) const;
519 jgs 149
520 jgs 110 /**
521     \brief
522 jgs 82 returns the function space representation of the type functionSpaceCode on this domain
523     as a vtkObject.
524     */
525     // vtkObject createVtkObject(int functionSpaceCode) const;
526 jgs 149
527 jgs 82 /**
528     \brief
529     adds a PDE onto the stiffness matrix mat and a rhs
530     */
531 woo409 757 FINLEY_DLL_API
532 jgs 82 virtual void addPDEToSystem(
533     SystemMatrixAdapter& mat, escript::Data& rhs,
534     const escript::Data& A, const escript::Data& B, const escript::Data& C,
535 jgs 102 const escript::Data& D, const escript::Data& X, const escript::Data& Y,
536     const escript::Data& d, const escript::Data& y,
537     const escript::Data& d_contact, const escript::Data& y_contact) const;
538 gross 1204 /**
539     \brief
540     adds a PDE onto the lumped stiffness matrix matrix
541     */
542     FINLEY_DLL_API
543     virtual void addPDEToLumpedSystem(
544     escript::Data& mat,
545     const escript::Data& D,
546     const escript::Data& d) const;
547 jgs 149
548 jgs 82 /**
549     \brief
550 jgs 102 adds a PDE onto the stiffness matrix mat and a rhs
551 jgs 82 */
552 woo409 757 FINLEY_DLL_API
553 jgs 102 virtual void addPDEToRHS(escript::Data& rhs,
554     const escript::Data& X, const escript::Data& Y,
555     const escript::Data& y, const escript::Data& y_contact) const;
556 gross 1367 /**
557     \brief
558     adds a PDE onto a transport problem
559     */
560 jgs 149
561 gross 1367 FINLEY_DLL_API
562     virtual void addPDEToTransportProblem(
563     TransportProblemAdapter& tp, escript::Data& source,
564     const escript::Data& M,
565     const escript::Data& A, const escript::Data& B, const escript::Data& C,const escript::Data& D,
566     const escript::Data& X,const escript::Data& Y,
567     const escript::Data& d, const escript::Data& y,
568     const escript::Data& d_contact,const escript::Data& y_contact) const;
569    
570    
571 jgs 82 /**
572     \brief
573 gross 1366 creates a SystemMatrixAdapter stiffness matrix and initializes it with zeros:
574 jgs 82 */
575 woo409 757 FINLEY_DLL_API
576 jgs 82 SystemMatrixAdapter newSystemMatrix(
577     const int row_blocksize,
578     const escript::FunctionSpace& row_functionspace,
579     const int column_blocksize,
580     const escript::FunctionSpace& column_functionspace,
581 jgs 102 const int type) const;
582 gross 1366 /**
583     \brief
584     creates a TransportProblemAdapter
585 jgs 82
586 gross 1366 */
587    
588     FINLEY_DLL_API
589     TransportProblemAdapter newTransportProblem(
590     const double theta,
591     const int blocksize,
592     const escript::FunctionSpace& functionspace,
593     const int type) const;
594    
595 jgs 102 /**
596     \brief returns locations in the FEM nodes
597     */
598 woo409 757 FINLEY_DLL_API
599 jgs 102 virtual escript::Data getX() const;
600 jgs 149
601 jgs 102 /**
602     \brief return boundary normals at the quadrature point on the face elements
603     */
604 woo409 757 FINLEY_DLL_API
605 jgs 102 virtual escript::Data getNormal() const;
606 jgs 149
607 jgs 102 /**
608     \brief returns the element size
609     */
610 woo409 757 FINLEY_DLL_API
611 jgs 102 virtual escript::Data getSize() const;
612    
613 jgs 149 /**
614     \brief comparison operators
615     */
616 woo409 757 FINLEY_DLL_API
617 jgs 121 virtual bool operator==(const AbstractDomain& other) const;
618 woo409 757 FINLEY_DLL_API
619 jgs 121 virtual bool operator!=(const AbstractDomain& other) const;
620 jgs 102
621 gross 767 /**
622     \brief assigns new tag newTag to all samples of functionspace with a positive
623     value of mask for any its sample point.
624    
625     */
626     FINLEY_DLL_API
627     virtual void setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const;
628    
629 gross 1716 /**
630     \brief
631     return the number of tags in use and a pointer to an array with the number of tags in use
632     */
633     FINLEY_DLL_API
634     virtual int getNumberOfTagsInUse(int functionSpaceCode) const;
635    
636     FINLEY_DLL_API
637 jfenwick 2487 virtual const int* borrowListOfTagsInUse(int functionSpaceCode) const;
638 gross 1716
639 jfenwick 1802
640     /**
641     \brief Checks if this domain allows tags for the specified functionSpaceCode.
642     */
643     FINLEY_DLL_API
644     virtual
645     bool canTag(int functionSpaceCode) const;
646    
647    
648 jgs 82 protected:
649    
650     private:
651 caltinay 2151 void extractArgsFromDict(const boost::python::dict& arg, int& numData,
652     char**& names, escriptDataC*& data,
653     escriptDataC**& dataPtr) const;
654 jgs 149
655 jgs 82 //
656     // pointer to the externally created finley mesh
657     boost::shared_ptr<Finley_Mesh> m_finleyMesh;
658    
659     static FunctionSpaceNamesMapType m_functionSpaceTypeNames;
660    
661     };
662    
663     } // end of namespace
664 jgs 149
665 jgs 82 #endif

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26