/[escript]/trunk-mpi-branch/finley/src/Mesh_hex8.c
ViewVC logotype

Contents of /trunk-mpi-branch/finley/src/Mesh_hex8.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1226 - (show annotations)
Fri Aug 3 08:00:07 2007 UTC (12 years, 9 months ago) by gross
File MIME type: text/plain
File size: 21217 byte(s)
hook for ParaMetis added. still needs some work
1 /*
2 ************************************************************
3 * Copyright 2006 by ACcESS MNRF *
4 * *
5 * http://www.access.edu.au *
6 * Primary Business: Queensland, Australia *
7 * Licensed under the Open Software License version 3.0 *
8 * http://www.opensource.org/licenses/osl-3.0.php *
9 * *
10 ************************************************************
11 */
12
13 /**************************************************************/
14
15 /* Finley: generates rectangular meshes */
16
17 /* Generates a numElements[0] x numElements[1] x numElements[2] mesh with first order elements (Hex8) in the brick */
18 /* [0,Length[0]] x [0,Length[1]] x [0,Length[2]]. order is the desired accuracy of the */
19 /* integration scheme. */
20
21 /**************************************************************/
22
23 /* Author: gross@access.edu.au */
24 /* Version: $Id$ */
25
26 /**************************************************************/
27
28 #include "RectangularMesh.h"
29
30 Finley_Mesh* Finley_RectangularMesh_Hex8(dim_t* numElements,
31 double* Length,
32 bool_t* periodic,
33 index_t order,
34 index_t reduced_order,
35 bool_t useElementsOnFace,
36 bool_t useFullElementOrder,
37 bool_t optimize)
38 {
39 #define N_PER_E 1
40 #define DIM 3
41 dim_t N0,N1,N2,NE0,NE1,NE2,i0,i1,i2,k,Nstride0,Nstride1,Nstride2, local_NE0, local_NE1, local_NE2, local_N0, local_N1, local_N2;
42 dim_t totalNECount,faceNECount,NDOF0,NDOF1,NDOF2,NFaceElements, NN;
43 index_t node0, myRank, e_offset2, e_offset1, e_offset0, offset1, offset2, offset0, global_i0, global_i1, global_i2;
44 Finley_Mesh* out;
45 Paso_MPIInfo *mpi_info = NULL;
46 char name[50];
47 double time0=Finley_timer();
48
49 /* get MPI information */
50 mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );
51 if (! Finley_noError()) {
52 return NULL;
53 }
54 myRank=mpi_info->rank;
55
56 /* allocate mesh: */
57 sprintf(name,"Rectangular %d x %d x %d mesh",N0,N1,N2);
58 out=Finley_Mesh_alloc(name,DIM,order, reduced_order, mpi_info);
59 if (! Finley_noError()) {
60 Paso_MPIInfo_free( mpi_info );
61 return NULL;
62 }
63
64 Finley_Mesh_setElements(out,Finley_ElementFile_alloc(Hex8,out->order,out->reduced_order,mpi_info));
65 if (useElementsOnFace) {
66 Finley_Mesh_setFaceElements(out,Finley_ElementFile_alloc(Hex8Face,
67 out->order,
68 out->reduced_order,
69 mpi_info));
70 Finley_Mesh_setContactElements(out,Finley_ElementFile_alloc(Hex8Face_Contact,
71 out->order,
72 out->reduced_order,
73 mpi_info));
74 } else {
75 Finley_Mesh_setFaceElements(out,Finley_ElementFile_alloc(Rec4,
76 out->order,
77 out->reduced_order,
78 mpi_info));
79 Finley_Mesh_setContactElements(out,Finley_ElementFile_alloc(Rec4_Contact,
80 out->order,
81 out->reduced_order,
82 mpi_info));
83 }
84 Finley_Mesh_setPoints(out,Finley_ElementFile_alloc(Point1,
85 out->order,
86 out->reduced_order,
87 mpi_info));
88 if (! Finley_noError()) {
89 Paso_MPIInfo_free( mpi_info );
90 Finley_Mesh_free(out);
91 return NULL;
92 }
93
94 /* set up the global dimensions of the mesh */
95
96 NE0=MAX(1,numElements[0]);
97 NE1=MAX(1,numElements[1]);
98 NE2=MAX(1,numElements[2]);
99 N0=N_PER_E*NE0+1;
100 N1=N_PER_E*NE1+1;
101 N2=N_PER_E*NE2+1;
102
103 /* work out the largest dimension */
104 if (N2=MAX3(N0,N1,N2)) {
105 Nstride0=1;
106 Nstride1=N0;
107 Nstride2=N0*N1;
108 local_NE0=NE0;
109 e_offset0=0;
110 local_NE1=NE1;
111 e_offset1=0;
112 Paso_MPIInfo_Split(mpi_info,NE2,&local_NE2,&e_offset2);
113 } else if (N1=MAX3(N0,N1,N2)) {
114 Nstride0=N2;
115 Nstride1=N0*N2;
116 Nstride2=1;
117 local_NE0=NE0;
118 e_offset0=0;
119 Paso_MPIInfo_Split(mpi_info,NE1,&local_NE1,&e_offset1);
120 local_NE2=NE2;
121 e_offset2=0;
122 } else {
123 Nstride0=N1*N2;
124 Nstride1=1;
125 Nstride2=N1;
126 Paso_MPIInfo_Split(mpi_info,NE0,&local_NE0,&e_offset0);
127 local_NE1=NE1;
128 e_offset1=0;
129 local_NE2=NE2;
130 e_offset2=0;
131 }
132 offset0=e_offset0*N_PER_E;
133 offset1=e_offset1*N_PER_E;
134 offset2=e_offset2*N_PER_E;
135 local_N0=local_NE0*N_PER_E+1;
136 local_N1=local_NE1*N_PER_E+1;
137 local_N2=local_NE2*N_PER_E+1;
138
139 /* get the number of surface elements */
140
141 NFaceElements=0;
142 if (!periodic[2]) {
143 NDOF2=N2;
144 if (offset2==0) NFaceElements+=local_NE1*local_NE0;
145 if (local_NE2+e_offset2 == NE2) NFaceElements+=local_NE1*local_NE0;
146 } else {
147 NDOF2=N2-1;
148
149 if (!periodic[0]) {
150 NDOF0=N0;
151 if (e_offset0 == 0) NFaceElements+=local_NE1*local_NE2;
152 if (local_NE0+e_offset0 == NE0) NFaceElements+=local_NE1*local_NE2;
153 } else {
154 NDOF0=N0-1;
155 }
156 if (!periodic[1]) {
157 NDOF1=N1;
158 if (e_offset1 == 0) NFaceElements+=local_NE0*local_NE2;
159 if (local_NE1+e_offset1 == NE1) NFaceElements+=local_NE0*local_NE2;
160 } else {
161 NDOF1=N1-1;
162 }
163
164 /* allocate tables: */
165
166 Finley_NodeFile_allocTable(out->Nodes,local_N0*local_N1*local_N2);
167 Finley_ElementFile_allocTable(out->Elements,local_NE0*local_NE1*local_NE2);
168 Finley_ElementFile_allocTable(out->FaceElements,NFaceElements);
169
170 if (Finley_noError()) {
171 /* create nodes */
172
173 #pragma omp parallel for private(i0,i1,i2,k,global_i0,global_i1,global_i2)
174 for (i2=0;i2<local_N2;i2++) {
175 for (i1=0;i1<local_N1;i1++) {
176 for (i0=0;i0<local_N0;i0++) {
177 k=i0+local_N0*i1+local_N0*local_N1*i2;
178 global_i0=i0+offset0;
179 global_i1=i1+offset1;
180 global_i2=i2+offset2;
181 out->Nodes->Coordinates[INDEX2(0,k,DIM)]=DBLE(global_i0)/DBLE(N0-1)*Length[0];
182 out->Nodes->Coordinates[INDEX2(1,k,DIM)]=DBLE(global_i1)/DBLE(N1-1)*Length[1];
183 out->Nodes->Coordinates[INDEX2(2,k,DIM)]=DBLE(global_i2)/DBLE(N2-1)*Length[2];
184 out->Nodes->Id[k]=Nstride0*global_i0+Nstride1*global_i1+Nstride2*global_i2;
185 out->Nodes->Tag[k]=0;
186 out->Nodes->globalDegreesOfFreedom[k]=Nstride0*(global_i0%NDOF0)
187 +Nstride1*(global_i1%NDOF1)
188 +Nstride2*(global_i2%NDOF2);
189 }
190 }
191 }
192 /* set the elements: */
193 NN=out->Elements->numNodes;
194 #pragma omp parallel for private(i0,i1,i2,k,node0)
195 for (i2=0;i2<local_NE2;i2++) {
196 for (i1=0;i1<local_NE1;i1++) {
197 for (i0=0;i0<local_NE0;i0++) {
198
199 k=i0+local_NE0*i1+local_NE0*local_NE1*i2;
200 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(i2+e_offset2);
201
202 out->Elements->Id[k]=(i0+e_offset0)+NE0*(i1+e_offset1)+NE0*NE1*(i2+e_offset2);
203 out->Elements->Tag[k]=0;
204 out->Elements->Owner[k]=myRank;
205
206 out->Elements->Nodes[INDEX2(0,k,NN)] =node0 ;
207 out->Elements->Nodes[INDEX2(1,k,NN)] =node0+ Nstride0;
208 out->Elements->Nodes[INDEX2(2,k,NN)] =node0+ Nstride1+Nstride0;
209 out->Elements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride1;
210 out->Elements->Nodes[INDEX2(4,k,NN)] =node0+Nstride2 ;
211 out->Elements->Nodes[INDEX2(5,k,NN)] =node0+Nstride2 +Nstride0;
212 out->Elements->Nodes[INDEX2(6,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
213 out->Elements->Nodes[INDEX2(7,k,NN)] =node0+Nstride2+Nstride1 ;
214 }
215 }
216 }
217 /* face elements */
218 NN=out->FaceElements->numNodes;
219 totalNECount=NE0*NE1*NE2;
220 faceNECount=0;
221 /* these are the quadrilateral elements on boundary 1 (x3=0): */
222 if (!periodic[2]) {
223 /* ** elements on boundary 100 (x3=0): */
224 if (offset2==0) {
225 #pragma omp parallel for private(i0,i1,k,node0)
226 for (i1=0;i1<local_NE1;i1++) {
227 for (i0=0;i0<local_NE0;i0++) {
228
229 k=i0+local_NE0*i1+faceNECount;
230 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(i1+e_offset1);
231
232 out->FaceElements->Id[k]=(i0+e_offset0)+NE0*(i1+e_offset1)+totalNECount;
233 out->FaceElements->Tag[k]=100;
234 out->FaceElements->Owner[k]=myRank;
235
236 if (useElementsOnFace) {
237 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
238 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0 +Nstride1 ;
239 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0 +Nstride1+Nstride0;
240 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride0 ;
241 out->FaceElements->Nodes[INDEX2(4,k,NN)] =node0+Nstride2 ;
242 out->FaceElements->Nodes[INDEX2(5,k,NN)] =node0+Nstride2+Nstride1 ;
243 out->FaceElements->Nodes[INDEX2(6,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
244 out->FaceElements->Nodes[INDEX2(7,k,NN)] =node0+Nstride2 +Nstride0;
245 } else {
246 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
247 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+ Nstride1 ;
248 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+ Nstride1+Nstride0;
249 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride0;
250 }
251 }
252 }
253 faceNECount+=local_NE1*local_NE0;
254 }
255 totalNECount+=NE1*NE0;
256 /* ** elements on boundary 200 (x3=1) */
257 if (local_NE2+e_offset2 == NE2) {
258 #pragma omp parallel for private(i0,i1,k,node0)
259 for (i1=0;i1<local_NE1;i1++) {
260 for (i0=0;i0<local_NE0;i0++) {
261
262 k=i0+local_NE0*i1+faceNECount;
263 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(NE2-1);
264
265 out->FaceElements->Id[k]=(i0+e_offset0)+NE0*(i1+e_offset1)+totalNECount;
266 out->FaceElements->Tag[k]=200;
267 out->FaceElements->Owner[k]=myRank;
268 if (useElementsOnFace) {
269 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0+Nstride2 ;
270 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2+ Nstride0;
271 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
272 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+Nstride2+Nstride1 ;
273
274 out->FaceElements->Nodes[INDEX2(4,k,NN)] =node0 ;
275 out->FaceElements->Nodes[INDEX2(5,k,NN)] =node0+Nstride0 ;
276 out->FaceElements->Nodes[INDEX2(6,k,NN)] =node0+ Nstride1+Nstride0;
277 out->FaceElements->Nodes[INDEX2(7,k,NN)] =node0+ Nstride1;
278 } else {
279 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0+Nstride2 ;
280 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2 +Nstride0;
281 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
282 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+Nstride2+Nstride1 ;
283 }
284 }
285 }
286 faceNECount+=local_NE1*local_NE0;
287 }
288 totalNECount+=NE1*NE0;
289 }
290 if (!periodic[0]) {
291 /* ** elements on boundary 001 (x1=0): */
292
293 if (e_offset0 == 0) {
294 #pragma omp parallel for private(i1,i2,k,node0)
295 for (i2=0;i2<local_NE2;i2++) {
296 for (i1=0;i1<local_NE1;i1++) {
297
298 k=i1+local_NE1*i2+faceNECount;
299 node0=Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(i2+e_offset2);
300 out->FaceElements->Id[k]=(i1+e_offset1)+NE1*(i2+e_offset2)+totalNECount;
301 out->FaceElements->Tag[k]=1;
302 out->FaceElements->Owner[k]=myRank;
303
304 if (useElementsOnFace) {
305 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
306 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2 ;
307 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1 ;
308 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+Nstride1 ;
309 out->FaceElements->Nodes[INDEX2(4,k,NN)] =node0+Nstride0 ;
310 out->FaceElements->Nodes[INDEX2(5,k,NN)] =node0+Nstride2+Nstride0 ;
311 out->FaceElements->Nodes[INDEX2(6,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
312 out->FaceElements->Nodes[INDEX2(7,k,NN)] =node0+Nstride1+Nstride0 ;
313 } else {
314 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
315 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2 ;
316 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1 ;
317 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride1 ;
318 }
319 }
320 }
321 }
322 faceNECount+=local_NE1*local_NE2;
323 }
324 totalNECount+=NE1*NE2;
325
326 /* ** elements on boundary 002 (x1=1): */
327 if (local_NE0+e_offset0 == NE0) {
328 #pragma omp parallel for private(i1,i2,k,node0)
329 for (i2=0;i2<local_NE2;i2++) {
330 for (i1=0;i1<local_NE1;i1++) {
331 k=i1+local_NE1*i2+faceNECount;
332 node0=Nstride0*N_PER_E*(NE0-1)+Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(i2+e_offset2);
333 out->FaceElements->Id[k]=(i1+e_offset1)+NE1*(i2+e_offset2)+totalNECount;
334 out->FaceElements->Tag[k]=2;
335 out->FaceElements->Owner[k]=myRank;
336
337 if (useElementsOnFace) {
338 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0+ Nstride0;
339 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride1+Nstride0;
340 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
341 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2+ Nstride0;
342
343 out->FaceElements->Nodes[INDEX2(4,k,NN)]=node0 ;
344 out->FaceElements->Nodes[INDEX2(5,k,NN)]=node0+ Nstride1 ;
345 out->FaceElements->Nodes[INDEX2(6,k,NN)]=node0+Nstride2+Nstride1 ;
346 out->FaceElements->Nodes[INDEX2(7,k,NN)]=node0+Nstride2 ;
347
348 } else {
349 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0 +Nstride0;
350 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride1+Nstride0;
351 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
352 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2+ Nstride0;
353 }
354
355 }
356 }
357 faceNECount+=local_NE1*local_NE2;
358 }
359 totalNECount+=NE1*NE2;
360 }
361 if (!periodic[1]) {
362 /* ** elements on boundary 010 (x2=0): */
363 if (e_offset1 == 0) {
364 #pragma omp parallel for private(i0,i2,k,node0)
365 for (i2=0;i2<local_NE2;i2++) {
366 for (i0=0;i0<local_NE0;i0++) {
367 k=i0+local_NE0*i2+faceNECount;
368 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride2*N_PER_E*(i2+e_offset2);
369
370 out->FaceElements->Id[k]=(i2+e_offset2)+NE2*(e_offset0+i0)+totalNECount;
371 out->FaceElements->Tag[k]=10;
372 out->FaceElements->Owner[k]=myRank;
373 if (useElementsOnFace) {
374 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0 ;
375 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride0;
376 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2 +Nstride0;
377 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2 ;
378
379 out->FaceElements->Nodes[INDEX2(4,k,NN)]=node0+ Nstride1 ;
380 out->FaceElements->Nodes[INDEX2(5,k,NN)]=node0+Nstride1+ Nstride0;
381 out->FaceElements->Nodes[INDEX2(6,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
382 out->FaceElements->Nodes[INDEX2(7,k,NN)]=node0+Nstride2+Nstride1 ;
383 } else {
384 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0 ;
385 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride0;
386 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+ Nstride0;
387 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2 ;
388 }
389 }
390 }
391 faceNECount+=local_NE0*local_NE2;
392 }
393 totalNECount+=NE0*NE2;
394 /* ** elements on boundary 020 (x2=1): */
395 if (local_NE1+e_offset1 == NE1) {
396 #pragma omp parallel for private(i0,i2,k,node0)
397 for (i2=0;i2<local_NE2;i2++) {
398 for (i0=0;i0<local_NE0;i0++) {
399 k=i0+local_NE0*i2+faceNECount;
400 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(NE1-1)+Nstride2*N_PER_E*(i2+e_offset2);
401
402 out->FaceElements->Id[k]=(i2+e_offset2)+NE2*(i0+e_offset0)+totalNECount;
403 out->FaceElements->Tag[k]=20;
404 out->FaceElements->Owner[k]=myRank;
405
406 if (useElementsOnFace) {
407 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0+ Nstride1 ;
408 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+Nstride2+Nstride1 ;
409 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
410 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride1+Nstride0 ;
411
412 out->FaceElements->Nodes[INDEX2(4,k,NN)]=node0 ;
413 out->FaceElements->Nodes[INDEX2(5,k,NN)]=node0+Nstride2 ;
414 out->FaceElements->Nodes[INDEX2(6,k,NN)]=node0+Nstride2+ Nstride0;
415 out->FaceElements->Nodes[INDEX2(7,k,NN)]=node0+ Nstride0;
416 } else {
417 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0+ Nstride1 ;
418 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+Nstride2+Nstride1 ;
419 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
420 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+ Nstride1+Nstride0;
421 }
422 }
423 }
424 faceNECount+=local_NE0*local_NE2;
425 }
426 totalNECount+=NE0*NE2;
427 }
428 /* add tag names */
429 Finley_Mesh_addTagMap(out,"top", 200);
430 Finley_Mesh_addTagMap(out,"bottom", 100);
431 Finley_Mesh_addTagMap(out,"left", 1);
432 Finley_Mesh_addTagMap(out,"right", 2);
433 Finley_Mesh_addTagMap(out,"front", 10);
434 Finley_Mesh_addTagMap(out,"back", 20);
435
436 /* prepare mesh for further calculatuions:*/
437 if (Finley_noError()) {
438 Finley_Mesh_resolveNodeIds(out);
439 }
440 if (Finley_noError()) {
441 Finley_Mesh_prepare(out, optimize);
442 }
443 }
444
445 if (!Finley_noError()) {
446 Finley_Mesh_free(out);
447 }
448 /* free up memory */
449 Paso_MPIInfo_free( mpi_info );
450 #ifdef Finley_TRACE
451 printf("timing: mesh generation: %.4e sec\n",Finley_timer()-time0);
452 #endif
453
454 return out;
455 }

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26