/[escript]/trunk/finley/src/ElementFile_borrowLocalVolume.c
ViewVC logotype

Contents of /trunk/finley/src/ElementFile_borrowLocalVolume.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 552 - (show annotations)
Wed Feb 22 03:18:07 2006 UTC (13 years, 4 months ago) by gross
File MIME type: text/plain
File size: 20931 byte(s)
and more work on saving the element jacobians (please don;t look at the code)
1 /*
2 ******************************************************************************
3 * *
4 * COPYRIGHT ACcESS 2003,2004,2005,2006 - All Rights Reserved *
5 * *
6 * This software is the property of ACcESS. No part of this code *
7 * may be copied in any form or by any means without the expressed written *
8 * consent of ACcESS. Copying, use or modification of this software *
9 * by any unauthorised person is illegal unless that person has a software *
10 * license agreement with ACcESS. *
11 * *
12 ******************************************************************************
13 */
14
15
16 /**************************************************************/
17
18 /**************************************************************/
19
20 /* Author: gross@access.edu.au */
21 /* Version: $Id$ */
22
23 /**************************************************************/
24
25 #include "ElementFile.h"
26 #include "Util.h"
27 #ifdef _OPENMP
28 #include <omp.h>
29 #endif
30
31
32 /**************************************************************/
33
34 double* Finley_ElementFile_borrowDSDV(Finley_ElementFile* self) {
35 }
36 double* Finley_ElementFile_borrowDSLinearDV(Finley_ElementFile* self) {
37 }
38 double* Finley_ElementFile_borrowLocalVolume(Finley_ElementFile* self) {
39
40 if (! self->volume_is_valid) {
41 numDim_t local_numDim= ;
42 numDim_t numDim= ;
43 numDim_t numQuad= ;
44 if (self->volume==NULL) self->volume=MEMALLOC(self->numElements,double);
45 if (self->DvDV==NULL) self->DvDV=MEMALLOC(self->numElements*local_numDim*numDim,double);
46 if (! (Finley_checkPtr(self->volume) || Finley_checkPtr(self->DvDV)) ) {
47 self->volume_is_valid=TRUE;
48
49 if (numDim==1 && local_numDim==1) {
50 } else if (numDim==2 && local_numDim==1) {
51
52 } else if (numDim==2 && local_numDim==2) {
53
54 } else if (numDim==3 && local_numDim==1) {
55
56 } else if (numDim==3 && local_numDim==2) {
57
58 } else if (numDim==3 && local_numDim==3) {
59
60 }
61 }
62 }
63
64 return self->volume;
65 }
66
67 char error_msg[LenErrorMsg_MAX];
68 double *EM_S=NULL,*EM_F=NULL,*V=NULL,*dVdv=NULL,*dSdV=NULL,*Vol=NULL,*dvdV=NULL;
69 double time0;
70 numDim_t numDimensions[ESCRIPT_MAX_DATA_RANK],e,q;
71 Assemble_Parameters p;
72 index_t *index_row=NULL,*index_col=NULL,color;
73 Finley_resetError();
74
75 if (nodes==NULL || elements==NULL) return;
76 if (S==NULL && isEmpty(F)) return;
77
78 /* set all parameters in p*/
79 Assemble_getAssembleParameters(nodes,elements,S,F,&p);
80 if (! Finley_noError()) return;
81
82 /* this function assumes NS=NN */
83 if (p.NN!=p.NS) {
84 Finley_setError(SYSTEM_ERROR,"Finley_Assemble_PDE: for Finley_Assemble_PDE numNodes and numShapes have to be identical.");
85 return;
86 }
87 if (p.numDim!=p.numElementDim) {
88 Finley_setError(SYSTEM_ERROR,"Finley_Assemble_PDE: Finley_Assemble_PDE accepts volume elements only.");
89 return;
90 }
91 /* get a functionspace */
92 type_t funcspace=UNKNOWN;
93 updateFunctionSpaceType(funcspace,A);
94 updateFunctionSpaceType(funcspace,B);
95 updateFunctionSpaceType(funcspace,C);
96 updateFunctionSpaceType(funcspace,D);
97 updateFunctionSpaceType(funcspace,X);
98 updateFunctionSpaceType(funcspace,Y);
99 if (funcspace==UNKNOWN) return; /* all data are empty */
100
101 /* check if all function spaces are the same */
102
103 if (! functionSpaceTypeEqual(funcspace,A) ) {
104 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: unexpected function space type for coefficient A");
105 }
106 if (! functionSpaceTypeEqual(funcspace,B) ) {
107 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: unexpected function space type for coefficient B");
108 }
109 if (! functionSpaceTypeEqual(funcspace,C) ) {
110 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: unexpected function space type for coefficient C");
111 }
112 if (! functionSpaceTypeEqual(funcspace,D) ) {
113 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: unexpected function space type for coefficient D");
114 }
115 if (! functionSpaceTypeEqual(funcspace,X) ) {
116 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: unexpected function space type for coefficient X");
117 }
118 if (! functionSpaceTypeEqual(funcspace,Y) ) {
119 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: unexpected function space type for coefficient Y");
120 }
121
122 /* check if all function spaces are the same */
123
124 if (! numSamplesEqual(A,p.numQuad,elements->numElements) ) {
125 sprintf(error_msg,"Finley_Assemble_PDE: sample points of coefficient A don't match (%d,%d)",p.numQuad,elements->numElements);
126 Finley_setError(TYPE_ERROR,error_msg);
127 }
128
129 if (! numSamplesEqual(B,p.numQuad,elements->numElements) ) {
130 sprintf(error_msg,"Finley_Assemble_PDE: sample points of coefficient B don't match (%d,%d)",p.numQuad,elements->numElements);
131 Finley_setError(TYPE_ERROR,error_msg);
132 }
133
134 if (! numSamplesEqual(C,p.numQuad,elements->numElements) ) {
135 sprintf(error_msg,"Finley_Assemble_PDE: sample points of coefficient C don't match (%d,%d)",p.numQuad,elements->numElements);
136 Finley_setError(TYPE_ERROR,error_msg);
137 }
138
139 if (! numSamplesEqual(D,p.numQuad,elements->numElements) ) {
140 sprintf(error_msg,"Finley_Assemble_PDE: sample points of coefficient D don't match (%d,%d)",p.numQuad,elements->numElements);
141 Finley_setError(TYPE_ERROR,error_msg);
142 }
143
144 if (! numSamplesEqual(X,p.numQuad,elements->numElements) ) {
145 sprintf(error_msg,"Finley_Assemble_PDE: sample points of coefficient X don't match (%d,%d)",p.numQuad,elements->numElements);
146 Finley_setError(TYPE_ERROR,error_msg);
147 }
148
149 if (! numSamplesEqual(Y,p.numQuad,elements->numElements) ) {
150 sprintf(error_msg,"Finley_Assemble_PDE: sample points of coefficient Y don't match (%d,%d)",p.numQuad,elements->numElements);
151 Finley_setError(TYPE_ERROR,error_msg);
152 }
153
154 /* check the numDimensions: */
155
156 if (p.numEqu==1 && p.numComp==1) {
157 if (!isEmpty(A)) {
158 numDimensions[0]=p.numDim;
159 numDimensions[1]=p.numDim;
160 if (!isDataPointShapeEqual(A,2,numDimensions)) {
161 sprintf(error_msg,"Finley_Assemble_PDE: coefficient A: illegal shape, expected shape (%d,%d)",numDimensions[0],numDimensions[1]);
162 Finley_setError(TYPE_ERROR,error_msg);
163 }
164 }
165 if (!isEmpty(B)) {
166 numDimensions[0]=p.numDim;
167 if (!isDataPointShapeEqual(B,1,numDimensions)) {
168 sprintf(error_msg,"Finley_Assemble_PDE: coefficient B: illegal shape (%d,)",numDimensions[0]);
169 Finley_setError(TYPE_ERROR,error_msg);
170 }
171 }
172 if (!isEmpty(C)) {
173 numDimensions[0]=p.numDim;
174 if (!isDataPointShapeEqual(C,1,numDimensions)) {
175 sprintf(error_msg,"Finley_Assemble_PDE: coefficient C, expected shape (%d,)",numDimensions[0]);
176 Finley_setError(TYPE_ERROR,error_msg);
177 }
178 }
179 if (!isEmpty(D)) {
180 if (!isDataPointShapeEqual(D,0,numDimensions)) {
181 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: coefficient D, rank 0 expected.");
182 }
183 }
184 if (!isEmpty(X)) {
185 numDimensions[0]=p.numDim;
186 if (!isDataPointShapeEqual(X,1,numDimensions)) {
187 sprintf(error_msg,"Finley_Assemble_PDE: coefficient X, expected shape (%d,",numDimensions[0]);
188 Finley_setError(TYPE_ERROR,error_msg);
189 }
190 }
191 if (!isEmpty(Y)) {
192 if (!isDataPointShapeEqual(Y,0,numDimensions)) {
193 Finley_setError(TYPE_ERROR,"Finley_Assemble_PDE: coefficient Y, rank 0 expected.");
194 }
195 }
196 } else {
197 if (!isEmpty(A)) {
198 numDimensions[0]=p.numEqu;
199 numDimensions[1]=p.numDim;
200 numDimensions[2]=p.numComp;
201 numDimensions[3]=p.numDim;
202 if (!isDataPointShapeEqual(A,4,numDimensions)) {
203 sprintf(error_msg,"Finley_Assemble_PDE: coefficient A, expected shape (%d,%d,%d,%d)",numDimensions[0],numDimensions[1],numDimensions[2],numDimensions[3]);
204 Finley_setError(TYPE_ERROR,error_msg);
205 }
206 }
207 if (!isEmpty(B)) {
208 numDimensions[0]=p.numEqu;
209 numDimensions[1]=p.numDim;
210 numDimensions[2]=p.numComp;
211 if (!isDataPointShapeEqual(B,3,numDimensions)) {
212 sprintf(error_msg,"Finley_Assemble_PDE: coefficient B, expected shape (%d,%d,%d)",numDimensions[0],numDimensions[1],numDimensions[2]);
213 Finley_setError(TYPE_ERROR,error_msg);
214 }
215 }
216 if (!isEmpty(C)) {
217 numDimensions[0]=p.numEqu;
218 numDimensions[1]=p.numComp;
219 numDimensions[2]=p.numDim;
220 if (!isDataPointShapeEqual(C,3,numDimensions)) {
221 sprintf(error_msg,"Finley_Assemble_PDE: coefficient C, expected shape (%d,%d,%d)",numDimensions[0],numDimensions[1],numDimensions[2]);
222 Finley_setError(TYPE_ERROR,error_msg);
223 }
224 }
225 if (!isEmpty(D)) {
226 numDimensions[0]=p.numEqu;
227 numDimensions[1]=p.numComp;
228 if (!isDataPointShapeEqual(D,2,numDimensions)) {
229 sprintf(error_msg,"Finley_Assemble_PDE: coefficient D, expected shape (%d,%d)",numDimensions[0],numDimensions[1]);
230 Finley_setError(TYPE_ERROR,error_msg);
231 }
232 }
233 if (!isEmpty(X)) {
234 numDimensions[0]=p.numEqu;
235 numDimensions[1]=p.numDim;
236 if (!isDataPointShapeEqual(X,2,numDimensions)) {
237 sprintf(error_msg,"Finley_Assemble_PDE: coefficient X, expected shape (%d,%d)",numDimensions[0],numDimensions[1]);
238 Finley_setError(TYPE_ERROR,error_msg);
239 }
240 }
241 if (!isEmpty(Y)) {
242 numDimensions[0]=p.numEqu;
243 if (!isDataPointShapeEqual(Y,1,numDimensions)) {
244 sprintf(error_msg,"Finley_Assemble_PDE: coefficient Y, expected shape (%d,)",numDimensions[0]);
245 Finley_setError(TYPE_ERROR,error_msg);
246 }
247 }
248 }
249
250 if (Finley_noError()) {
251 time0=Finley_timer();
252 #pragma omp parallel private(index_col,index_row,EM_S,EM_F,V,dVdv,dSdV,Vol,dvdV,color,q) \
253 firstprivate(elements,nodes,S,F,A,B,C,D,X,Y)
254 {
255 EM_S=EM_F=V=dVdv=dSdV=Vol=dvdV=NULL;
256 index_row=index_col=NULL;
257
258 /* allocate work arrays: */
259
260 EM_S=(double*) THREAD_MEMALLOC(p.NN_row*p.NN_col*p.numEqu*p.numComp,double);
261 EM_F=(double*) THREAD_MEMALLOC(p.NN_row*p.numEqu,double);
262 V=(double*) THREAD_MEMALLOC(p.NN*p.numDim,double);
263 dVdv=(double*) THREAD_MEMALLOC(p.numDim*p.numDim*p.numQuad,double);
264 dvdV=(double*) THREAD_MEMALLOC(p.numDim*p.numDim*p.numQuad,double);
265 dSdV=(double*) THREAD_MEMALLOC(p.NS_row*p.numQuad*p.numDim,double);
266 Vol=(double*) THREAD_MEMALLOC(p.numQuad,double);
267 index_col=(index_t*) THREAD_MEMALLOC(p.NN_col,index_t);
268 index_row=(index_t*) THREAD_MEMALLOC(p.NN_row,index_t);
269
270 if (! (Finley_checkPtr(EM_S) || Finley_checkPtr(EM_F) || Finley_checkPtr(V) || Finley_checkPtr(index_col) ||
271 Finley_checkPtr(index_row) || Finley_checkPtr(dVdv) || Finley_checkPtr(dSdV) || Finley_checkPtr(Vol) )) {
272
273 /* open loop over all colors: */
274 for (color=elements->minColor;color<=elements->maxColor;color++) {
275 /* open loop over all elements: */
276 #pragma omp for private(e) schedule(static)
277 for(e=0;e<elements->numElements;e++){
278 if (elements->Color[e]==color) {
279 for (q=0;q<p.NN_row;q++) index_row[q]=p.label_row[elements->Nodes[INDEX2(p.row_node[q],e,p.NN)]];
280 /* gather V-coordinates of nodes into V: */
281 //============================
282 Finley_Util_Gather_double(NN,&(self->Nodes[INDEX2(0,e,NN)]),numDim,nodes->Coordinates,V);
283
284 void Finley_LocalVolume_33(ElementFile* elem,NodeFile* nodes) {
285 char error_msg[LenErrorMsg_MAX];
286 double tol=TOL*(node->diameter)**(node->dim);
287 #pragma omp parallel
288 {
289 register double DVDv00,DVDv10,DVDv20,DVDv01,DVDv11,DVDv21,DVDv02,DVDv12,DVDv22,D;
290 register double x0_tmp, x1_tmp, x2_tmp, dSdv0_tmp, dSdv1_tmp, dSdv2_tmp;
291 double x0[NN],x1[NN],x2[NN];
292 index_t q,k;
293 #pragma omp for private(e) schedule(static)
294 for(e=0;e<elements->numElements;e++){
295
296 for (k=0;k<NN;++k) {
297 x0[k]=nodes->Coordinates[INDEX2(0,elem->Nodes[INDEX2(k,e,NN)],numDim)];
298 x1[k]=nodes->Coordinates[INDEX2(1,elem->Nodes[INDEX2(k,e,NN)],numDim)];
299 x2[k]=nodes->Coordinates[INDEX2(2,elem->Nodes[INDEX2(k,e,NN)],numDim)];
300 }
301
302 for (q=0;q<numQuad;++q) {
303 x0_tmp=x0[0];
304 x1_tmp=x1[0];
305 x2_tmp=x2[0];
306
307 dSdv0_tmp=elem->referenceElement->dSdv[INDEX3(0,0,q,NN,local_numDim)];
308 dSdv1_tmp=elem->referenceElement->dSdv[INDEX3(0,1,q,NN,local_numDim)];
309 dSdv2_tmp=elem->referenceElement->dSdv[INDEX3(0,2,q,NN,local_numDim)];
310
311 DVDv00=x0_tmp*dSdv0_tmp;
312 DVDv10=x1_tmp*dSdv0_tmp;
313 DVDv20=x2_tmp*dSdv0_tmp;
314
315 DVDv01=x0_tmp*dSdv1_tmp;
316 DVDv11=x1_tmp*dSdv1_tmp;
317 DVDv21=x2_tmp*dSdv1_tmp;
318
319 DVDv02=x0_tmp*dSdv2_tmp;
320 DVDv12=x1_tmp*dSdv2_tmp;
321 DVDv22=x2_tmp*dSdv2_tmp;
322
323 for (k=1;k<NN;++k) {
324 x0_tmp=x0[k];
325 x1_tmp=x1[k];
326 x2_tmp=x2[k];
327
328 dSdv0_tmp=elem->referenceElement->dSdv[INDEX3(k,0,q,NN,local_numDim)];
329 dSdv1_tmp=elem->referenceElement->dSdv[INDEX3(k,1,q,NN,local_numDim)];
330 dSdv2_tmp=elem->referenceElement->dSdv[INDEX3(k,2,q,NN,local_numDim)];
331
332 DVDv00+=x0_tmp*dSdv0_tmp;
333 DVDv10+=x1_tmp*dSdv0_tmp;
334 DVDv20+=x2_tmp*dSdv0_tmp;
335
336 DVDv01+=x0_tmp*dSdv1_tmp;
337 DVDv11+=x1_tmp*dSdv1_tmp;
338 DVDv21+=x2_tmp*dSdv1_tmp;
339
340 DVDv02+=x0_tmp*dSdv2_tmp;
341 DVDv12+=x1_tmp*dSdv2_tmp;
342 DVDv22+=x2_tmp*dSdv2_tmp;
343 }
344 D = DVDv00*(DVDv11*DVDv22-DVDv12*DVDv21)+
345 DVDv01*(DVDv20*DVDv12-DVDv10*DVDv22)+
346 DVDv02*(DVDv10*DVDv21-DVDv20*DVDv11);
347 if (ABS(D)<tol){
348 sprintf(error_msg,"Finley_LocalVolume_33: volume element %d of type %s ",e,elem->referenceElement->name,ABS(D),tol);
349 Finley_setError(ZERO_DIVISION_ERROR,error_msg);
350 } else {
351 D=1./D;
352 elem->DvDV[INDEX3(0,0,q,local_numDim,numDim)]=(DVDv11*DVDv22-DVDv12*DVDv21)*D;
353 elem->DvDV[INDEX3(1,0,q,local_numDim,numDim)]=(DVDv20*DVDv12-DVDv10*DVDv22)*D;
354 elem->DvDV[INDEX3(2,0,q,local_numDim,numDim)]=(DVDv10*DVDv21-DVDv20*DVDv11)*D;
355 elem->DvDV[INDEX3(0,1,q,local_numDim,numDim)]=(DVDv02*DVDv21-DVDv01*DVDv22)*D;
356 elem->DvDV[INDEX3(1,1,q,local_numDim,numDim)]=(DVDv00*DVDv22-DVDv20*DVDv02)*D;
357 elem->DvDV[INDEX3(2,1,q,local_numDim,numDim)]=(DVDv01*DVDv20-DVDv00*DVDv21)*D;
358 elem->DvDV[INDEX3(0,2,q,local_numDim,numDim)]=(DVDv01*DVDv12-DVDv02*DVDv11)*D;
359 elem->DvDV[INDEX3(1,2,q,local_numDim,numDim)]=(DVDv02*DVDv10-DVDv00*DVDv12)*D;
360 elem->DvDV[INDEX3(2,2,q,local_numDim,numDim)]=(DVDv00*DVDv11-DVDv01*DVDv10)*D;
361 elem->volume[q]=ABS(D)*referenceElement->QuadWeights[q];
362 }
363 }
364
365 }
366
367
368
369
370
371 /* calculate dVdv(i,j,q)=V(i,k)*DSDv(k,j,q) */
372 Finley_Util_SmallMatMult(numDim,numDim*numQuad,dVdv,NN,V,referenceElement->dSdv);
373 /* dvdV=invert(dVdv) inplace */
374 Finley_Util_InvertSmallMat(numQuad,numDim,dVdv,dvdV,Vol);
375 for (q=0;q<numQuad;q++) self->volume[q]=ABS(self.volume[q]*p.referenceElement->QuadWeights[q]);
376 /* calculate dSdV=DSDv*DvDV */
377 Finley_Util_SmallMatSetMult(p.numQuad,p.NS_row,p.numDim,dSdV,p.numDim,p.referenceElement_row->dSdv,dvdV);
378 /* scale volume: */
379 //============================
380
381 /* integration for the stiffness matrix: */
382 /* in order to optimze the number of operations the case of constants coefficience needs a bit more work */
383 /* to make use of some symmetry. */
384
385 if (S!=NULL) {
386 for (q=0;q<p.NN_row*p.NN_col*p.numEqu*p.numComp;q++) EM_S[q]=0;
387 if (p.numEqu==1 && p.numComp==1) {
388 Finley_Assemble_PDEMatrix_Single2(p.NS_row,p.numDim,p.numQuad,
389 p.referenceElement_row->S,dSdV,Vol,p.NN_row,EM_S,
390 getSampleData(A,e),isExpanded(A),
391 getSampleData(B,e),isExpanded(B),
392 getSampleData(C,e),isExpanded(C),
393 getSampleData(D,e),isExpanded(D));
394 } else {
395 Finley_Assemble_PDEMatrix_System2(p.NS_row,p.numDim,p.numQuad,p.numEqu,p.numComp,
396 p.referenceElement_row->S,dSdV,Vol,p.NN_row,EM_S,
397 getSampleData(A,e),isExpanded(A),
398 getSampleData(B,e),isExpanded(B),
399 getSampleData(C,e),isExpanded(C),
400 getSampleData(D,e),isExpanded(D));
401 }
402 for (q=0;q<p.NN_col;q++) index_col[q]=p.label_col[elements->Nodes[INDEX2(p.col_node[q],e,p.NN)]];
403 Finley_Assemble_addToSystemMatrix(S,p.NN_row,index_row,p.numEqu,p.NN_col,index_col,p.numComp,EM_S);
404 }
405 if (!isEmpty(F)) {
406 for (q=0;q<p.NN_row*p.numEqu;q++) EM_F[q]=0;
407 if (p.numEqu==1) {
408 Finley_Assemble_RHSMatrix_Single(p.NS_row,p.numDim,p.numQuad,
409 p.referenceElement_row->S,dSdV,Vol,p.NN_row,EM_F,
410 getSampleData(X,e),isExpanded(X),
411 getSampleData(Y,e),isExpanded(Y));
412 } else {
413 Finley_Assemble_RHSMatrix_System(p.NS_row,p.numDim,p.numQuad,
414 p.numEqu,p.referenceElement_row->S,dSdV,Vol,p.NN_row,EM_F,
415 getSampleData(X,e),isExpanded(X),
416 getSampleData(Y,e),isExpanded(Y));
417 }
418 /* add */
419 Finley_Util_AddScatter(p.NN_row,index_row,p.numEqu,EM_F,getSampleData(F,0));
420 }
421 }
422 }
423 }
424 }
425 /* clean up */
426 THREAD_MEMFREE(EM_S);
427 THREAD_MEMFREE(EM_F);
428 THREAD_MEMFREE(V);
429 THREAD_MEMFREE(dVdv);
430 THREAD_MEMFREE(dvdV);
431 THREAD_MEMFREE(dSdV);
432 THREAD_MEMFREE(Vol);
433 THREAD_MEMFREE(index_col);
434 THREAD_MEMFREE(index_row);
435 }
436 #ifdef Finley_TRACE
437 printf("timing: assemblage PDE: %.4e sec\n",Finley_timer()-time0);
438 #endif
439 }
440 }
441 /*
442 * $Log$
443 * Revision 1.8 2005/09/15 03:44:21 jgs
444 * Merge of development branch dev-02 back to main trunk on 2005-09-15
445 *
446 * Revision 1.7 2005/09/01 03:31:35 jgs
447 * Merge of development branch dev-02 back to main trunk on 2005-09-01
448 *
449 * Revision 1.6 2005/08/12 01:45:42 jgs
450 * erge of development branch dev-02 back to main trunk on 2005-08-12
451 *
452 * Revision 1.5.2.3 2005/09/07 06:26:17 gross
453 * the solver from finley are put into the standalone package paso now
454 *
455 * Revision 1.5.2.2 2005/08/24 02:02:18 gross
456 * timing output switched off. solver output can be swiched through getSolution(verbose=True) now.
457 *
458 * Revision 1.5.2.1 2005/08/03 08:54:27 gross
459 * contact element assemblage was called with wrong element table pointer
460 *
461 * Revision 1.5 2005/07/08 04:07:46 jgs
462 * Merge of development branch back to main trunk on 2005-07-08
463 *
464 * Revision 1.4 2004/12/15 07:08:32 jgs
465 * *** empty log message ***
466 * Revision 1.1.1.1.2.2 2005/06/29 02:34:47 gross
467 * some changes towards 64 integers in finley
468 *
469 * Revision 1.1.1.1.2.1 2004/11/24 01:37:12 gross
470 * some changes dealing with the integer overflow in memory allocation. Finley solves 4M unknowns now
471 *
472 *
473 *
474 */

  ViewVC Help
Powered by ViewVC 1.1.26