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

Diff of /branches/domexper/dudley/src/Util.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/finley/src/finleyC/Util.c revision 147 by jgs, Fri Aug 12 01:45:47 2005 UTC trunk/finley/src/Util.c revision 782 by bcumming, Tue Jul 18 00:47:47 2006 UTC
# Line 1  Line 1 
1  /* $Id$ */  /*
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    
# Line 6  Line 16 
16    
17  /**************************************************************/  /**************************************************************/
18    
 /*   Copyrights by ACcESS Australia, 2003 */  
19  /*   author: gross@access.edu.au */  /*   author: gross@access.edu.au */
20  /*   Version: $Id$ */  /*   Version: $Id$ */
21    
22  /**************************************************************/  /**************************************************************/
23    
 #include "Common.h"  
24  #include "Finley.h"  #include "Finley.h"
25  #include "Util.h"  #include "Util.h"
26    
27  #ifdef _OPENMP  #ifdef _OPENMP
28  #include <omp.h>  #include <omp.h>
29  #endif  #endif
# Line 75  void Finley_Util_AddScatter(dim_t len,in Line 84  void Finley_Util_AddScatter(dim_t len,in
84     }     }
85  }  }
86    
87    #ifdef PASO_MPI
88    /* same as AddScatter(), but checks that value index[] is below an upper bound upperBound before  
89       addition. This is used to ensure that only the influence of local DOF is added */
90    /*        out(1:numData,index[p])+=in(1:numData,p)
91            where p = {k=1...len , index[k]<upperBound}*/
92    void Finley_Util_AddScatter_upperBound(dim_t len,index_t* index,dim_t numData,double* in,double * out, index_t upperBound){
93       dim_t i,s;
94       for (s=0;s<len;s++) {
95           for(i=0;i<numData;i++) {
96              //#pragma omp atomic
97              if( index[s]<upperBound )
98                out[INDEX2(i,index[s],numData)]+=in[INDEX2(i,s,numData)];
99           }
100       }
101    }  
102    
103    
104    #endif
105    
106  /*    multiplies two matrices */  /*    multiplies two matrices */
107    
108  /*          A(1:A1,1:A2)=B(1:A1,1:B2)*C(1:B2,1:A2) */  /*          A(1:A1,1:A2)=B(1:A1,1:B2)*C(1:B2,1:A2) */
# Line 124  void Finley_Util_InvertSmallMat(dim_t le Line 152  void Finley_Util_InvertSmallMat(dim_t le
152                 D=1./D;                 D=1./D;
153                 invA[q]=D;                 invA[q]=D;
154              } else {              } else {
155                 Finley_ErrorCode=ZERO_DIVISION_ERROR;                 Finley_setError(ZERO_DIVISION_ERROR,"__FILE__: Non-regular matrix");
                sprintf(Finley_ErrorMsg,"Non-regular matrix");  
156                 return;                 return;
157              }              }
158           }           }
# Line 147  void Finley_Util_InvertSmallMat(dim_t le Line 174  void Finley_Util_InvertSmallMat(dim_t le
174                 invA[INDEX3(0,1,q,2,2)]=-A12*D;                 invA[INDEX3(0,1,q,2,2)]=-A12*D;
175                 invA[INDEX3(1,1,q,2,2)]= A11*D;                 invA[INDEX3(1,1,q,2,2)]= A11*D;
176              } else {              } else {
177                 Finley_ErrorCode=ZERO_DIVISION_ERROR;                 Finley_setError(ZERO_DIVISION_ERROR,"__FILE__: Non-regular matrix");
                sprintf(Finley_ErrorMsg,"Non-regular matrix");  
178                 return;                 return;
179              }              }
180           }           }
# Line 180  void Finley_Util_InvertSmallMat(dim_t le Line 206  void Finley_Util_InvertSmallMat(dim_t le
206                 invA[INDEX3(1,2,q,3,3)]=(A13*A21-A11*A23)*D;                 invA[INDEX3(1,2,q,3,3)]=(A13*A21-A11*A23)*D;
207                 invA[INDEX3(2,2,q,3,3)]=(A11*A22-A12*A21)*D;                 invA[INDEX3(2,2,q,3,3)]=(A11*A22-A12*A21)*D;
208              } else {              } else {
209                 Finley_ErrorCode=ZERO_DIVISION_ERROR;                 Finley_setError(ZERO_DIVISION_ERROR,"__FILE__: Non-regular matrix");
                sprintf(Finley_ErrorMsg,"Non-regular matrix");  
210                 return;                 return;
211              }              }
212           }           }
# Line 251  void  Finley_NormalVector(dim_t len, dim Line 276  void  Finley_NormalVector(dim_t len, dim
276              A21=A[INDEX3(1,0,q,2,dim1)];              A21=A[INDEX3(1,0,q,2,dim1)];
277              length = sqrt(A11*A11+A21*A21);              length = sqrt(A11*A11+A21*A21);
278              if (! length>0) {              if (! length>0) {
279                 Finley_ErrorCode=ZERO_DIVISION_ERROR;                 Finley_setError(ZERO_DIVISION_ERROR,"__FILE__: area equals zero.");
                sprintf(Finley_ErrorMsg,"area equals zero.");  
280                 return;                 return;
281              } else {              } else {
282                 invlength=1./length;                 invlength=1./length;
# Line 274  void  Finley_NormalVector(dim_t len, dim Line 298  void  Finley_NormalVector(dim_t len, dim
298              CO_A33=A11*A22-A21*A12;              CO_A33=A11*A22-A21*A12;
299              length=sqrt(CO_A13*CO_A13+CO_A23*CO_A23+CO_A33*CO_A33);              length=sqrt(CO_A13*CO_A13+CO_A23*CO_A23+CO_A33*CO_A33);
300              if (! length>0) {              if (! length>0) {
301                 Finley_ErrorCode=ZERO_DIVISION_ERROR;                 Finley_setError(ZERO_DIVISION_ERROR,"__FILE__: area equals zero.");
                sprintf(Finley_ErrorMsg,"area equals zero.");  
302                 return;                 return;
303              } else {              } else {
304                 invlength=1./length;                 invlength=1./length;
# Line 349  int Finley_Util_ValueAndIndex_compar(con Line 372  int Finley_Util_ValueAndIndex_compar(con
372     e2=(Finley_Util_ValueAndIndex*) arg2;     e2=(Finley_Util_ValueAndIndex*) arg2;
373     if (e1->value < e2->value) return -1;     if (e1->value < e2->value) return -1;
374     if (e1->value > e2->value) return  1;     if (e1->value > e2->value) return  1;
375       if (e1->index < e2->index) return -1;
376       if (e1->index > e2->index) return  1;
377    
378     return 0;     return 0;
379  }  }
380    
381  void Finley_Util_sortValueAndIndex(dim_t n,Finley_Util_ValueAndIndex* array) {  void Finley_Util_sortValueAndIndex(dim_t n,Finley_Util_ValueAndIndex* array) {
382       /* OMP : needs parallelization !*/       /* OMP : needs parallelization !*/
383       qsort(array,n,sizeof(Finley_Util_ValueAndIndex),Finley_Util_ValueAndIndex_compar);       qsort(array,n,sizeof(Finley_Util_ValueAndIndex),Finley_Util_ValueAndIndex_compar);
# Line 472  void Finley_copyDouble(dim_t n,double* s Line 499  void Finley_copyDouble(dim_t n,double* s
499    for (i=0;i<n;i++) target[i]=source[i];    for (i=0;i<n;i++) target[i]=source[i];
500  }  }
501    
502    #ifdef PASO_MPI
503    void Finley_printDoubleArray( FILE *fid, dim_t n, double *array, char *name  )
504    {
505      index_t i;
506      
507      if( name )
508        fprintf( fid, "%s [ ", name );
509      else
510        fprintf( fid, "[ " );  
511      for( i=0; i<(n<60 ? n : 60); i++ )
512        fprintf( fid, "%g ", array[i] );
513      if( n>=30 )
514        fprintf( fid, "... " );
515      fprintf( fid, "]\n" );
516    }
517    void Finley_printIntArray( FILE *fid, dim_t n, int *array, char *name  )
518    {
519      index_t i;
520      
521      if( name )
522        fprintf( fid, "%s [ ", name );
523      else
524        fprintf( fid, "[ " );  
525      for( i=0; i<(n<60 ? n : 60); i++ )
526        fprintf( fid, "%d ", array[i] );
527      if( n>=30 )
528        fprintf( fid, "... " );
529      fprintf( fid, "]\n" );
530    }
531    void Finley_printMaskArray( FILE *fid, dim_t n, int *array, char *name  )
532    {
533      index_t i;
534      
535      if( name )
536        fprintf( fid, "%s [ ", name );
537      else
538        fprintf( fid, "[ " );  
539      for( i=0; i<(n<60 ? n : 60); i++ )
540        if( array[i]!=-1 )
541          fprintf( fid, "%3d ", array[i] );
542        else
543          fprintf( fid, "  * " );
544      if( n>=30 )
545        fprintf( fid, "... " );
546      fprintf( fid, "]\n" );
547    }
548    #endif
549    
550  /*  /*
  * $Log$  
551   * Revision 1.8  2005/08/12 01:45:43  jgs   * Revision 1.8  2005/08/12 01:45:43  jgs
552   * erge of development branch dev-02 back to main trunk on 2005-08-12   *
553     * Revision 1.7.2.2  2005/09/07 06:26:22  gross
554     * the solver from finley are put into the standalone package paso now
555   *   *
556   * Revision 1.7.2.1  2005/08/04 22:41:11  gross   * Revision 1.7.2.1  2005/08/04 22:41:11  gross
557   * some extra routines for finley that might speed-up RHS assembling in some cases (not actived right now)   * some extra routines for finley that might speed-up RHS assembling in some cases (not actived right now)

Legend:
Removed from v.147  
changed lines
  Added in v.782

  ViewVC Help
Powered by ViewVC 1.1.26