source: trunk/examples/berrada/MFLBC_RD_perfomanceMeasurement/2Y2_mflbc_rd_normal.h @ 406

Last change on this file since 406 was 406, checked in by lnalod, 14 years ago

performance script update.
  • Property svn:eol-style set to native
File size: 37.2 KB
Line 
1#include <sys/time.h>
2double my_gettimeofday(){
3   struct timeval tmp_time;
4    gettimeofday(&tmp_time, NULL);
5     return tmp_time.tv_sec + (tmp_time.tv_usec * 1.0e-6L);
6}
7
8
9  double differenceForward=0, differenceBackward=0;
10  double parallelForward=0, parallelBackward=0;
11  double nonParallelForward=0, nonParallelBackward=0;
12  int counter=0;
13  double beginParallelForward=0, endParallelForward=0;
14  double beginNonParallelForward=0, endNonParallelForward=0;
15  double beginNonParallelBackward=0, endNonParallelBackward=0;
16  double beginParallelBackward=0, endParallelBackward=0;
17  double beginForward=0, endForward=0;
18  double beginBackward=0, endBackward=0;
19
20//----------------------------------------------------
21// project: mflbc_rd     header generated by YAO version v.9
22//----------------------------------------------------
23
24// € € € € € € € € LES FONCTIONS PREDEFINIES
25/*M2_TBTOG   */ 
26void YtabTOgrad_ssd(YREAL tab[])
27{
28         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
29                 for (int Yw2=0; Yw2<YA2_Sac;  ++Yw2){
30                         for (int Yws=0; Yws<YNBS_ssd; ++Yws){
31                                 YG_ssd(Yws, Yw1, Yw2) = tab[Y3windice]; ++Y3windice;}}}
32}/*M2_RGRAD*/ 
33void Yrazgrad_ssd()
34{
35         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
36                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
37                         for (int Yws=0; Yws<YNBS_ssd; ++Yws){
38                                 Yssd(Yw1, Yw2)->Ygrad[Yws] = 0.0;}}}
39}/*M2_SETA*/ 
40void Ysetstate_ssd(double val)
41{
42         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
43                 for (int Yw2=0; Yw2<YA2_Sac;  ++Yw2){
44                         for (int Yws=0; Yws<YNBS_ssd; ++Yws){
45                                 Yssd(Yw1, Yw2)->Ystate[Yws] = val;}}}
46}/*M2_YIOTU*/ 
47void Yio_ssd(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
48{  Yiorwf ("ssd", Yws, Yw1, Yw2, Yw3, Ywt, &YS_ssd(Yws, Yw1, Yw2), val);
49}/*M2_CREY*/ 
50void Ycreate_ssd() 
51{
52         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
53                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
54                         if ((Yssd(Yw1, Yw2)= new Yaossd ())==NULL) Ycreate_errnew();}}
55}/*M1_ADJUS*/ 
56void Yadjust_gama()
57{
58         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1) 
59         for (int Yws=0;Yws<YNBS_gama; ++Yws) 
60         { Ystate_gama(Yws, Yw1) -= Yepsi_gama(Yws, Yw1) * Ygrad_gama(Yws, Yw1); 
61        }
62}/*M1_GCTOTB  */ 
63void YgradCTOtab_gama(YREAL tab[])
64{
65         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
66                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
67                         tab[Y3windice] += YG_gama(Yws, Yw1); ++Y3windice;}}
68}/*M1_VSTA*/ 
69void Y3valstate_gama()
70{
71         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
72                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
73                         Y3x[Y3windice] = Ygama(Yw1)->Ystate[Yws]; ++Y3windice;}}
74}/*M1_GSTA*/ 
75void Y3getstate_gama(float x[])
76{
77         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
78                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
79                         Ygama(Yw1)->Ystate[Yws] = x[Y3windice]; ++Y3windice;}}
80}/*M1_VGRAD*/ 
81void Y3valgrad_gama(float g[])
82{
83         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
84                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
85                         g[Y3windice] = Ygama(Yw1)->Ygrad[Yws]; ++Y3windice;}}
86}/*M1_TBTOG   */ 
87void YtabTOgrad_gama(YREAL tab[])
88{
89         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
90                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
91                         YG_gama(Yws, Yw1) = tab[Y3windice]; ++Y3windice;}}
92}/*M1_RGRAD*/ 
93void Yrazgrad_gama()
94{
95         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
96                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
97                         Ygama(Yw1)->Ygrad[Yws] = 0.0;}}
98}/*M1_SETA*/ 
99void Ysetstate_gama(double val)
100{
101         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
102                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
103                         Ygama(Yw1)->Ystate[Yws] = val;}}
104}/*M1_YIOTU*/ 
105void Yio_gama(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val) 
106{  Yiorwf ("gama", Yws, Yw1, Yw2, Yw3, Ywt, &YS_gama(Yws, Yw1), val);
107}/*M0_OUTOB*/ 
108int Youtoobs_gama(YioKind yiokind, int Yws, int Ywt, int arbpdt)
109{
110         Yaobs.time = arbpdt;
111         Yaobs.imod = Yimod("gama");
112         Yaobs.smod = Yws;/*M1_OUTOB*/ 
113         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1)
114         {      if(select_io(yiokind, "gama", Yws, Yw1, -1, -1, Ywt, &Ystate_gama(Yws, Yw1)))
115                        {       Yaobs.iaxe = Yw1; Yaobs.jaxe = -1; Yaobs.kaxe = -1;
116                                Yaobs.vobs = Ystate_gama(Yws, Yw1);
117                                if(!Yobs_insert (&Yaobs)) return(0);
118                        }
119         }/*M9_OUTOB*/ 
120         return(1);
121}/*M1_SEPS*/ 
122void Ysetepsi_gama(double val)
123{
124         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
125                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
126                         Ygama(Yw1)->Yepsi[Yws] = val;}}
127}/*M1_CREY*/ 
128void Ycreate_gama()     
129{
130         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
131                 if ((Ygama(Yw1) = new Yaogama ())==NULL) Ycreate_errnew();}
132}/*M1_SWISH*/ 
133void Ysetwish_gama(double val)
134{
135         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
136                 for (int Yws=0; Yws<YNBS_gama; ++Yws){
137                         Ywish_gama(Yws, Yw1) = val;}}
138}/*M2_TBTOG   */ 
139void YtabTOgrad_nj(YREAL tab[])
140{
141         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
142                 for (int Yw2=0; Yw2<YA2_Sac;  ++Yw2){
143                         for (int Yws=0; Yws<YNBS_nj; ++Yws){
144                                 YG_nj(Yws, Yw1, Yw2) = tab[Y3windice]; ++Y3windice;}}}
145}/*M2_RGRAD*/ 
146void Yrazgrad_nj()
147{
148         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
149                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
150                         for (int Yws=0; Yws<YNBS_nj; ++Yws){
151                                 Ynj(Yw1, Yw2)->Ygrad[Yws] = 0.0;}}}
152}/*M2_SETA*/ 
153void Ysetstate_nj(double val)
154{
155         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
156                 for (int Yw2=0; Yw2<YA2_Sac;  ++Yw2){
157                         for (int Yws=0; Yws<YNBS_nj; ++Yws){
158                                 Ynj(Yw1, Yw2)->Ystate[Yws] = val;}}}
159}/*M2_YIOTU*/ 
160void Yio_nj(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
161{  Yiorwf ("nj", Yws, Yw1, Yw2, Yw3, Ywt, &YS_nj(Yws, Yw1, Yw2), val);
162}/*M2_CREU*/ 
163void Ycreate_nj() 
164{
165         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
166                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
167                         if ((Ynj(Yw1, Yw2)= new nj ())==NULL) Ycreate_errnew();}}
168}/*M2_TBTOGT  */ 
169void YtabTOgrad_diac(int frompdt, int topdt, YREAL tab[])
170{
171         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
172                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
173                         for (int Ywt=frompdt; Ywt<topdt; ++Ywt){
174                                 for (int Yws=0; Yws<YNBS_diac; ++Yws){
175                                         YG_diac(Yws, Yw1, Yw2, Ywt) = tab[Y3windice]; ++Y3windice;}}}}
176}/*M2_RGRADT*/ 
177void Yrazgrad_diac()
178{
179         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
180                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
181                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
182                                 for (int Yws=0; Yws<YNBS_diac; ++Yws){
183                                         Ydiac(Yw1, Yw2)->Ygrad[Ywt][Yws] = 0.0;}}}}
184}/*M2_SETAT*/ 
185void Ysetstate_diac(double val)
186{
187         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
188                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
189                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu;    ++Ywt){
190                                 for (int Yws=0; Yws<YNBS_diac; ++Yws){
191                                         Ydiac(Yw1, Yw2)->Ystate[Ywt][Yws] = val;}}}}
192}/*M2_YIOUT*/ 
193void Yio_diac(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val) 
194{  Yiorwf ("diac", Yws, Yw1, Yw2, Yw3, Ywt, &YS_diac(Yws, Yw1, Yw2, Ywt), val);
195}/*M2_CREU*/ 
196void Ycreate_diac() 
197{
198         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
199                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
200                         if ((Ydiac(Yw1, Yw2)= new diac ())==NULL) Ycreate_errnew();}}
201}/*M2_TBTOGT  */ 
202void YtabTOgrad_diab(int frompdt, int topdt, YREAL tab[])
203{
204         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
205                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
206                         for (int Ywt=frompdt; Ywt<topdt; ++Ywt){
207                                 for (int Yws=0; Yws<YNBS_diab; ++Yws){
208                                         YG_diab(Yws, Yw1, Yw2, Ywt) = tab[Y3windice]; ++Y3windice;}}}}
209}/*M2_RGRADT*/ 
210void Yrazgrad_diab()
211{
212         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
213                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
214                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
215                                 for (int Yws=0; Yws<YNBS_diab; ++Yws){
216                                         Ydiab(Yw1, Yw2)->Ygrad[Ywt][Yws] = 0.0;}}}}
217}/*M2_SETAT*/ 
218void Ysetstate_diab(double val)
219{
220         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
221                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
222                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu;    ++Ywt){
223                                 for (int Yws=0; Yws<YNBS_diab; ++Yws){
224                                         Ydiab(Yw1, Yw2)->Ystate[Ywt][Yws] = val;}}}}
225}/*M2_YIOUT*/ 
226void Yio_diab(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val) 
227{  Yiorwf ("diab", Yws, Yw1, Yw2, Yw3, Ywt, &YS_diab(Yws, Yw1, Yw2, Ywt), val);
228}/*M2_CREU*/ 
229void Ycreate_diab() 
230{
231         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
232                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
233                         if ((Ydiab(Yw1, Yw2)= new diab ())==NULL) Ycreate_errnew();}}
234}/*M2_TBTOGT  */ 
235void YtabTOgrad_bet(int frompdt, int topdt, YREAL tab[])
236{
237         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
238                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
239                         for (int Ywt=frompdt; Ywt<topdt; ++Ywt){
240                                 for (int Yws=0; Yws<YNBS_bet; ++Yws){
241                                         YG_bet(Yws, Yw1, Yw2, Ywt) = tab[Y3windice]; ++Y3windice;}}}}
242}/*M2_RGRADT*/ 
243void Yrazgrad_bet()
244{
245         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
246                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
247                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
248                                 for (int Yws=0; Yws<YNBS_bet; ++Yws){
249                                         Ybet(Yw1, Yw2)->Ygrad[Ywt][Yws] = 0.0;}}}}
250}/*M2_SETAT*/ 
251void Ysetstate_bet(double val)
252{
253         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
254                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
255                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu;    ++Ywt){
256                                 for (int Yws=0; Yws<YNBS_bet; ++Yws){
257                                         Ybet(Yw1, Yw2)->Ystate[Ywt][Yws] = val;}}}}
258}/*M2_YIOUT*/ 
259void Yio_bet(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
260{  Yiorwf ("bet", Yws, Yw1, Yw2, Yw3, Ywt, &YS_bet(Yws, Yw1, Yw2, Ywt), val);
261}/*M2_CREU*/ 
262void Ycreate_bet() 
263{
264         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
265                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
266                         if ((Ybet(Yw1, Yw2)= new bet ())==NULL) Ycreate_errnew();}}
267}/*M2_TBTOGT  */ 
268void YtabTOgrad_gag(int frompdt, int topdt, YREAL tab[])
269{
270         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
271                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
272                         for (int Ywt=frompdt; Ywt<topdt; ++Ywt){
273                                 for (int Yws=0; Yws<YNBS_gag; ++Yws){
274                                         YG_gag(Yws, Yw1, Yw2, Ywt) = tab[Y3windice]; ++Y3windice;}}}}
275}/*M2_RGRADT*/ 
276void Yrazgrad_gag()
277{
278         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
279                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
280                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
281                                 for (int Yws=0; Yws<YNBS_gag; ++Yws){
282                                         Ygag(Yw1, Yw2)->Ygrad[Ywt][Yws] = 0.0;}}}}
283}/*M2_SETAT*/ 
284void Ysetstate_gag(double val)
285{
286         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
287                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
288                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu;    ++Ywt){
289                                 for (int Yws=0; Yws<YNBS_gag; ++Yws){
290                                         Ygag(Yw1, Yw2)->Ystate[Ywt][Yws] = val;}}}}
291}/*M2_YIOUT*/ 
292void Yio_gag(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
293{  Yiorwf ("gag", Yws, Yw1, Yw2, Yw3, Ywt, &YS_gag(Yws, Yw1, Yw2, Ywt), val);
294}/*M2_CREU*/ 
295void Ycreate_gag() 
296{
297         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
298                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
299                         if ((Ygag(Yw1, Yw2)= new gag ())==NULL) Ycreate_errnew();}}
300}/*M2_TBTOGT  */ 
301void YtabTOgrad_res(int frompdt, int topdt, YREAL tab[])
302{
303         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
304                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
305                         for (int Ywt=frompdt; Ywt<topdt; ++Ywt){
306                                 for (int Yws=0; Yws<YNBS_res; ++Yws){
307                                         YG_res(Yws, Yw1, Yw2, Ywt) = tab[Y3windice]; ++Y3windice;}}}}
308}/*M2_RGRADT*/ 
309void Yrazgrad_res()
310{
311         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
312                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
313                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
314                                 for (int Yws=0; Yws<YNBS_res; ++Yws){
315                                         Yres(Yw1, Yw2)->Ygrad[Ywt][Yws] = 0.0;}}}}
316}/*M2_SETAT*/ 
317void Ysetstate_res(double val)
318{
319         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
320                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
321                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu;    ++Ywt){
322                                 for (int Yws=0; Yws<YNBS_res; ++Yws){
323                                         Yres(Yw1, Yw2)->Ystate[Ywt][Yws] = val;}}}}
324}/*M2_YIOUT*/ 
325void Yio_res(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
326{  Yiorwf ("res", Yws, Yw1, Yw2, Yw3, Ywt, &YS_res(Yws, Yw1, Yw2, Ywt), val);
327}/*M2_CREU*/ 
328void Ycreate_res() 
329{
330         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
331                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
332                         if ((Yres(Yw1, Yw2)= new res ())==NULL) Ycreate_errnew();}}
333}/*M2_TBTOGT  */ 
334void YtabTOgrad_ixu(int frompdt, int topdt, YREAL tab[])
335{
336         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
337                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
338                         for (int Ywt=frompdt; Ywt<topdt; ++Ywt){
339                                 for (int Yws=0; Yws<YNBS_ixu; ++Yws){
340                                         YG_ixu(Yws, Yw1, Yw2, Ywt) = tab[Y3windice]; ++Y3windice;}}}}
341}/*M2_RGRADT*/ 
342void Yrazgrad_ixu()
343{
344         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
345                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
346                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
347                                 for (int Yws=0; Yws<YNBS_ixu; ++Yws){
348                                         Yixu(Yw1, Yw2)->Ygrad[Ywt][Yws] = 0.0;}}}}
349}/*M2_SETAT*/ 
350void Ysetstate_ixu(double val)
351{
352         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
353                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
354                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu;    ++Ywt){
355                                 for (int Yws=0; Yws<YNBS_ixu; ++Yws){
356                                         Yixu(Yw1, Yw2)->Ystate[Ywt][Yws] = val;}}}}
357}/*M2_YIOUT*/ 
358void Yio_ixu(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
359{  Yiorwf ("ixu", Yws, Yw1, Yw2, Yw3, Ywt, &YS_ixu(Yws, Yw1, Yw2, Ywt), val);
360}/*M2_CREU*/ 
361void Ycreate_ixu() 
362{
363         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
364                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
365                         if ((Yixu(Yw1, Yw2)= new ixu ())==NULL) Ycreate_errnew();}}
366}/*M2_TBTOGT  */ 
367void YtabTOgrad_psi(int frompdt, int topdt, YREAL tab[])
368{
369         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
370                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
371                         for (int Ywt=frompdt; Ywt<topdt; ++Ywt){
372                                 for (int Yws=0; Yws<YNBS_psi; ++Yws){
373                                         YG_psi(Yws, Yw1, Yw2, Ywt) = tab[Y3windice]; ++Y3windice;}}}}
374}/*M2_RGRADT*/ 
375void Yrazgrad_psi()
376{
377         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
378                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
379                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
380                                 for (int Yws=0; Yws<YNBS_psi; ++Yws){
381                                         Ypsi(Yw1, Yw2)->Ygrad[Ywt][Yws] = 0.0;}}}}
382}/*M2_SETAT*/ 
383void Ysetstate_psi(double val)
384{
385         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
386                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
387                         for (int Ywt=0; Ywt<YNBALLTIME_Tlu;    ++Ywt){
388                                 for (int Yws=0; Yws<YNBS_psi; ++Yws){
389                                         Ypsi(Yw1, Yw2)->Ystate[Ywt][Yws] = val;}}}}
390}/*M2_YIOUT*/ 
391void Yio_psi(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
392{  Yiorwf ("psi", Yws, Yw1, Yw2, Yw3, Ywt, &YS_psi(Yws, Yw1, Yw2, Ywt), val);
393}/*M0_OUTOB*/ 
394int Youtoobs_psi(YioKind yiokind, int Yws, int Ywt, int arbpdt)
395{
396         Yaobs.time = arbpdt;
397         Yaobs.imod = Yimod("psi");
398         Yaobs.smod = Yws;/*M2_OUTOBT*/
399         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1)
400         for (int Yw2=0; Yw2<YA2_Sac; ++Yw2)
401         {      if(select_io(yiokind, "psi", Yws, Yw1, Yw2, -1, Ywt, &Ystate_psi(Yws, Yw1, Yw2, Ywt)))
402                        {       Yaobs.iaxe = Yw1; Yaobs.jaxe = Yw2; Yaobs.kaxe = -1;
403                                Yaobs.vobs = Ystate_psi(Yws, Yw1, Yw2, Ywt);
404                                if(!Yobs_insert (&Yaobs)) return(0);
405                        }
406         }/*M9_OUTOB*/ 
407         return(1);
408}/*M2_CREU*/ 
409void Ycreate_psi() 
410{
411         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
412                 for (int Yw2=0; Yw2<YA2_Sac; ++Yw2){
413                         if ((Ypsi(Yw1, Yw2)= new psi ())==NULL) Ycreate_errnew();}}
414}/*M2_SWISH*/ 
415void Ysetwish_psi(double val)
416{
417         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
418                 for (int Yw2=0; Yw2<YA2_Sac;  ++Yw2){
419                         for (int Yws=0; Yws<YNBS_psi; ++Yws){
420                                 Ywish_psi(Yws, Yw1, Yw2) = val;}}}
421}/*M1_TBTOGT  */ 
422void YtabTOgrad_psifd(int frompdt, int topdt, YREAL tab[])
423{
424         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
425                 for (int Ywt=frompdt; Ywt<topdt;  ++Ywt){
426                         for (int Yws=0; Yws<YNBS_psifd; ++Yws){
427                                 YG_psifd(Yws, Yw1, Ywt) = tab[Y3windice]; ++Y3windice;}}}
428}/*M1_RGRADT*/ 
429void Yrazgrad_psifd()
430{
431         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
432                 for (int Ywt=0; Ywt<YNBALLTIME_Tlu; ++Ywt){
433                         for (int Yws=0; Yws<YNBS_psifd; ++Yws){
434                                 Ypsifd(Yw1)->Ygrad[Ywt][Yws] = 0.0;}}}
435}/*M1_SETAT*/ 
436void Ysetstate_psifd(double val)
437{
438         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
439                 for (int Ywt=0; Ywt<YNBALLTIME_Tlu;  ++Ywt){
440                         for (int Yws=0; Yws<YNBS_psifd; ++Yws){
441                                 Ypsifd(Yw1)->Ystate[Ywt][Yws] = val;}}}
442}/*M1_YIOUT*/ 
443void Yio_psifd(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val) 
444{  Yiorwf ("psifd", Yws, Yw1, Yw2, Yw3, Ywt, &YS_psifd(Yws, Yw1, Ywt), val);
445}/*M0_OUTOB*/ 
446int Youtoobs_psifd(YioKind yiokind, int Yws, int Ywt, int arbpdt)
447{
448         Yaobs.time = arbpdt;
449         Yaobs.imod = Yimod("psifd");
450         Yaobs.smod = Yws;/*M1_OUTOBT*/
451         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1)
452         {      if(select_io(yiokind, "psifd", Yws, Yw1, -1, -1, Ywt, &Ystate_psifd(Yws, Yw1, Ywt)))
453                        {       Yaobs.iaxe = Yw1; Yaobs.jaxe = -1; Yaobs.kaxe = -1;
454                                Yaobs.vobs = Ystate_psifd(Yws, Yw1, Ywt);
455                                if(!Yobs_insert (&Yaobs)) return(0);
456                        }
457         }/*M9_OUTOB*/ 
458         return(1);
459}/*M1_CREU*/ 
460void Ycreate_psifd() 
461{
462         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
463                 if ((Ypsifd(Yw1) = new psifd ())==NULL) Ycreate_errnew();}
464}/*M1_SWISH*/ 
465void Ysetwish_psifd(double val)
466{
467         for (int Yw1=0; Yw1<YA1_Sac; ++Yw1){
468                 for (int Yws=0; Yws<YNBS_psifd; ++Yws){
469                         Ywish_psifd(Yws, Yw1) = val;}}
470}/*M1_TBTOG   */ 
471void YtabTOgrad_lap(YREAL tab[])
472{
473         for (int Yw1=0; Yw1<YA1_Olap; ++Yw1){
474                 for (int Yws=0; Yws<YNBS_lap; ++Yws){
475                         YG_lap(Yws, Yw1) = tab[Y3windice]; ++Y3windice;}}
476}/*M1_RGRAD*/ 
477void Yrazgrad_lap()
478{
479         for (int Yw1=0; Yw1<YA1_Olap; ++Yw1){
480                 for (int Yws=0; Yws<YNBS_lap; ++Yws){
481                         Ylap(Yw1)->Ygrad[Yws] = 0.0;}}
482}/*M1_SETA*/ 
483void Ysetstate_lap(double val)
484{
485         for (int Yw1=0; Yw1<YA1_Olap; ++Yw1){
486                 for (int Yws=0; Yws<YNBS_lap; ++Yws){
487                         Ylap(Yw1)->Ystate[Yws] = val;}}
488}/*M1_YIOTU*/ 
489void Yio_lap(int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)   
490{  Yiorwf ("lap", Yws, Yw1, Yw2, Yw3, Ywt, &YS_lap(Yws, Yw1), val);
491}/*M1_CREU*/ 
492void Ycreate_lap() 
493{
494         for (int Yw1=0; Yw1<YA1_Olap; ++Yw1){
495                 if ((Ylap(Yw1) = new lap ())==NULL) Ycreate_errnew();}
496}
497void Ycreate_all () 
498{
499         Ycreate_ssd ();
500         Ycreate_gama ();
501         Ycreate_nj ();
502         Ycreate_diac ();
503         Ycreate_diab ();
504         Ycreate_bet ();
505         Ycreate_gag ();
506         Ycreate_res ();
507         Ycreate_ixu ();
508         Ycreate_psi ();
509         Ycreate_psifd ();
510         Ycreate_lap ();
511}
512void Ywishdiff_all (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, int Ywt, YREAL vobs) 
513{       
514         if(1==0);
515         else if (strcmp(nmmod, "gama") == 0)
516                                 YW_gama(Yws, Yw1) = YS_gama(Yws, Yw1) - vobs;
517         else if (strcmp(nmmod, "psi") == 0)
518                                 YW_psi(Yws, Yw1, Yw2) = YS_psi(Yws, Yw1, Yw2, Ywt) - vobs;
519         else if (strcmp(nmmod, "psifd") == 0)
520                                 YW_psifd(Yws, Yw1) = YS_psifd(Yws, Yw1, Ywt) - vobs;
521}
522void Ycostwishdiff_all (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, int Ywt) 
523{       
524         if(1==0);
525         else if (strcmp(nmmod, "gama") == 0)
526                                 YG_gama(Yws, Yw1) += Ycostdiff(YW_gama(Yws, Yw1), YS_lap(Yws, Yw1));
527         else if (strcmp(nmmod, "psi") == 0)
528                                      YG_psi(Yws, Yw1, Yw2, Ywt) += Ycostdiff(YW_psi(Yws, Yw1, Yw2), YW_psi(Yws, Yw1, Yw2));
529         else if (strcmp(nmmod, "psifd") == 0)
530                                 YG_psifd(Yws, Yw1, Ywt) += Ycostdiff(YW_psifd(Yws, Yw1), YW_psifd(Yws, Yw1));
531}
532void Youtoobs_mod(YioKind yiokind, char *nmmod, int numout, int pdt, int arbpdt)
533{
534         if(1==0);
535         else if (strcmp(nmmod, "gama") == 0) Youtoobs_gama(yiokind, numout, pdt, arbpdt);
536         else if (strcmp(nmmod, "psi") == 0) Youtoobs_psi(yiokind, numout, pdt, arbpdt);
537         else if (strcmp(nmmod, "psifd") == 0) Youtoobs_psifd(yiokind, numout, pdt, arbpdt);
538}
539void Yadjust_all () 
540{
541         Yadjust_gama ();
542}
543void Yrazgrad_all () 
544{
545         Yrazgrad_ssd ();
546         Yrazgrad_gama ();
547         Yrazgrad_nj ();
548         Yrazgrad_diac ();
549         Yrazgrad_diab ();
550         Yrazgrad_bet ();
551         Yrazgrad_gag ();
552         Yrazgrad_res ();
553         Yrazgrad_ixu ();
554         Yrazgrad_psi ();
555         Yrazgrad_psifd ();
556         Yrazgrad_lap ();
557}
558void Yrazgrad_only (int itraj) 
559{
560        if (itraj==Yid_Tlu)
561        {  Yrazgrad_nj ();
562           Yrazgrad_lap ();
563         }
564}
565int Ysetstate_mod (char *nmmod, YREAL val) 
566{       int codret=0; int all=0;
567        if (!strcmp(nmmod, "Y#A")) all=1;
568        if (!strcmp(nmmod, "ssd") || all)
569        {  Ysetstate_ssd(val);codret=1;}
570        if (!strcmp(nmmod, "gama") || all)
571        {  Ysetstate_gama(val);codret=1;}
572        if (!strcmp(nmmod, "nj") || all)
573        {  Ysetstate_nj(val);codret=1;}
574        if (!strcmp(nmmod, "diac") || all)
575        {  Ysetstate_diac(val);codret=1;}
576        if (!strcmp(nmmod, "diab") || all)
577        {  Ysetstate_diab(val);codret=1;}
578        if (!strcmp(nmmod, "bet") || all)
579        {  Ysetstate_bet(val);codret=1;}
580        if (!strcmp(nmmod, "gag") || all)
581        {  Ysetstate_gag(val);codret=1;}
582        if (!strcmp(nmmod, "res") || all)
583        {  Ysetstate_res(val);codret=1;}
584        if (!strcmp(nmmod, "ixu") || all)
585        {  Ysetstate_ixu(val);codret=1;}
586        if (!strcmp(nmmod, "psi") || all)
587        {  Ysetstate_psi(val);codret=1;}
588        if (!strcmp(nmmod, "psifd") || all)
589        {  Ysetstate_psifd(val);codret=1;}
590        if (!strcmp(nmmod, "lap") || all)
591        {  Ysetstate_lap(val);codret=1;}
592        return(codret);
593}
594void Ysetwish_mod (int imod, YREAL val) 
595{       if(1==0);
596        else if (imod==1) Ysetwish_gama(val);
597        else if (imod==9) Ysetwish_psi(val);
598        else if (imod==10) Ysetwish_psifd(val);
599}
600void  Yio_mod (char *nmmod, int Yws, int Yw1, int Yw2, int Yw3, int Ywt, double val)
601{
602         if(1==0);
603         else if (strcmp(nmmod, "ssd") == 0) Yio_ssd(Yws, Yw1, Yw2, Yw3, Ywt, val);
604         else if (strcmp(nmmod, "gama") == 0) Yio_gama(Yws, Yw1, Yw2, Yw3, Ywt, val);
605         else if (strcmp(nmmod, "nj") == 0) Yio_nj(Yws, Yw1, Yw2, Yw3, Ywt, val);
606         else if (strcmp(nmmod, "diac") == 0) Yio_diac(Yws, Yw1, Yw2, Yw3, Ywt, val);
607         else if (strcmp(nmmod, "diab") == 0) Yio_diab(Yws, Yw1, Yw2, Yw3, Ywt, val);
608         else if (strcmp(nmmod, "bet") == 0) Yio_bet(Yws, Yw1, Yw2, Yw3, Ywt, val);
609         else if (strcmp(nmmod, "gag") == 0) Yio_gag(Yws, Yw1, Yw2, Yw3, Ywt, val);
610         else if (strcmp(nmmod, "res") == 0) Yio_res(Yws, Yw1, Yw2, Yw3, Ywt, val);
611         else if (strcmp(nmmod, "ixu") == 0) Yio_ixu(Yws, Yw1, Yw2, Yw3, Ywt, val);
612         else if (strcmp(nmmod, "psi") == 0) Yio_psi(Yws, Yw1, Yw2, Yw3, Ywt, val);
613         else if (strcmp(nmmod, "psifd") == 0) Yio_psifd(Yws, Yw1, Yw2, Yw3, Ywt, val);
614         else if (strcmp(nmmod, "lap") == 0) Yio_lap(Yws, Yw1, Yw2, Yw3, Ywt, val);
615}
616void YgradCTOtab_target (YREAL tab[]) 
617{       //Y3windice = 0;
618         YgradCTOtab_gama (tab);
619}
620void YtabTOgrad_target (YREAL tab[]) 
621{       //Y3windice = 0;
622         YtabTOgrad_gama (tab);
623}
624void Y3getstate_all (float x[]) 
625{        Y3windice = 0;
626         Y3getstate_gama (x);
627}
628void Y3valstate_all () 
629{        Y3windice = 0;
630         Y3valstate_gama ();
631}
632void Y3valgrad_all (float g[]) 
633{        Y3windice = 0;
634         Y3valgrad_gama (g);
635}
636int Yauto_call (int argc, char *argv[]) 
637{
638         int codret=0; int all=0; double val;
639         if (1==0);
640         else if ( !strcmp(argv[0], "setepsi") || !strcmp(argv[0], "SETEPSI") 
641                                         ||!strcmp(argv[0], "setepsi_all") || !strcmp(argv[0], "SETEPSI_ALL"))
642         {
643                         if (!strcmp(argv[0], "setepsi_all") || !strcmp(argv[0], "SETEPSI_ALL")){all=1; val=atof(argv[1]);} else val=atof(argv[2]);
644                         if (!strcmp(argv[1], "gama") || all)
645                                         {Ysetepsi_gama(val);codret=1;}
646         }
647         else codret=0;
648         return(codret);
649}
650
651//#############################################################################################################################
652
653
654 int Yforward_space_Sac()
655{
656         YA1=2049; YA2=512; YA3=0;
657Yi=-1; Yj=-1; Yk=-1; /* init des indices de maille: maj par la boucle si valide*/
658
659beginForward=my_gettimeofday();
660#pragma omp parallel for
661for(YY=0; YY<YA1_Sac; ++YY){
662  Yi=YY;
663{
664for(Yj=0; Yj<YA2_Sac; ++Yj)
665{
666         Yting[0]=YS1_ssd( Yi, Yj);
667         Ynj(Yi, Yj)->forward( Yting[0] );
668         Yting[0]=YS1_nj( Yi, Yj);
669         Ydiab(Yi, Yj)->forward( Yting[0] );
670         Yting[0]=YS1_nj( Yi, Yj);
671         Ydiac(Yi, Yj)->forward( Yting[0] );
672         if (1==0 || Yj-1<0)
673         Yting[0]=0; 
674         else 
675         Yting[0]=YS1_bet( Yi, Yj-1, YTemps);
676         if (1==0 || Yj-1<0)
677         Yting[1]=0; 
678         else 
679         Yting[1]=YS2_bet( Yi, Yj-1, YTemps);
680         Ygag(Yi, Yj)->forward( Yting[0], Yting[1] );
681         Yting[0]=YS1_diac( Yi, Yj, YTemps);
682         Yting[1]=YS2_diac( Yi, Yj, YTemps);
683         Yting[2]=YS1_gag( Yi, Yj, YTemps);
684         Yting[3]=YS2_gag( Yi, Yj, YTemps);
685         Ybet(Yi, Yj)->forward( Yting[0], Yting[1], Yting[2], Yting[3] );
686
687}
688
689}
690}
691
692for(Yi=0; Yi<YA1_Sac; ++Yi)
693{
694for(Yj=0; Yj<YA2_Sac; ++Yj)
695{
696         if (1==0 || Yi-1<0 || Yj-1<0)
697         Yting[0]=0; 
698         else 
699         Yting[0]=YS1_psi( Yi-1, Yj-1, YTemps);
700         if (1==0 || Yi-1<0 || Yj-1<0)
701         Yting[1]=0; 
702         else 
703         Yting[1]=YS2_psi( Yi-1, Yj-1, YTemps);
704         if (1==0 || Yi-1<0)
705         Yting[2]=0; 
706         else 
707         Yting[2]=YS1_psi( Yi-1, Yj, YTemps);
708         if (1==0 || Yi-1<0)
709         Yting[3]=0; 
710         else 
711         Yting[3]=YS2_psi( Yi-1, Yj, YTemps);
712         if (1==0 || Yi-1<0 || Yj+1>YA2_Sac-1)
713         Yting[4]=0; 
714         else 
715         Yting[4]=YS1_psi( Yi-1, Yj+1, YTemps);
716         if (1==0 || Yi-1<0 || Yj+1>YA2_Sac-1)
717         Yting[5]=0; 
718         else 
719         Yting[5]=YS2_psi( Yi-1, Yj+1, YTemps);
720         Yting[6]=YS1_diab( 0, Yj, YTemps);
721         Yting[7]=YS2_diab( 0, Yj, YTemps);
722         Yting[8]=YS1_gama( Yi);
723         Yting[9]=YS2_gama( Yi);
724         Yres(Yi, Yj)->forward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5], Yting[6], Yting[7], Yting[8], Yting[9] );
725         Yting[0]=YS1_res( Yi, Yj, YTemps);
726         Yting[1]=YS2_res( Yi, Yj, YTemps);
727         if (1==0 || Yj-1<0)
728         Yting[2]=0; 
729         else 
730         Yting[2]=YS1_ixu( Yi, Yj-1, YTemps);
731         if (1==0 || Yj-1<0)
732         Yting[3]=0; 
733         else 
734         Yting[3]=YS2_ixu( Yi, Yj-1, YTemps);
735         Yting[4]=YS1_bet( 0, Yj, YTemps);
736         Yting[5]=YS2_bet( 0, Yj, YTemps);
737         if (1==0 || Yi+1>YA1_Sac-1)
738         Yting[6]=0; 
739         else 
740         Yting[6]=YS1_gama( Yi+1);
741         if (1==0 || Yi+1>YA1_Sac-1)
742         Yting[7]=0; 
743         else 
744         Yting[7]=YS2_gama( Yi+1);
745         Yixu(Yi, Yj)->forward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5], Yting[6], Yting[7] );
746
747}
748for(Yj=YA2_Sac-1; Yj>=0; --Yj)
749{
750         Yting[0]=YS1_ixu( Yi, Yj, YTemps);
751         Yting[1]=YS2_ixu( Yi, Yj, YTemps);
752         if (1==0 || Yj+1>YA2_Sac-1)
753         Yting[2]=0; 
754         else 
755         Yting[2]=YS1_psi( Yi, Yj+1, YTemps);
756         if (1==0 || Yj+1>YA2_Sac-1)
757         Yting[3]=0; 
758         else 
759         Yting[3]=YS2_psi( Yi, Yj+1, YTemps);
760         if (1==0 || Yj+1>YA2_Sac-1)
761         Yting[4]=0; 
762         else 
763         Yting[4]=YS1_gag( 0, Yj+1, YTemps);
764         if (1==0 || Yj+1>YA2_Sac-1)
765         Yting[5]=0; 
766         else 
767         Yting[5]=YS2_gag( 0, Yj+1, YTemps);
768         Ypsi(Yi, Yj)->forward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5] );
769
770}
771
772}
773#pragma omp parallel for
774for(YY=0; YY<YA1_Sac; ++YY){
775  Yi=YY;
776{
777         Yting[0]=YS1_psi( Yi, 511, YTemps);
778         Yting[1]=YS2_psi( Yi, 511, YTemps);
779         Yting[2]=YS1_gama( Yi);
780         Yting[3]=YS2_gama( Yi);
781         Ypsifd(Yi)->forward( Yting[0], Yting[1], Yting[2], Yting[3] );
782
783}
784}
785  endForward=my_gettimeofday();
786
787//  printf("\n\n################ FORWARD_SPACE_SAC #########################################");
788//  printf("\nTime begin: %f", begin);
789//  printf("\nTime end: %f", end);
790//  printf("\nTimeForwardDifference %f", (end - begin));
791//  printf("\n###############################################################################\n\n");
792
793         return(0);
794}
795//#############################################################################################################################
796
797 int Ybackward_space_Sac()
798{
799         YA1=2049; YA2=512; YA3=0;
800Yi=-1; Yj=-1; Yk=-1; /* init des indices de maille: maj par la boucle si valide*/
801  beginBackward=my_gettimeofday();
802#pragma omp parallel for
803for(YY=YA1_Sac-1; YY>=0; --YY){
804  Yi=YY;
805{
806         Yting[0]=YS1_psi( Yi, 511, YTemps);
807         Yting[1]=YS2_psi( Yi, 511, YTemps);
808         Yting[2]=YS1_gama( Yi);
809         Yting[3]=YS2_gama( Yi);
810         memset(Yjac, 0, 20*sizeof(double));
811         Ypsifd(Yi)->backward( Yting[0], Yting[1], Yting[2], Yting[3] );
812         Yvsmatt (YNBS_psifd, YNBI_psifd, YMAX_JAC_NBI, &YG1Y_psifd, Yjac[0], Ytbeta);
813         YG1_psi( Yi, 511, YTemps) += Ytbeta[0];
814         YG2_psi( Yi, 511, YTemps) += Ytbeta[1];
815         YG1_gama( Yi) += Ytbeta[2];
816         YG2_gama( Yi) += Ytbeta[3];
817
818}
819}
820for(Yi=YA1_Sac-1; Yi>=0; --Yi)
821{
822for(Yj=0; Yj<YA2_Sac; ++Yj)
823{
824         Yting[0]=YS1_ixu( Yi, Yj, YTemps);
825         Yting[1]=YS2_ixu( Yi, Yj, YTemps);
826         if (1==0 || Yj+1>YA2_Sac-1)
827         Yting[2]=0; 
828         else 
829         Yting[2]=YS1_psi( Yi, Yj+1, YTemps);
830         if (1==0 || Yj+1>YA2_Sac-1)
831         Yting[3]=0; 
832         else 
833         Yting[3]=YS2_psi( Yi, Yj+1, YTemps);
834         if (1==0 || Yj+1>YA2_Sac-1)
835         Yting[4]=0; 
836         else 
837         Yting[4]=YS1_gag( 0, Yj+1, YTemps);
838         if (1==0 || Yj+1>YA2_Sac-1)
839         Yting[5]=0; 
840         else 
841         Yting[5]=YS2_gag( 0, Yj+1, YTemps);
842         memset(Yjac, 0, 20*sizeof(double));
843         Ypsi(Yi, Yj)->backward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5] );
844         Yvsmatt (YNBS_psi, YNBI_psi, YMAX_JAC_NBI, &YG1Y_psi, Yjac[0], Ytbeta);
845         YG1_ixu( Yi, Yj, YTemps) += Ytbeta[0];
846         YG2_ixu( Yi, Yj, YTemps) += Ytbeta[1];
847         if (1==0 || Yj+1>YA2_Sac-1){} 
848         else 
849         YG1_psi( Yi, Yj+1, YTemps) += Ytbeta[2];
850         if (1==0 || Yj+1>YA2_Sac-1){} 
851         else 
852         YG2_psi( Yi, Yj+1, YTemps) += Ytbeta[3];
853         if (1==0 || Yj+1>YA2_Sac-1){} 
854         else 
855         YG1_gag( 0, Yj+1, YTemps) += Ytbeta[4];
856         if (1==0 || Yj+1>YA2_Sac-1){} 
857         else 
858         YG2_gag( 0, Yj+1, YTemps) += Ytbeta[5];
859
860}
861for(Yj=YA2_Sac-1; Yj>=0; --Yj)
862{
863         Yting[0]=YS1_res( Yi, Yj, YTemps);
864         Yting[1]=YS2_res( Yi, Yj, YTemps);
865         if (1==0 || Yj-1<0)
866         Yting[2]=0; 
867         else 
868         Yting[2]=YS1_ixu( Yi, Yj-1, YTemps);
869         if (1==0 || Yj-1<0)
870         Yting[3]=0; 
871         else 
872         Yting[3]=YS2_ixu( Yi, Yj-1, YTemps);
873         Yting[4]=YS1_bet( 0, Yj, YTemps);
874         Yting[5]=YS2_bet( 0, Yj, YTemps);
875         if (1==0 || Yi+1>YA1_Sac-1)
876         Yting[6]=0; 
877         else 
878         Yting[6]=YS1_gama( Yi+1);
879         if (1==0 || Yi+1>YA1_Sac-1)
880         Yting[7]=0; 
881         else 
882         Yting[7]=YS2_gama( Yi+1);
883         memset(Yjac, 0, 20*sizeof(double));
884         Yixu(Yi, Yj)->backward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5], Yting[6], Yting[7] );
885         Yvsmatt (YNBS_ixu, YNBI_ixu, YMAX_JAC_NBI, &YG1Y_ixu, Yjac[0], Ytbeta);
886         YG1_res( Yi, Yj, YTemps) += Ytbeta[0];
887         YG2_res( Yi, Yj, YTemps) += Ytbeta[1];
888         if (1==0 || Yj-1<0){} 
889         else 
890         YG1_ixu( Yi, Yj-1, YTemps) += Ytbeta[2];
891         if (1==0 || Yj-1<0){} 
892         else 
893         YG2_ixu( Yi, Yj-1, YTemps) += Ytbeta[3];
894         YG1_bet( 0, Yj, YTemps) += Ytbeta[4];
895         YG2_bet( 0, Yj, YTemps) += Ytbeta[5];
896         if (1==0 || Yi+1>YA1_Sac-1){} 
897         else 
898         YG1_gama( Yi+1) += Ytbeta[6];
899         if (1==0 || Yi+1>YA1_Sac-1){} 
900         else 
901         YG2_gama( Yi+1) += Ytbeta[7];
902         if (1==0 || Yi-1<0 || Yj-1<0)
903         Yting[0]=0; 
904         else 
905         Yting[0]=YS1_psi( Yi-1, Yj-1, YTemps);
906         if (1==0 || Yi-1<0 || Yj-1<0)
907         Yting[1]=0; 
908         else 
909         Yting[1]=YS2_psi( Yi-1, Yj-1, YTemps);
910         if (1==0 || Yi-1<0)
911         Yting[2]=0; 
912         else 
913         Yting[2]=YS1_psi( Yi-1, Yj, YTemps);
914         if (1==0 || Yi-1<0)
915         Yting[3]=0; 
916         else 
917         Yting[3]=YS2_psi( Yi-1, Yj, YTemps);
918         if (1==0 || Yi-1<0 || Yj+1>YA2_Sac-1)
919         Yting[4]=0; 
920         else 
921         Yting[4]=YS1_psi( Yi-1, Yj+1, YTemps);
922         if (1==0 || Yi-1<0 || Yj+1>YA2_Sac-1)
923         Yting[5]=0; 
924         else 
925         Yting[5]=YS2_psi( Yi-1, Yj+1, YTemps);
926         Yting[6]=YS1_diab( 0, Yj, YTemps);
927         Yting[7]=YS2_diab( 0, Yj, YTemps);
928         Yting[8]=YS1_gama( Yi);
929         Yting[9]=YS2_gama( Yi);
930         memset(Yjac, 0, 20*sizeof(double));
931         Yres(Yi, Yj)->backward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5], Yting[6], Yting[7], Yting[8], Yting[9] );
932         Yvsmatt (YNBS_res, YNBI_res, YMAX_JAC_NBI, &YG1Y_res, Yjac[0], Ytbeta);
933         if (1==0 || Yi-1<0 || Yj-1<0){} 
934         else 
935         YG1_psi( Yi-1, Yj-1, YTemps) += Ytbeta[0];
936         if (1==0 || Yi-1<0 || Yj-1<0){} 
937         else 
938         YG2_psi( Yi-1, Yj-1, YTemps) += Ytbeta[1];
939         if (1==0 || Yi-1<0){} 
940         else 
941         YG1_psi( Yi-1, Yj, YTemps) += Ytbeta[2];
942         if (1==0 || Yi-1<0){} 
943         else 
944         YG2_psi( Yi-1, Yj, YTemps) += Ytbeta[3];
945         if (1==0 || Yi-1<0 || Yj+1>YA2_Sac-1){} 
946         else 
947         YG1_psi( Yi-1, Yj+1, YTemps) += Ytbeta[4];
948         if (1==0 || Yi-1<0 || Yj+1>YA2_Sac-1){} 
949         else 
950         YG2_psi( Yi-1, Yj+1, YTemps) += Ytbeta[5];
951         YG1_diab( 0, Yj, YTemps) += Ytbeta[6];
952         YG2_diab( 0, Yj, YTemps) += Ytbeta[7];
953         YG1_gama( Yi) += Ytbeta[8];
954         YG2_gama( Yi) += Ytbeta[9];
955
956}
957
958}
959#pragma omp parallel for
960for(YY=YA1_Sac-1; YY>=0; --YY){
961  Yi=YY;
962{
963for(Yj=YA2_Sac-1; Yj>=0; --Yj)
964{
965         Yting[0]=YS1_diac( Yi, Yj, YTemps);
966         Yting[1]=YS2_diac( Yi, Yj, YTemps);
967         Yting[2]=YS1_gag( Yi, Yj, YTemps);
968         Yting[3]=YS2_gag( Yi, Yj, YTemps);
969         memset(Yjac, 0, 20*sizeof(double));
970         Ybet(Yi, Yj)->backward( Yting[0], Yting[1], Yting[2], Yting[3] );
971         Yvsmatt (YNBS_bet, YNBI_bet, YMAX_JAC_NBI, &YG1Y_bet, Yjac[0], Ytbeta);
972         YG1_diac( Yi, Yj, YTemps) += Ytbeta[0];
973         YG2_diac( Yi, Yj, YTemps) += Ytbeta[1];
974         YG1_gag( Yi, Yj, YTemps) += Ytbeta[2];
975         YG2_gag( Yi, Yj, YTemps) += Ytbeta[3];
976         if (1==0 || Yj-1<0)
977         Yting[0]=0; 
978         else 
979         Yting[0]=YS1_bet( Yi, Yj-1, YTemps);
980         if (1==0 || Yj-1<0)
981         Yting[1]=0; 
982         else 
983         Yting[1]=YS2_bet( Yi, Yj-1, YTemps);
984         memset(Yjac, 0, 20*sizeof(double));
985         Ygag(Yi, Yj)->backward( Yting[0], Yting[1] );
986         Yvsmatt (YNBS_gag, YNBI_gag, YMAX_JAC_NBI, &YG1Y_gag, Yjac[0], Ytbeta);
987         if (1==0 || Yj-1<0){} 
988         else 
989         YG1_bet( Yi, Yj-1, YTemps) += Ytbeta[0];
990         if (1==0 || Yj-1<0){} 
991         else 
992         YG2_bet( Yi, Yj-1, YTemps) += Ytbeta[1];
993         Yting[0]=YS1_nj( Yi, Yj);
994         memset(Yjac, 0, 20*sizeof(double));
995         Ydiac(Yi, Yj)->backward( Yting[0] );
996         Yvsmatt (YNBS_diac, YNBI_diac, YMAX_JAC_NBI, &YG1Y_diac, Yjac[0], Ytbeta);
997         YG1_nj( Yi, Yj) += Ytbeta[0];
998         Yting[0]=YS1_nj( Yi, Yj);
999         memset(Yjac, 0, 20*sizeof(double));
1000         Ydiab(Yi, Yj)->backward( Yting[0] );
1001         Yvsmatt (YNBS_diab, YNBI_diab, YMAX_JAC_NBI, &YG1Y_diab, Yjac[0], Ytbeta);
1002         YG1_nj( Yi, Yj) += Ytbeta[0];
1003         Yting[0]=YS1_ssd( Yi, Yj);
1004         memset(Yjac, 0, 10*sizeof(double));
1005         Ynj(Yi, Yj)->backward( Yting[0] );
1006         Yvsmatt (YNBS_nj, YNBI_nj, YMAX_JAC_NBI, &YG1Y_nj, Yjac[0], Ytbeta);
1007         YG1_ssd( Yi, Yj) += Ytbeta[0];
1008
1009}
1010
1011}
1012}
1013  endBackward=my_gettimeofday();
1014  counter ++;
1015
1016  printf("\n\n################FORWARD-BACKWARD_SPACE_SAC#########################################");
1017//  printf("\nTime begin: %f", begin);
1018//  printf("\nTime end: %f", end);
1019  printf("\nTimeForwardDifference %f", (endForward - beginForward));
1020  printf("\nTimeBackwardDifference %f", (endBackward - beginBackward));
1021  printf("\ncounter %d ", counter);
1022  differenceForward = differenceForward + (endForward - beginForward);
1023  differenceBackward = differenceBackward + (endBackward - beginBackward);
1024  printf("Average %f", (differenceForward + differenceBackward) / counter );
1025  printf("\n############################################################################\n\n");
1026  //parallelForward = parallelForward + (endParallelForward - beginParallelForward);
1027  //parallelBackward = parallelBackward + (endParallelBackward - beginParallelBackward);
1028  //nonParallelForward = nonParallelForward + (endNonParallelForward - beginNonParallelForward);
1029  //nonParallelBackward = nonParallelBackward + (endNonParallelBackward - beginNonParallelBackward);
1030         return(0);
1031}
1032
1033 int Yforward_space_Olap()
1034{
1035         YA1=2049; YA2=0; YA3=0;
1036Yi=-1; Yj=-1; Yk=-1; /* init des indices de maille: maj par la boucle si valide*/
1037#pragma omp parallel for
1038for(YY=0; YY<YA1_Olap; ++YY){
1039  Yi=YY;
1040{
1041         if (1==0 || Yi-1<0)
1042         Yting[0]=0; 
1043         else 
1044         Yting[0]=YW1_gama( Yi-1);
1045         if (1==0 || Yi-1<0)
1046         Yting[1]=0; 
1047         else 
1048         Yting[1]=YW2_gama( Yi-1);
1049         Yting[2]=YW1_gama( Yi);
1050         Yting[3]=YW2_gama( Yi);
1051         if (1==0 || Yi+1>YA1_Olap-1)
1052         Yting[4]=0; 
1053         else 
1054         Yting[4]=YW1_gama( Yi+1);
1055         if (1==0 || Yi+1>YA1_Olap-1)
1056         Yting[5]=0; 
1057         else 
1058         Yting[5]=YW2_gama( Yi+1);
1059         Ylap(Yi)->forward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5] );
1060
1061}
1062}
1063
1064         return(0);
1065}
1066
1067 int Ybackward_space_Olap()
1068{
1069         YA1=2049; YA2=0; YA3=0;
1070Yi=-1; Yj=-1; Yk=-1; /* init des indices de maille: maj par la boucle si valide*/
1071#pragma omp parallel for
1072for(YY=YA1_Olap-1; YY>=0; --YY){
1073  Yi=YY;
1074{
1075         if (1==0 || Yi-1<0)
1076         Yting[0]=0; 
1077         else 
1078         Yting[0]=YW1_gama( Yi-1);
1079         if (1==0 || Yi-1<0)
1080         Yting[1]=0; 
1081         else 
1082         Yting[1]=YW2_gama( Yi-1);
1083         Yting[2]=YW1_gama( Yi);
1084         Yting[3]=YW2_gama( Yi);
1085         if (1==0 || Yi+1>YA1_Olap-1)
1086         Yting[4]=0; 
1087         else 
1088         Yting[4]=YW1_gama( Yi+1);
1089         if (1==0 || Yi+1>YA1_Olap-1)
1090         Yting[5]=0; 
1091         else 
1092         Yting[5]=YW2_gama( Yi+1);
1093         memset(Yjac, 0, 20*sizeof(double));
1094         Ylap(Yi)->backward( Yting[0], Yting[1], Yting[2], Yting[3], Yting[4], Yting[5] );
1095         Yvsmatt (YNBS_lap, YNBI_lap, YMAX_JAC_NBI, &YG1Y_lap, Yjac[0], Ytbeta);
1096         if (1==0 || Yi-1<0){} 
1097         else 
1098         #pragma omp atomic
1099         YG1_gama( Yi-1) += Ytbeta[0];
1100         if (1==0 || Yi-1<0){} 
1101         else 
1102         #pragma omp atomic
1103         YG2_gama( Yi-1) += Ytbeta[1];
1104         YG1_gama( Yi) += Ytbeta[2];
1105         YG2_gama( Yi) += Ytbeta[3];
1106         if (1==0 || Yi+1>YA1_Olap-1){} 
1107         else 
1108         #pragma omp atomic
1109         YG1_gama( Yi+1) += Ytbeta[4];
1110         if (1==0 || Yi+1>YA1_Olap-1){} 
1111         else 
1112         #pragma omp atomic
1113         YG2_gama( Yi+1) += Ytbeta[5];
1114
1115}
1116}
1117
1118         return(0);
1119}
1120
1121int Yforward_traj_Tlu(int nbp)
1122{
1123//       printf("\n##aaaaaaiiiiiiiiiiii##########################################################################\n\n");
1124        Ycurward=FORWARD;
1125         Yforward_space_Sac();
1126         return(0);
1127}
1128
1129int Ybackward_traj_Tlu(int nbp)
1130{
1131//       printf("\n##bbbbbbiiiiiiiiiiii##########################################################################\n\n");
1132        Ycurward=BACKWARD;
1133         Ybackward_space_Sac();
1134         return(0);
1135}
1136
1137int Yforward_order()
1138{
1139//       printf("\n##cccccciiiiiiiiiiii##########################################################################\n\n");
1140//       printf("\n############################################################################\n\n");
1141         Yforward_traj_Tlu(0);
1142
1143 return(0);
1144}
1145
1146int Ybackward_order()
1147{
1148         //printf("\n##uuuuuuuuuuuuu##########################################################################\n\n");
1149         //printf("\n############################################################################\n\n");
1150         Ybackward_traj_Tlu(0);
1151         //printf("\n############################################################################\n\n");
1152/*  if (counter > 6){
1153         printf("\n############################################################################\n\n");
1154    printf("\ncounter %d", counter);
1155    printf("\nTimeForwardDifference %f", differenceForward);
1156    printf("\nTimeBackwardDifference %f", differenceBackward);
1157    printf("\nAverageForward %f", differenceForward / counter );
1158    printf("\nAverageBackward %f", differenceBackward / counter );
1159    printf("\nAverage %f", (differenceForward + differenceBackward) / counter );
1160    //printf("\nParallel time %f", (parallelForward + parallelBackward) / counter );
1161    //printf("\nNon Parallel time %f", (nonParallelForward + nonParallelBackward) / counter );
1162         printf("\n############################################################################\n\n");
1163  }
1164*/     
1165         return(0);
1166}
1167
1168void Yforward_operator (char type) 
1169{       
1170        if ((YTabOpera[Yid_Olap].type==type || type=='*')  && YTabOpera[Yid_Olap].isactiv) Yforward_space_Olap();
1171}
1172void Ybackward_operator (char type) 
1173{       
1174        if ((YTabOpera[Yid_Olap].type==type || type=='*')  && YTabOpera[Yid_Olap].isactiv) Ybackward_space_Olap();
1175}
1176
1177// € € € € € € € € LES FONCTIONS UTILISATEUR ... :
1178int Yuser_call (int argc, char *argv[]) 
1179{
1180         int codret=1;
1181         if (strcmp(argv[0], "xdisplay") == 0)
1182                 xdisplay();
1183         else if (strcmp(argv[0], "xset_init") == 0)
1184                 xset_init();
1185         else if (strcmp(argv[0], "xnorme") == 0)
1186                 xnorme();
1187         else if (strcmp(argv[0], "xgama0") == 0)
1188                 xgama0(argc, argv);
1189         else if (strcmp(argv[0], "xset_deltazr") == 0)
1190                 xset_deltazr(argc, argv);
1191         else if (strcmp(argv[0], "xset_c0") == 0)
1192                 xset_c0(argc, argv);
1193         else if (strcmp(argv[0], "xset_freq") == 0)
1194                 xset_freq(argc, argv);
1195         else if (strcmp(argv[0], "xset_tab_freq") == 0)
1196                 xset_tab_freq(argc, argv);
1197         else if (strcmp(argv[0], "xset_zs") == 0)
1198                 xset_zs(argc, argv);
1199         else if (strcmp(argv[0], "xset_fac") == 0)
1200                 xset_fac(argc, argv);
1201         else if (strcmp(argv[0], "xset_gama") == 0)
1202                 xset_gama(argc, argv);
1203         else if (strcmp(argv[0], "xcoef_OBS") == 0)
1204                 xcoef_OBS(argc, argv);
1205         else codret=0;
1206         return(codret);
1207}
1208
1209//-------------- end Yao generation -----------------
Note: See TracBrowser for help on using the repository browser.