/[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 3379 - (hide annotations)
Wed Nov 24 04:48:49 2010 UTC (8 years, 3 months ago) by gross
File MIME type: text/plain
File size: 18927 byte(s)
some clarification on lumping
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 gross 3379 const escript::Data& d,
561     const bool useHRZ) const;
562 jgs 149
563 jgs 82 /**
564     \brief
565 jgs 102 adds a PDE onto the stiffness matrix mat and a rhs
566 jgs 82 */
567 woo409 757 FINLEY_DLL_API
568 jgs 102 virtual void addPDEToRHS(escript::Data& rhs,
569     const escript::Data& X, const escript::Data& Y,
570     const escript::Data& y, const escript::Data& y_contact) const;
571 gross 1367 /**
572     \brief
573     adds a PDE onto a transport problem
574     */
575 jgs 149
576 gross 1367 FINLEY_DLL_API
577     virtual void addPDEToTransportProblem(
578 jfenwick 3269 escript::AbstractTransportProblem& tp, escript::Data& source,
579 gross 1367 const escript::Data& M,
580     const escript::Data& A, const escript::Data& B, const escript::Data& C,const escript::Data& D,
581     const escript::Data& X,const escript::Data& Y,
582     const escript::Data& d, const escript::Data& y,
583     const escript::Data& d_contact,const escript::Data& y_contact) const;
584    
585    
586 jgs 82 /**
587     \brief
588 gross 1366 creates a SystemMatrixAdapter stiffness matrix and initializes it with zeros:
589 jgs 82 */
590 woo409 757 FINLEY_DLL_API
591 jfenwick 3259 escript::ASM_ptr newSystemMatrix(
592 jgs 82 const int row_blocksize,
593     const escript::FunctionSpace& row_functionspace,
594     const int column_blocksize,
595     const escript::FunctionSpace& column_functionspace,
596 jgs 102 const int type) const;
597 gross 1366 /**
598     \brief
599     creates a TransportProblemAdapter
600 jgs 82
601 gross 1366 */
602    
603     FINLEY_DLL_API
604 jfenwick 3259 escript::ATP_ptr newTransportProblem(
605 gross 2987 const bool useBackwardEuler,
606 gross 1366 const int blocksize,
607     const escript::FunctionSpace& functionspace,
608     const int type) const;
609    
610 jgs 102 /**
611     \brief returns locations in the FEM nodes
612     */
613 woo409 757 FINLEY_DLL_API
614 jgs 102 virtual escript::Data getX() const;
615 jgs 149
616 jgs 102 /**
617     \brief return boundary normals at the quadrature point on the face elements
618     */
619 woo409 757 FINLEY_DLL_API
620 jgs 102 virtual escript::Data getNormal() const;
621 jgs 149
622 jgs 102 /**
623     \brief returns the element size
624     */
625 woo409 757 FINLEY_DLL_API
626 jgs 102 virtual escript::Data getSize() const;
627    
628 jgs 149 /**
629     \brief comparison operators
630     */
631 woo409 757 FINLEY_DLL_API
632 jfenwick 2521 virtual bool operator==(const escript::AbstractDomain& other) const;
633 woo409 757 FINLEY_DLL_API
634 jfenwick 2521 virtual bool operator!=(const escript::AbstractDomain& other) const;
635 jgs 102
636 gross 767 /**
637     \brief assigns new tag newTag to all samples of functionspace with a positive
638     value of mask for any its sample point.
639    
640     */
641     FINLEY_DLL_API
642     virtual void setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const;
643    
644 gross 1716 /**
645     \brief
646     return the number of tags in use and a pointer to an array with the number of tags in use
647     */
648     FINLEY_DLL_API
649     virtual int getNumberOfTagsInUse(int functionSpaceCode) const;
650    
651     FINLEY_DLL_API
652 jfenwick 2487 virtual const int* borrowListOfTagsInUse(int functionSpaceCode) const;
653 gross 1716
654 jfenwick 1802
655     /**
656     \brief Checks if this domain allows tags for the specified functionSpaceCode.
657     */
658     FINLEY_DLL_API
659     virtual
660     bool canTag(int functionSpaceCode) const;
661    
662 gross 2856 /**
663     \brief returns the approximation order used for a function space functionSpaceCode
664     */
665 jfenwick 1802
666 gross 2856 FINLEY_DLL_API
667     virtual
668     int getApproximationOrder(const int functionSpaceCode) const;
669    
670 jfenwick 3259 FINLEY_DLL_API
671     bool supportsContactElements() const;
672 gross 2856
673 jfenwick 3259
674 jgs 82 protected:
675    
676     private:
677 caltinay 2151 void extractArgsFromDict(const boost::python::dict& arg, int& numData,
678     char**& names, escriptDataC*& data,
679     escriptDataC**& dataPtr) const;
680 jgs 149
681 jgs 82 //
682     // pointer to the externally created finley mesh
683     boost::shared_ptr<Finley_Mesh> m_finleyMesh;
684    
685     static FunctionSpaceNamesMapType m_functionSpaceTypeNames;
686    
687     };
688    
689 caltinay 2898 // Do not use this class. It is a convenience wrapper for the dataexporter.
690     class FINLEY_DLL_API ReferenceElementSetWrapper {
691     public:
692 jfenwick 3259 ReferenceElementSetWrapper(Finley_ElementTypeId id, index_t order,
693 caltinay 2898 index_t reducedOrder);
694     ~ReferenceElementSetWrapper();
695    
696     Finley_ReferenceElementSet* getElementSet() const { return m_refSet; }
697    
698     private:
699     Finley_ReferenceElementSet* m_refSet;
700     };
701    
702    
703 jgs 82 } // end of namespace
704 jgs 149
705 jgs 82 #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26