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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 700 - (show annotations)
Thu Apr 6 00:13:40 2006 UTC (13 years, 5 months ago) by gross
File size: 20604 byte(s)
A few changes in the build mechanism and the file structure so scons can build release tar files:

  * paso/src/Solver has been moved to paso/src 
  * all test_.py are now run_.py files and are assumed to be passing python tests. they can run by 
    scons py_tests and are part of the release test set
  * escript/py_src/test_ are moved to escript/test/python and are installed in to the build directory 
    (rather then the PYTHONPATH).
  * all py files in test/python which don't start with run_ or test_ are now 'local_py_tests'. they are installed i
    by not run automatically.
  * CppUnitTest is now treated as a escript module (against previous decisions).
  * scons realse builds nor tar/zip files with relvant source code (src and tests in seperate files)

the python tests don't pass yet due to path problems.


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
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