/[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 2856 - (hide annotations)
Mon Jan 18 04:14:37 2010 UTC (9 years, 3 months ago) by gross
File MIME type: text/plain
File size: 18798 byte(s)
FunctionSpaces provide now some information about their approximation order.
1 ksteube 1312
2     /*******************************************************
3 ksteube 1811 *
4 jfenwick 2548 * Copyright (c) 2003-2009 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 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     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     #ifdef PASO_MPI
155     MPI_Comm
156     #else
157     unsigned int
158     #endif
159     getMPIComm() const;
160    
161 ksteube 1877 /**
162     \brief
163 jgs 82 return this as an AbstractContinuousDomain.
164     */
165     inline const AbstractContinuousDomain& asAbstractContinuousDomain() const
166     {
167     return *(static_cast<const AbstractContinuousDomain*>(this));
168     }
169    
170     /**
171     \brief
172     return this as an AbstractDomain.
173     */
174     inline const AbstractDomain& asAbstractDomain() const
175     {
176     return *(static_cast<const AbstractDomain*>(this));
177     }
178 jgs 149
179 jgs 82 /**
180     \brief
181     Write the current mesh to a file with the given name.
182     \param fileName Input - The name of the file to write to.
183     */
184 woo409 757 FINLEY_DLL_API
185 jgs 82 void write(const std::string& fileName) const;
186 jgs 149
187 jgs 82 /**
188     \brief
189 jfenwick 2519 \param full
190 ksteube 1326 */
191     FINLEY_DLL_API
192 jfenwick 2519 void Print_Mesh_Info(const bool full=false) const;
193 ksteube 1326
194     /**
195     \brief
196 ksteube 1312 dumps the mesh to a file with the given name.
197     \param fileName Input - The name of the file
198     */
199     FINLEY_DLL_API
200     void dump(const std::string& fileName) const;
201    
202     /**
203     \brief
204 jgs 149 return the pointer to the underlying finley mesh structure
205 jgs 82 */
206 woo409 757 FINLEY_DLL_API
207 jgs 82 Finley_Mesh* getFinley_Mesh() const;
208 jgs 149
209 jgs 110 /**
210     \brief
211     Return the tag key for the given sample number.
212     \param functionSpaceType Input - The function space type.
213     \param sampleNo Input - The sample number.
214     */
215 woo409 757 FINLEY_DLL_API
216 jgs 110 int getTagFromSampleNo(int functionSpaceType, int sampleNo) const;
217 jgs 149
218 jgs 110 /**
219     \brief
220     Return the reference number of the given sample number.
221     \param functionSpaceType Input - The function space type.
222     */
223 woo409 757 FINLEY_DLL_API
224 jfenwick 2487 const int* borrowSampleReferenceIDs(int functionSpaceType) const;
225 jgs 110
226     /**
227     \brief
228 jgs 82 Returns true if the given integer is a valid function space type
229     for this domain.
230     */
231 woo409 757 FINLEY_DLL_API
232 jgs 82 virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
233 jgs 149
234 jgs 82 /**
235     \brief
236     Return a description for this domain
237     */
238 woo409 757 FINLEY_DLL_API
239 jgs 82 virtual std::string getDescription() const;
240 jgs 149
241 jgs 82 /**
242     \brief
243     Return a description for the given function space type code
244     */
245 woo409 757 FINLEY_DLL_API
246 jgs 82 virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;
247 jgs 110
248 jgs 82 /**
249     \brief
250     Build the table of function space type names
251     */
252 woo409 757 FINLEY_DLL_API
253 jgs 82 void setFunctionSpaceTypeNames();
254 jgs 149
255 jgs 82 /**
256     \brief
257     Return a continuous FunctionSpace code
258     */
259 woo409 757 FINLEY_DLL_API
260 jgs 82 virtual int getContinuousFunctionCode() const;
261 jgs 149
262 jgs 82 /**
263     \brief
264 gross 1062 Return a continuous on reduced order nodes FunctionSpace code
265     */
266     FINLEY_DLL_API
267     virtual int getReducedContinuousFunctionCode() const;
268    
269     /**
270     \brief
271 gross 1059 Return a function FunctionSpace code
272 jgs 82 */
273 woo409 757 FINLEY_DLL_API
274 jgs 82 virtual int getFunctionCode() const;
275 jgs 149
276 jgs 82 /**
277     \brief
278 gross 1059 Return a function with reduced integration order FunctionSpace code
279     */
280     FINLEY_DLL_API
281     virtual int getReducedFunctionCode() const;
282    
283     /**
284     \brief
285 jgs 82 Return a function on boundary FunctionSpace code
286     */
287 woo409 757 FINLEY_DLL_API
288 jgs 82 virtual int getFunctionOnBoundaryCode() const;
289 jgs 149
290 jgs 82 /**
291     \brief
292 gross 1059 Return a function on boundary with reduced integration order FunctionSpace code
293     */
294     FINLEY_DLL_API
295     virtual int getReducedFunctionOnBoundaryCode() const;
296    
297     /**
298     \brief
299 jgs 82 Return a FunctionOnContactZero code
300     */
301 woo409 757 FINLEY_DLL_API
302 jgs 82 virtual int getFunctionOnContactZeroCode() const;
303 jgs 149
304 jgs 82 /**
305     \brief
306 gross 1059 Return a FunctionOnContactZero code with reduced integration order
307     */
308     FINLEY_DLL_API
309     virtual int getReducedFunctionOnContactZeroCode() const;
310    
311     /**
312     \brief
313 jgs 82 Return a FunctionOnContactOne code
314     */
315 woo409 757 FINLEY_DLL_API
316 jgs 82 virtual int getFunctionOnContactOneCode() const;
317 jgs 149
318 jgs 82 /**
319     \brief
320 gross 1059 Return a FunctionOnContactOne code with reduced integration order
321     */
322     FINLEY_DLL_API
323     virtual int getReducedFunctionOnContactOneCode() const;
324    
325     /**
326     \brief
327 jgs 82 Return a Solution code
328     */
329 woo409 757 FINLEY_DLL_API
330 jgs 82 virtual int getSolutionCode() const;
331 jgs 149
332 jgs 82 /**
333     \brief
334     Return a ReducedSolution code
335     */
336 woo409 757 FINLEY_DLL_API
337 jgs 82 virtual int getReducedSolutionCode() const;
338 jgs 149
339 jgs 82 /**
340     \brief
341     Return a DiracDeltaFunction code
342     */
343 woo409 757 FINLEY_DLL_API
344 jgs 82 virtual int getDiracDeltaFunctionCode() const;
345 jgs 149
346     /**
347 bcumming 782 5B
348 jgs 149 \brief
349     */
350 jgs 82 typedef std::map<int, std::string> FunctionSpaceNamesMapType;
351 jgs 149
352 jgs 82 /**
353     \brief
354     */
355 woo409 757 FINLEY_DLL_API
356 jgs 82 virtual int getDim() const;
357 jgs 149
358     /**
359 jgs 82 \brief
360 gross 2533 Returns a status indicator of the domain. The status identifier should be unique over
361     the live time if the object but may be updated if changes to the domain happen, e.g.
362     modifications to its geometry.
363    
364     This has to be implemented by the actual Domain adapter.
365     */
366     FINLEY_DLL_API
367     virtual StatusType getStatus() const;
368    
369    
370     /**
371     \brief
372 ksteube 1754 Return the number of data points summed across all MPI processes
373     */
374     FINLEY_DLL_API
375     virtual int getNumDataPointsGlobal() const;
376    
377     /**
378     \brief
379 jgs 82 Return the number of data points per sample, and the number of samples as a pair.
380 jgs 121 \param functionSpaceCode Input -
381 jgs 82 */
382 woo409 757 FINLEY_DLL_API
383 jgs 82 virtual std::pair<int,int> getDataShape(int functionSpaceCode) const;
384    
385     /**
386     \brief
387     copies the location of data points into arg. The domain of arg has to match this.
388     has to be implemented by the actual Domain adapter.
389     */
390 woo409 757 FINLEY_DLL_API
391 jgs 82 virtual void setToX(escript::Data& arg) const;
392 jgs 149
393 jgs 82 /**
394     \brief
395 gross 1044 sets a map from a clear tag name to a tag key
396     \param name Input - tag name.
397     \param tag Input - tag key.
398     */
399     FINLEY_DLL_API
400     virtual void setTagMap(const std::string& name, int tag);
401    
402     /**
403     \brief
404     Return the tag key for tag name.
405     \param name Input - tag name
406     */
407     FINLEY_DLL_API
408     virtual int getTag(const std::string& name) const;
409    
410     /**
411     \brief
412     Returns true if name is a defined tage name.
413     \param name Input - tag name to be checked.
414     */
415     FINLEY_DLL_API
416     virtual bool isValidTagName(const std::string& name) const;
417    
418     /**
419     \brief
420     Returns all tag names in a single string sperated by commas
421     */
422     FINLEY_DLL_API
423     virtual std::string showTagNames() const;
424    
425     /**
426     \brief
427 jgs 82 assigns new location to the domain
428     */
429 woo409 757 FINLEY_DLL_API
430 jgs 82 virtual void setNewX(const escript::Data& arg);
431 jgs 149
432 jgs 82 /**
433     \brief
434     interpolates data given on source onto target where source and target have to be given on the same domain.
435     */
436 woo409 757 FINLEY_DLL_API
437 jgs 82 virtual void interpolateOnDomain(escript::Data& target,const escript::Data& source) const;
438 jfenwick 2521
439    
440 woo409 757 FINLEY_DLL_API
441 jgs 82 virtual bool probeInterpolationOnDomain(int functionSpaceType_source,int functionSpaceType_target) const;
442 jgs 149
443 jgs 82 /**
444 jfenwick 2635 \brief given a vector of FunctionSpace typecodes, pass back a code which then can all be interpolated to.
445     \return true is result is valid, false if not
446     */
447     FINLEY_DLL_API
448     bool
449     commonFunctionSpace(const std::vector<int>& fs, int& resultcode) const;
450    
451     /**
452 jgs 82 \brief
453     interpolates data given on source onto target where source and target are given on different domains.
454     has to be implemented by the actual Domain adapter.
455     */
456 woo409 757 FINLEY_DLL_API
457 jgs 82 virtual void interpolateACross(escript::Data& target, const escript::Data& source) const;
458 jfenwick 2521
459     /**
460     \brief determines whether interpolation from source to target is possible.
461     Must be implemented by the actual Domain adapter
462     */
463 woo409 757 FINLEY_DLL_API
464 jfenwick 2521 virtual bool probeInterpolationACross(int functionSpaceType_source,const escript::AbstractDomain& targetDomain, int functionSpaceType_target) const;
465 jgs 149
466 jgs 82 /**
467     \brief
468 jgs 149 copies the surface normals at data points into out. The actual function space to be considered
469 jgs 82 is defined by out. out has to be defined on this.
470     */
471 woo409 757 FINLEY_DLL_API
472 jgs 82 virtual void setToNormal(escript::Data& out) const;
473 jgs 149
474 jgs 82 /**
475     \brief
476     copies the size of samples into out. The actual function space to be considered
477     is defined by out. out has to be defined on this.
478     */
479 woo409 757 FINLEY_DLL_API
480 jgs 82 virtual void setToSize(escript::Data& out) const;
481    
482     /**
483     \brief
484     copies the gradient of arg into grad. The actual function space to be considered
485     for the gradient is defined by grad. arg and grad have to be defined on this.
486     */
487 woo409 757 FINLEY_DLL_API
488 jgs 82 virtual void setToGradient(escript::Data& grad,const escript::Data& arg) const;
489    
490     /**
491     \brief
492     copies the integrals of the function defined by arg into integrals.
493     arg has to be defined on this.
494     */
495 woo409 757 FINLEY_DLL_API
496 jgs 82 virtual void setToIntegrals(std::vector<double>& integrals,const escript::Data& arg) const;
497    
498 jgs 149 /**
499 jgs 102 \brief
500 gross 1859 return the identifier of the matrix type to be used for the global stiffness matrix when a particular solver, package, perconditioner,
501 jgs 102 and symmetric matrix is used.
502     \param solver
503 jfenwick 2519 \param preconditioner
504     \param package
505 jgs 102 \param symmetry
506     */
507 woo409 757 FINLEY_DLL_API
508 gross 1859 virtual int getSystemMatrixTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;
509 jgs 102
510 jgs 82 /**
511     \brief
512 gross 1859 return the identifier of the transport problem type to be used when a particular solver, perconditioner, package
513     and symmetric matrix is used.
514     \param solver
515 jfenwick 2519 \param preconditioner
516     \param package
517 gross 1859 \param symmetry
518     */
519     FINLEY_DLL_API
520     virtual int getTransportTypeId(const int solver, const int preconditioner, const int package, const bool symmetry) const;
521    
522     /**
523     \brief
524 jgs 82 returns true if data on this domain and a function space of type functionSpaceCode has to
525     considered as cell centered data.
526     */
527 woo409 757 FINLEY_DLL_API
528 jgs 82 virtual bool isCellOriented(int functionSpaceCode) const;
529 jgs 149
530 jgs 82 /**
531     \brief
532 jgs 153 Saves a dictonary of Data objects to an OpenDX input file. The keywords are used as identifier
533    
534     This has to be implemented by the actual Domain adapter.
535 jgs 82 */
536 woo409 757 FINLEY_DLL_API
537 jgs 153 virtual void saveDX(const std::string& filename,const boost::python::dict& arg) const;
538 jgs 149
539 jgs 153
540 jgs 82 /**
541     \brief
542 jgs 153 Saves a dictonary of Data objects to an VTK XML input file. The keywords are used as identifier
543    
544     This has to be implemented by the actual Domain adapter.
545 jgs 110 */
546 woo409 757 FINLEY_DLL_API
547 gross 2421 virtual void saveVTK(const std::string& filename,const boost::python::dict& arg, const std::string& metadata, const std::string& metadata_schema) const;
548 jgs 149
549 jfenwick 2642 FINLEY_DLL_API
550     virtual bool ownSample(int fs_code, index_t id) const;
551    
552 jgs 110 /**
553     \brief
554 jgs 82 returns the function space representation of the type functionSpaceCode on this domain
555     as a vtkObject.
556     */
557     // vtkObject createVtkObject(int functionSpaceCode) const;
558 jgs 149
559 jgs 82 /**
560     \brief
561     adds a PDE onto the stiffness matrix mat and a rhs
562     */
563 woo409 757 FINLEY_DLL_API
564 jgs 82 virtual void addPDEToSystem(
565     SystemMatrixAdapter& mat, escript::Data& rhs,
566     const escript::Data& A, const escript::Data& B, const escript::Data& C,
567 jgs 102 const escript::Data& D, const escript::Data& X, const escript::Data& Y,
568     const escript::Data& d, const escript::Data& y,
569     const escript::Data& d_contact, const escript::Data& y_contact) const;
570 gross 1204 /**
571     \brief
572     adds a PDE onto the lumped stiffness matrix matrix
573     */
574     FINLEY_DLL_API
575     virtual void addPDEToLumpedSystem(
576     escript::Data& mat,
577     const escript::Data& D,
578     const escript::Data& d) const;
579 jgs 149
580 jgs 82 /**
581     \brief
582 jgs 102 adds a PDE onto the stiffness matrix mat and a rhs
583 jgs 82 */
584 woo409 757 FINLEY_DLL_API
585 jgs 102 virtual void addPDEToRHS(escript::Data& rhs,
586     const escript::Data& X, const escript::Data& Y,
587     const escript::Data& y, const escript::Data& y_contact) const;
588 gross 1367 /**
589     \brief
590     adds a PDE onto a transport problem
591     */
592 jgs 149
593 gross 1367 FINLEY_DLL_API
594     virtual void addPDEToTransportProblem(
595     TransportProblemAdapter& tp, escript::Data& source,
596     const escript::Data& M,
597     const escript::Data& A, const escript::Data& B, const escript::Data& C,const escript::Data& D,
598     const escript::Data& X,const escript::Data& Y,
599     const escript::Data& d, const escript::Data& y,
600     const escript::Data& d_contact,const escript::Data& y_contact) const;
601    
602    
603 jgs 82 /**
604     \brief
605 gross 1366 creates a SystemMatrixAdapter stiffness matrix and initializes it with zeros:
606 jgs 82 */
607 woo409 757 FINLEY_DLL_API
608 jgs 82 SystemMatrixAdapter newSystemMatrix(
609     const int row_blocksize,
610     const escript::FunctionSpace& row_functionspace,
611     const int column_blocksize,
612     const escript::FunctionSpace& column_functionspace,
613 jgs 102 const int type) const;
614 gross 1366 /**
615     \brief
616     creates a TransportProblemAdapter
617 jgs 82
618 gross 1366 */
619    
620     FINLEY_DLL_API
621     TransportProblemAdapter newTransportProblem(
622     const double theta,
623     const int blocksize,
624     const escript::FunctionSpace& functionspace,
625     const int type) const;
626    
627 jgs 102 /**
628     \brief returns locations in the FEM nodes
629     */
630 woo409 757 FINLEY_DLL_API
631 jgs 102 virtual escript::Data getX() const;
632 jgs 149
633 jgs 102 /**
634     \brief return boundary normals at the quadrature point on the face elements
635     */
636 woo409 757 FINLEY_DLL_API
637 jgs 102 virtual escript::Data getNormal() const;
638 jgs 149
639 jgs 102 /**
640     \brief returns the element size
641     */
642 woo409 757 FINLEY_DLL_API
643 jgs 102 virtual escript::Data getSize() const;
644    
645 jgs 149 /**
646     \brief comparison operators
647     */
648 woo409 757 FINLEY_DLL_API
649 jfenwick 2521 virtual bool operator==(const escript::AbstractDomain& other) const;
650 woo409 757 FINLEY_DLL_API
651 jfenwick 2521 virtual bool operator!=(const escript::AbstractDomain& other) const;
652 jgs 102
653 gross 767 /**
654     \brief assigns new tag newTag to all samples of functionspace with a positive
655     value of mask for any its sample point.
656    
657     */
658     FINLEY_DLL_API
659     virtual void setTags(const int functionSpaceType, const int newTag, const escript::Data& mask) const;
660    
661 gross 1716 /**
662     \brief
663     return the number of tags in use and a pointer to an array with the number of tags in use
664     */
665     FINLEY_DLL_API
666     virtual int getNumberOfTagsInUse(int functionSpaceCode) const;
667    
668     FINLEY_DLL_API
669 jfenwick 2487 virtual const int* borrowListOfTagsInUse(int functionSpaceCode) const;
670 gross 1716
671 jfenwick 1802
672     /**
673     \brief Checks if this domain allows tags for the specified functionSpaceCode.
674     */
675     FINLEY_DLL_API
676     virtual
677     bool canTag(int functionSpaceCode) const;
678    
679 gross 2856 /**
680     \brief returns the approximation order used for a function space functionSpaceCode
681     */
682 jfenwick 1802
683 gross 2856 FINLEY_DLL_API
684     virtual
685     int getApproximationOrder(const int functionSpaceCode) const;
686    
687    
688 jgs 82 protected:
689    
690     private:
691 caltinay 2151 void extractArgsFromDict(const boost::python::dict& arg, int& numData,
692     char**& names, escriptDataC*& data,
693     escriptDataC**& dataPtr) const;
694 jgs 149
695 jgs 82 //
696     // pointer to the externally created finley mesh
697     boost::shared_ptr<Finley_Mesh> m_finleyMesh;
698    
699     static FunctionSpaceNamesMapType m_functionSpaceTypeNames;
700    
701     };
702    
703     } // 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