finley/src/Assemble_PDE_Single2_1D.c


/*******************************************************
*
* Copyright (c) 2003-2008 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/


/**************************************************************/

/*    assembles the system of numEq PDEs into the stiffness matrix S right hand side F  */
/*    the shape functions for test and solution must be identical */


/*      -(A_{i,j} u_,j)_i-(B_{i} u)_i+C_{j} u_,j-D u_m  and -(X_,i)_i + Y */

/*    in a 1D domain. The shape functions for test and solution must be identical  */
/*    and row_NS == row_NN                                                         */

/*    Shape of the coefficients: */

/*      A = 1 x 1 */
/*      B = 1   */
/*      C = 1   */
/*      D = scalar  */
/*      X = 1  */
/*      Y = scalar   */


/**************************************************************/


#include "Assemble.h"
#include "Util.h"
#ifdef _OPENMP
#include <omp.h>
#endif


/**************************************************************/

void  Finley_Assemble_PDE_Single2_1D(Assemble_Parameters p, Finley_ElementFile* elements,
                                     Paso_SystemMatrix* Mat, escriptDataC* F,
                                     escriptDataC* A, escriptDataC* B, escriptDataC* C, escriptDataC* D, escriptDataC* X, escriptDataC* Y) {

    #define DIM 1
    index_t color;
    dim_t e;
    __const double *A_p, *B_p, *C_p, *D_p, *X_p, *Y_p;
    double *EM_S, *EM_F, *Vol, *DSDX;
    index_t *row_index;
    register dim_t q, s,r;
    register double rtmp;
    bool_t add_EM_F, add_EM_S;

    bool_t extendedA=isExpanded(A);
    bool_t extendedB=isExpanded(B);
    bool_t extendedC=isExpanded(C);
    bool_t extendedD=isExpanded(D);
    bool_t extendedX=isExpanded(X);
    bool_t extendedY=isExpanded(Y);
    double *F_p=getSampleDataRW(F,0);
    double *S=p.row_jac->ReferenceElement->S;
    dim_t len_EM_S=p.row_NN*p.col_NN;
    dim_t len_EM_F=p.row_NN;


    #pragma omp parallel private(color, EM_S, EM_F, Vol, DSDX, A_p, B_p, C_p, D_p, X_p, Y_p, row_index, q, s,r,rtmp,add_EM_F, add_EM_S)
    {
       void* ABuff=allocSampleBuffer(A);
       void* BBuff=allocSampleBuffer(B);
       void* CBuff=allocSampleBuffer(C);
       void* DBuff=allocSampleBuffer(D);
       void* XBuff=allocSampleBuffer(X);
       void* YBuff=allocSampleBuffer(Y);
       EM_S=THREAD_MEMALLOC(len_EM_S,double);
       EM_F=THREAD_MEMALLOC(len_EM_F,double);
       row_index=THREAD_MEMALLOC(p.row_NN,index_t);


       if (!Finley_checkPtr(EM_S) && !Finley_checkPtr(EM_F) && !Finley_checkPtr(row_index) ) {

          for (color=elements->minColor;color<=elements->maxColor;color++) {
             /*  open loop over all elements: */
             #pragma omp for private(e) schedule(static)
             for(e=0;e<elements->numElements;e++){
                if (elements->Color[e]==color) {
                   Vol=&(p.row_jac->volume[INDEX2(0,e,p.numQuad)]);
                   DSDX=&(p.row_jac->DSDX[INDEX4(0,0,0,e,p.row_NN,DIM,p.numQuad)]);
                   for (q=0;q<len_EM_S;++q) EM_S[q]=0;
                   for (q=0;q<len_EM_F;++q) EM_F[q]=0;
                   add_EM_F=FALSE;
                   add_EM_S=FALSE;
                   /**************************************************************/
                   /*   process A: */
                   /**************************************************************/
                   A_p=getSampleDataRO(A,e,ABuff);
                   if (NULL!=A_p) {
                      add_EM_S=TRUE;
                      if (extendedA) {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                              rtmp=0;
                              for (q=0;q<p.numQuad;q++) {
                                 rtmp+=Vol[q]*DSDX[INDEX3(s,0,q,p.row_NN,DIM)]*A_p[INDEX3(0,0,q,DIM,DIM)]*DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
                             }
                             EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
                           }
                         }
                      } else {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                               rtmp=0;
                               for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*DSDX[INDEX3(s,0,q,p.row_NN,DIM)]*DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
                               EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*A_p[INDEX2(0,0,DIM)];
                           }
                         }
                       }
                   }
                   /**************************************************************/
                   /*   process B: */
                   /**************************************************************/
                   B_p=getSampleDataRO(B,e,BBuff);
                   if (NULL!=B_p) {
                      add_EM_S=TRUE;
                      if (extendedB) {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                             rtmp=0;
                             for (q=0;q<p.numQuad;q++) {
                                rtmp+=Vol[q]*DSDX[INDEX3(s,0,q,p.row_NN,DIM)]*B_p[INDEX2(0,q,DIM)]*S[INDEX2(r,q,p.row_NS)];
                             }
                             EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
                           }
                         }
                      } else {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                               rtmp=0;
                               for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*DSDX[INDEX3(s,0,q,p.row_NN,DIM)]*S[INDEX2(r,q,p.row_NS)];
                               EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*B_p[0];
                           }
                         }
                      }
                   }
                   /**************************************************************/
                   /*   process C: */
                   /**************************************************************/
                   C_p=getSampleDataRO(C,e,CBuff);
                   if (NULL!=C_p) {
                      add_EM_S=TRUE;
                     if (extendedC) {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                             rtmp=0;
                             for (q=0;q<p.numQuad;q++) {
                                rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)]*C_p[INDEX2(0,q,DIM)]*DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
                             }
                             EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
                           }
                         }
                     } else {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                              rtmp=0;
                              for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)]*DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
                              EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*C_p[0];
                           }
                         }
                     }
                   }
                   /************************************************************* */
                   /* process D */
                   /**************************************************************/
                   D_p=getSampleDataRO(D,e,DBuff);
                   if (NULL!=D_p) {
                     add_EM_S=TRUE;
                     if (extendedD) {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                              rtmp=0;
                              for (q=0;q<p.numQuad;q++) {
                                 rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)]*D_p[q]*S[INDEX2(r,q,p.row_NS)];
                             }
                             EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
                           }
                         }
                     } else {
                         for (s=0;s<p.row_NS;s++) {
                           for (r=0;r<p.col_NS;r++) {
                               rtmp=0;
                               for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)]*S[INDEX2(r,q,p.row_NS)];
                               EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*D_p[0];
                           }
                         }
                     }
                   }
                   /**************************************************************/
                   /*   process X: */
                   /**************************************************************/
                   X_p=getSampleDataRO(X,e,XBuff);
                   if (NULL!=X_p) {
                     add_EM_F=TRUE;
                     if (extendedX) {
                        for (s=0;s<p.row_NS;s++) {
                          rtmp=0;
                          for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*DSDX[INDEX3(s,0,q,p.row_NN,DIM)]*X_p[INDEX2(0,q,DIM)];
                          EM_F[INDEX2(0,s,p.numEqu)]+=rtmp;
                        }
                     } else {
                        for (s=0;s<p.row_NS;s++) {
                          rtmp=0;
                          for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*DSDX[INDEX3(s,0,q,p.row_NN,DIM)];
                          EM_F[INDEX2(0,s,p.numEqu)]+=rtmp*X_p[0];
                        }
                     }
                  }
                  /**************************************************************/
                  /*   process Y: */
                  /**************************************************************/
                   Y_p=getSampleDataRO(Y,e,YBuff);
                   if (NULL!=Y_p) {
                     add_EM_F=TRUE;
                     if (extendedY) {
                        for (s=0;s<p.row_NS;s++) {
                           rtmp=0;
                           for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)]*Y_p[q];
                           EM_F[INDEX2(0,s,p.numEqu)]+=rtmp;
                        }
                      } else {
                        for (s=0;s<p.row_NS;s++) {
                            rtmp=0;
                            for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)];
                            EM_F[INDEX2(0,s,p.numEqu)]+=rtmp*Y_p[0];
                        }
                      }
                    }
                    /***********************************************************************************************/
                    /* add the element matrices onto the matrix and right hand side                                */
                    /***********************************************************************************************/
                    for (q=0;q<p.row_NN;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[q],e,p.NN)]];
                    if (add_EM_F) Finley_Util_AddScatter(p.row_NN,row_index,p.numEqu,EM_F,F_p, p.row_DOF_UpperBound);
                    if (add_EM_S) Finley_Assemble_addToSystemMatrix(Mat,p.row_NN,row_index,p.numEqu,p.col_NN,row_index,p.numComp,EM_S);
   
                } /* end color check */
             } /* end element loop */
         } /* end color loop */
           
         THREAD_MEMFREE(EM_S);      /* these FREEs appear to be inside the if because if any of the allocs */
         THREAD_MEMFREE(EM_F);      /* failed it means an out of memory (which is not recoverable anyway) */
         THREAD_MEMFREE(row_index);

      } /* end of pointer check */
      freeSampleBuffer(ABuff);
      freeSampleBuffer(BBuff);
      freeSampleBuffer(CBuff);
      freeSampleBuffer(DBuff);
      freeSampleBuffer(XBuff);
      freeSampleBuffer(YBuff);
   } /* end parallel region */
}
/*
 * $Log$
 */
