/[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 3269 - (hide annotations)
Wed Oct 13 03:21:50 2010 UTC (8 years, 3 months ago) by jfenwick
File MIME type: text/plain
File size: 18901 byte(s)
Fixed some intel compiler warnings.
Put linearPDEs back the way it was and present a common interface for dudley and finley (as per Lutz)

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

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26