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

Annotation of /trunk/finley/src/ElementFile_jacobeans.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 552 - (hide annotations)
Wed Feb 22 03:18:07 2006 UTC (13 years, 8 months ago) by gross
Original Path: trunk/finley/src/ElementFile_borrowLocalVolume.c
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 gross 552 /*
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