1
2	/*******************************************************
3	*
4	* Copyright (c) 2003-2008 by University of Queensland
5	* Earth Systems Science Computational Center (ESSCC)
6	* http://www.uq.edu.au/esscc
7	*
8	* Primary Business: Queensland, Australia
9	* Licensed under the Open Software License version 3.0
10	* http://www.opensource.org/licenses/osl-3.0.php
11	*
12	*******************************************************/
13
14
15	/**************************************************************/
16
17	/* assembles the system of numEq PDEs into the stiffness matrix S right hand side F */
18	/* the shape functions for test and solution must be identical */
19
20
21	/* -(A_{i,j} u_,j)_i-(B_{i} u)_i+C_{j} u_,j-D u_m and -(X_,i)_i + Y */
22
23	/* in a 1D domain. The shape functions for test and solution must be identical */
24	/* and row_NS == row_NN */
25
26	/* Shape of the coefficients: */
27
28	/* A = 1 x 1 */
29	/* B = 1 */
30	/* C = 1 */
31	/* D = scalar */
32	/* X = 1 */
33	/* Y = scalar */
34
35
36	/**************************************************************/
37
38
39	#include "Assemble.h"
40	#include "Util.h"
41	#ifdef _OPENMP
42	#include <omp.h>
43	#endif
44
45
46	/**************************************************************/
47
48	void Finley_Assemble_PDE_Single2_1D(Assemble_Parameters p, Finley_ElementFile* elements,
49	Paso_SystemMatrix* Mat, escriptDataC* F,
50	escriptDataC* A, escriptDataC* B, escriptDataC* C, escriptDataC* D, escriptDataC* X, escriptDataC* Y) {
51
52	#define DIM 1
53	index_t color;
54	dim_t e;
55	__const double A_p, B_p, C_p, D_p, X_p, Y_p;
56	double EM_S, EM_F, Vol, DSDX;
57	index_t *row_index;
58	register dim_t q, s,r;
59	register double rtmp;
60	bool_t add_EM_F, add_EM_S;
61
62	bool_t extendedA=isExpanded(A);
63	bool_t extendedB=isExpanded(B);
64	bool_t extendedC=isExpanded(C);
65	bool_t extendedD=isExpanded(D);
66	bool_t extendedX=isExpanded(X);
67	bool_t extendedY=isExpanded(Y);
68	double *F_p=getSampleDataRW(F,0);
69	double *S=p.row_jac->ReferenceElement->S;
70	dim_t len_EM_S=p.row_NN*p.col_NN;
71	dim_t len_EM_F=p.row_NN;
72
73
74	#pragma omp parallel private(color, EM_S, EM_F, Vol, DSDX, A_p, B_p, C_p, D_p, X_p, Y_p, row_index, q, s,r,rtmp,add_EM_F, add_EM_S)
75	{
76	void* ABuff=allocSampleBuffer(A);
77	void* BBuff=allocSampleBuffer(B);
78	void* CBuff=allocSampleBuffer(C);
79	void* DBuff=allocSampleBuffer(D);
80	void* XBuff=allocSampleBuffer(X);
81	void* YBuff=allocSampleBuffer(Y);
82	EM_S=THREAD_MEMALLOC(len_EM_S,double);
83	EM_F=THREAD_MEMALLOC(len_EM_F,double);
84	row_index=THREAD_MEMALLOC(p.row_NN,index_t);
85
86
87	if (!Finley_checkPtr(EM_S) && !Finley_checkPtr(EM_F) && !Finley_checkPtr(row_index) ) {
88
89	for (color=elements->minColor;color<=elements->maxColor;color++) {
90	/* open loop over all elements: */
91	#pragma omp for private(e) schedule(static)
92	for(e=0;e<elements->numElements;e++){
93	if (elements->Color[e]==color) {
94	Vol=&(p.row_jac->volume[INDEX2(0,e,p.numQuad)]);
95	DSDX=&(p.row_jac->DSDX[INDEX4(0,0,0,e,p.row_NN,DIM,p.numQuad)]);
96	for (q=0;q<len_EM_S;++q) EM_S[q]=0;
97	for (q=0;q<len_EM_F;++q) EM_F[q]=0;
98	add_EM_F=FALSE;
99	add_EM_S=FALSE;
100	/**************************************************************/
101	/* process A: */
102	/**************************************************************/
103	A_p=getSampleDataRO(A,e,ABuff);
104	if (NULL!=A_p) {
105	add_EM_S=TRUE;
106	if (extendedA) {
107	for (s=0;s<p.row_NS;s++) {
108	for (r=0;r<p.col_NS;r++) {
109	rtmp=0;
110	for (q=0;q<p.numQuad;q++) {
111	rtmp+=Vol[q]DSDX[INDEX3(s,0,q,p.row_NN,DIM)]A_p[INDEX3(0,0,q,DIM,DIM)]*DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
112	}
113	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
114	}
115	}
116	} else {
117	for (s=0;s<p.row_NS;s++) {
118	for (r=0;r<p.col_NS;r++) {
119	rtmp=0;
120	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]DSDX[INDEX3(s,0,q,p.row_NN,DIM)]DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
121	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*A_p[INDEX2(0,0,DIM)];
122	}
123	}
124	}
125	}
126	/**************************************************************/
127	/* process B: */
128	/**************************************************************/
129	B_p=getSampleDataRO(B,e,BBuff);
130	if (NULL!=B_p) {
131	add_EM_S=TRUE;
132	if (extendedB) {
133	for (s=0;s<p.row_NS;s++) {
134	for (r=0;r<p.col_NS;r++) {
135	rtmp=0;
136	for (q=0;q<p.numQuad;q++) {
137	rtmp+=Vol[q]DSDX[INDEX3(s,0,q,p.row_NN,DIM)]B_p[INDEX2(0,q,DIM)]*S[INDEX2(r,q,p.row_NS)];
138	}
139	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
140	}
141	}
142	} else {
143	for (s=0;s<p.row_NS;s++) {
144	for (r=0;r<p.col_NS;r++) {
145	rtmp=0;
146	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]DSDX[INDEX3(s,0,q,p.row_NN,DIM)]S[INDEX2(r,q,p.row_NS)];
147	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*B_p[0];
148	}
149	}
150	}
151	}
152	/**************************************************************/
153	/* process C: */
154	/**************************************************************/
155	C_p=getSampleDataRO(C,e,CBuff);
156	if (NULL!=C_p) {
157	add_EM_S=TRUE;
158	if (extendedC) {
159	for (s=0;s<p.row_NS;s++) {
160	for (r=0;r<p.col_NS;r++) {
161	rtmp=0;
162	for (q=0;q<p.numQuad;q++) {
163	rtmp+=Vol[q]S[INDEX2(s,q,p.row_NS)]C_p[INDEX2(0,q,DIM)]*DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
164	}
165	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
166	}
167	}
168	} else {
169	for (s=0;s<p.row_NS;s++) {
170	for (r=0;r<p.col_NS;r++) {
171	rtmp=0;
172	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]S[INDEX2(s,q,p.row_NS)]DSDX[INDEX3(r,0,q,p.row_NN,DIM)];
173	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*C_p[0];
174	}
175	}
176	}
177	}
178	/************************************************************* */
179	/* process D */
180	/**************************************************************/
181	D_p=getSampleDataRO(D,e,DBuff);
182	if (NULL!=D_p) {
183	add_EM_S=TRUE;
184	if (extendedD) {
185	for (s=0;s<p.row_NS;s++) {
186	for (r=0;r<p.col_NS;r++) {
187	rtmp=0;
188	for (q=0;q<p.numQuad;q++) {
189	rtmp+=Vol[q]S[INDEX2(s,q,p.row_NS)]D_p[q]*S[INDEX2(r,q,p.row_NS)];
190	}
191	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp;
192	}
193	}
194	} else {
195	for (s=0;s<p.row_NS;s++) {
196	for (r=0;r<p.col_NS;r++) {
197	rtmp=0;
198	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]S[INDEX2(s,q,p.row_NS)]S[INDEX2(r,q,p.row_NS)];
199	EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_NN)]+=rtmp*D_p[0];
200	}
201	}
202	}
203	}
204	/**************************************************************/
205	/* process X: */
206	/**************************************************************/
207	X_p=getSampleDataRO(X,e,XBuff);
208	if (NULL!=X_p) {
209	add_EM_F=TRUE;
210	if (extendedX) {
211	for (s=0;s<p.row_NS;s++) {
212	rtmp=0;
213	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]DSDX[INDEX3(s,0,q,p.row_NN,DIM)]X_p[INDEX2(0,q,DIM)];
214	EM_F[INDEX2(0,s,p.numEqu)]+=rtmp;
215	}
216	} else {
217	for (s=0;s<p.row_NS;s++) {
218	rtmp=0;
219	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*DSDX[INDEX3(s,0,q,p.row_NN,DIM)];
220	EM_F[INDEX2(0,s,p.numEqu)]+=rtmp*X_p[0];
221	}
222	}
223	}
224	/**************************************************************/
225	/* process Y: */
226	/**************************************************************/
227	Y_p=getSampleDataRO(Y,e,YBuff);
228	if (NULL!=Y_p) {
229	add_EM_F=TRUE;
230	if (extendedY) {
231	for (s=0;s<p.row_NS;s++) {
232	rtmp=0;
233	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]S[INDEX2(s,q,p.row_NS)]Y_p[q];
234	EM_F[INDEX2(0,s,p.numEqu)]+=rtmp;
235	}
236	} else {
237	for (s=0;s<p.row_NS;s++) {
238	rtmp=0;
239	for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)];
240	EM_F[INDEX2(0,s,p.numEqu)]+=rtmp*Y_p[0];
241	}
242	}
243	}
244	/***********************************************************************************************/
245	/* add the element matrices onto the matrix and right hand side */
246	/***********************************************************************************************/
247	for (q=0;q<p.row_NN;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[q],e,p.NN)]];
248	if (add_EM_F) Finley_Util_AddScatter(p.row_NN,row_index,p.numEqu,EM_F,F_p, p.row_DOF_UpperBound);
249	if (add_EM_S) Finley_Assemble_addToSystemMatrix(Mat,p.row_NN,row_index,p.numEqu,p.col_NN,row_index,p.numComp,EM_S);
250
251	} /* end color check */
252	} /* end element loop */
253	} /* end color loop */
254
255	THREAD_MEMFREE(EM_S); /* these FREEs appear to be inside the if because if any of the allocs */
256	THREAD_MEMFREE(EM_F); /* failed it means an out of memory (which is not recoverable anyway) */
257	THREAD_MEMFREE(row_index);
258
259	} /* end of pointer check */
260	freeSampleBuffer(ABuff);
261	freeSampleBuffer(BBuff);
262	freeSampleBuffer(CBuff);
263	freeSampleBuffer(DBuff);
264	freeSampleBuffer(XBuff);
265	freeSampleBuffer(YBuff);
266	} /* end parallel region */
267	}
268	/*
269	* $Log$
270	*/