/[escript]/branches/domexper/dudley/src/ElementFile_jacobeans.c
ViewVC logotype

Annotation of /branches/domexper/dudley/src/ElementFile_jacobeans.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 616 - (hide annotations)
Wed Mar 22 02:46:56 2006 UTC (13 years, 11 months ago) by elspeth
Original Path: trunk/finley/src/ElementFile_borrowLocalVolume.c
File MIME type: text/plain
File size: 20604 byte(s)
Copyright added to more source files.

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

  ViewVC Help
Powered by ViewVC 1.1.26