source: Sophya/trunk/AddOn/TAcq/brviscalc.cc@ 3921

Last change on this file since 3921 was 3921, checked in by ansari, 15 years ago

tentative d'optimisation du calcul des visibilites, reza 03/12/2010
File size: 21.8 KB
Line 
1//----------------------------------------------------------------
2// Projet BAORadio - (C) LAL/IRFU 2008-2010
3// Classes de threads de calcul de visibilites pour BAORadio
4//----------------------------------------------------------------
5
6#include <stdlib.h>
7#include <string.h>
8#include <unistd.h>
9#include <fstream>
10#include <signal.h>
11
12#include "pexceptions.h"
13#include "fioarr.h"
14#include "matharr.h"
15#include "timestamp.h"
16#include "ctimer.h"
17
18#include "brviscalc.h"
19
20
21//---------------------------------------------------------------------
22// Classe de traitement - calcul de visibilite pour n fibres
23//---------------------------------------------------------------------
24
25/* --Methode-- */
26BRVisibilityCalculator::BRVisibilityCalculator(RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean, size_t nthr)
27 : BRBaseProcessor(memgr), paralex_(*this, nthr), nparthr_(nthr),
28 outpath_(outpath), nmean_(nmean), nbcalc_(1), calcid_(0), vpdata_(2*memgr.NbFibres())
29 // , dtfos_(outpath+"visdt.fits", Fits_Create), visdt_(dtfos_, 1024, true);
30{
31 DefineRank(1,0);
32
33 uint_4 maxnpairs = (2*memgr_.NbFibres()+1)*memgr_.NbFibres();
34 chanids_.SetSize(2*memgr_.NbFibres());
35 chanpairnumall_.SetSize(maxnpairs);
36 chanpairsall_.SetSize(maxnpairs,2);
37 for(size_t i=0; i<2*memgr_.NbFibres(); i++) vpdata_[i]=NULL;
38 SelectPairs();
39
40 // visdt_.AddFloatColumn("mfc");
41 visdt_.AddDoubleColumn("mfc");
42 visdt_.AddDoubleColumn("mtt");
43 visdt_.AddIntegerColumn("jfreq");
44 visdt_.AddIntegerColumn("numch");
45 visdt_.AddFloatColumn("vre");
46 visdt_.AddFloatColumn("vim");
47 ActivateVisDTable();
48
49 if (nmean_ < 1) nmean_=memgr_.NbPaquets();
50 if (nmean_ < 1) nmean_=1;
51
52 cout << " BRVisibilityCalculator::/Info nmean=" << nmean_ << endl;
53
54 totnbpaq_=0;
55 numfile_=0;
56 nb_flop_=0.;
57 moyfc_=moytt_=0.;
58
59 fgallfibok=NULL;
60 fgcktt_=false;
61 setNameId("viscalc", 0);
62}
63
64/* --Methode-- */
65BRVisibilityCalculator::~BRVisibilityCalculator()
66{
67 if (totnbpaq_<1) return;
68 if (fgvisdt_) {
69 cout << " ~BRVisibilityCalculator - Visibility Datatable : " << endl;
70 cout << visdt_;
71
72 string filename;
73 filename = outpath_+"visdt.ppf";
74 if (nbcalc_>1) {
75 char sbuff[32];
76 sprintf(sbuff,"visdt_%d.ppf",(int)calcid_);
77 filename = outpath_+sbuff;
78 }
79 POutPersist po(filename);
80 po << visdt_;
81 }
82 if (calcid_ == 0) {
83 if (fgcktt_) {
84 cout << " BRVisibilityCalculator - Check TimeTag done: TotNPaqProc= " << totnbpaq_ << endl;
85 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
86 cout << " BRTTCheck-Fiber[" << fib << "] NBadTT=" << vbadtt_[fib] << " NDiffTT>5="
87 << vndiff5tt_[fib] << " NotSameTT=" << vnsamett_[fib] << endl;
88 }
89 POutPersist pott(outpath_+"ttfcmtx.ppf");
90 pott << PPFNameTag("FC") << fcmtx_;
91 pott << PPFNameTag("TT") << ttmtx_;
92 }
93 }
94}
95
96/* --Methode-- */
97void BRVisibilityCalculator::DefineRank(uint_4 nbc, uint_4 cid, uint_4 pair1, uint_4 nbpairs, bool fgpimp)
98{
99 if ((nbc>6)||(cid>=nbc))
100 throw ParmError("BRVisibilityCalculator::DefineRank() NbCalc > 6 !");
101 uint_4 maxnpairs = (2*memgr_.NbFibres()+1)*memgr_.NbFibres();
102 if ((pair1>=maxnpairs)||(nbpairs<1))
103 throw ParmError("BRVisibilityCalculator::DefineRank() (pair1>=maxnpairs)||(nbpairs<1) !");
104 maxnpairs-=pair1;
105 if (maxnpairs>nbpairs) maxnpairs=nbpairs;
106
107 nbcalc_=nbc;
108 calcid_=cid;
109 if (nbcalc_>1) {
110 uint_4 npairspth=maxnpairs/nbcalc_; // nb de paires par thread
111 if (calcid_==(nbcalc_-1))
112 SelectPairs(calcid_*npairspth+pair1, maxnpairs-calcid_*npairspth, fgpimp);
113 else
114 SelectPairs(calcid_*npairspth+pair1, npairspth, fgpimp);
115 MemZaction mmzas[6]={MemZA_ProcA,MemZA_ProcB,MemZA_ProcC,MemZA_ProcD,MemZA_ProcE,MemZA_ProcF};
116 SetMemZAction(mmzas[calcid_]);
117 setNameId("viscalc_grp", calcid_);
118 }
119 else SelectPairs(pair1,maxnpairs, fgpimp);
120 return ;
121}
122
123/* --Methode-- */
124uint_4 BRVisibilityCalculator::SelectPairs(uint_4 pair1, uint_4 nbpairs, bool fgpimp)
125{
126 BRPaquet paq(memgr_.PaqSize());
127 uint_4 maxnpairs = (2*memgr_.NbFibres()+1)*memgr_.NbFibres();
128
129 if (pair1 >= maxnpairs) pair1=maxnpairs-1;
130 if (nbpairs > maxnpairs-pair1) nbpairs=maxnpairs-pair1;
131
132 pairst_=pair1;
133 nbpairs_=nbpairs;
134 fgpimp_=fgpimp;
135
136 uint_4 nbvisicomp=0;
137 sa_size_t kpair=0;
138 for(size_t i=0; i<vpdata_.size(); i++) {
139 for(size_t j=i; j<vpdata_.size(); j++) {
140 kpair++;
141 if (kpair<(pairst_+1)) continue;
142 if (kpair>=(pairst_+nbpairs_+1)) break;
143 if (fgpimp_&&(i!=j)&&((i+j)%2==0)) continue; // calcul des visib avec numero pair-impair + autocorrel
144 nbvisicomp++;
145 }
146 }
147
148 vismtx_.SetSize(nbvisicomp, paq.DataSize()/4);
149
150 chanpairnum_.SetSize(nbvisicomp);
151 chanpairs_.SetSize(nbvisicomp,2);
152
153 return nbvisicomp;
154}
155
156/* --Methode-- */
157int BRVisibilityCalculator::SelectFreqBinning(uint_4 freq1, uint_4 freq2, uint_4 nbfreq)
158{
159 jf1_=freq1; jf2_=freq2;
160 if ((jf1_<1)||(jf1_>=vismtx_.NCols())) jf1_=1;
161 if ((jf2_<1)||(jf2_>=vismtx_.NCols())||(jf2_<jf1_)) jf2_=vismtx_.NCols()-1;
162 if (nbfreq<1) nbfreq=(jf2_-jf1_);
163 djf_=(jf2_-jf1_)/nbfreq;
164 if (djf_<1) djf_=1;
165 cout << " BRVisibilityCalculator::SelectFreqBinning/Info JF1=" << jf1_
166 << " JF2=" << jf2_ << " DJF=" << djf_ << endl;
167
168}
169
170/* --Methode-- */
171void BRVisibilityCalculator::UpdateChanIds()
172{
173
174 for(size_t i=0; i<memgr_.NbFibres(); i++) {
175 chanids_(2*i)=memgr_.FiberId(i)*2-1;
176 chanids_(2*i+1)=memgr_.FiberId(i)*2;
177 }
178 sa_size_t k=0; // numero de ligne dans la matrice des visibilites
179 for(size_t i=0; i<vpdata_.size(); i++) {
180 for(size_t j=i; j<vpdata_.size(); j++) {
181 chanpairnumall_(k)=chanids_(i)*CHANPAIRCONVFAC+chanids_(j);
182 chanpairsall_(k,0)=chanids_(i); chanpairsall_(k,1)=chanids_(j); k++;
183 }
184 }
185 sa_size_t kpair=0;
186 k=0; // numero de ligne dans la matrice des visibilites
187 for(size_t i=0; i<vpdata_.size(); i++) {
188 for(size_t j=i; j<vpdata_.size(); j++) {
189 kpair++;
190 if (kpair<(pairst_+1)) continue;
191 if (kpair>=(pairst_+nbpairs_+1)) break;
192 if (fgpimp_&&(i!=j)&&((i+j)%2==0)) continue; // calcul des visib avec numero pair-impair + autocorrel
193 chanpairnum_(k)=chanids_(i)*CHANPAIRCONVFAC+chanids_(j);
194 chanpairs_(k,0)=chanids_(i); chanpairs_(k,1)=chanids_(j); k++;
195 }
196 }
197
198 string filename;
199 filename = outpath_+"chanum.ppf";
200 if (nbcalc_>1) {
201 char sbuff[32];
202 sprintf(sbuff,"chanum_%d.ppf",(int)calcid_);
203 filename = outpath_+sbuff;
204 }
205 POutPersist poc(filename);
206 poc << PPFNameTag("chanids") << chanids_;
207 poc << PPFNameTag("chanpairs") << chanpairs_;
208 poc << PPFNameTag("chanpairnum") << chanpairnum_;
209 poc << PPFNameTag("chanpairsall") << chanpairsall_;
210 poc << PPFNameTag("chanpairnumall") << chanpairnumall_;
211 cout << "BRVisibilityCalculator[" << calcid_ << "]::UpdateChanIds() Channel Ids/Pairs saved to PPF file "
212 << filename << endl;
213 cout << " ... NbVisib=NbChanPairs=" << chanpairs_.NRows() << " ChannelPairs= " ;
214 for(sa_size_t ir=0; ir<chanpairs_.NRows(); ir++) {
215 if (ir%10==0) cout << endl;
216 cout << "(" << chanpairs_(ir,0) << "," << chanpairs_(ir,1) << ") ";
217 }
218 cout << endl;
219 return;
220}
221
222/* --Methode-- */
223int BRVisibilityCalculator::ActivateTimeTagCheck(uint_8 maxnpaq)
224{
225 mindeltatt_=memgr_.PaqSize()/2;
226 if (mindeltatt_<1) mindeltatt_=1;
227 fcmtx_.SetSize(memgr_.NbFibres(), maxnpaq);
228 ttmtx_.SetSize(memgr_.NbFibres(), maxnpaq);
229 vlasttt_.resize(memgr_.NbFibres(), 0);
230 vbadtt_.resize(memgr_.NbFibres(), 0);
231 vnsamett_.resize(memgr_.NbFibres(), 0);
232 vndiff5tt_.resize(memgr_.NbFibres(), 0);
233
234 fgcktt_=true;
235 cout << " BRVisibilityCalculator::ActivateTimeTagCheck() - TT/Fc matrix NCols=" << maxnpaq
236 << " MinDeltaTT=" << mindeltatt_ << endl;
237
238 return 0;
239}
240
241
242/* --Methode-- */
243void BRVisibilityCalculator::run()
244{
245 cout << " BRVisibilityCalculator[" << calcid_ << "/" << nbcalc_
246 << "]::run() - Starting " << " NFibers=" << memgr_.NbFibres()
247 << " NChan=" << 2*memgr_.NbFibres() << " NPairs=" << nbpairs_ << " First:" << pairst_ << endl;
248
249 if (nparthr_ < 2) return BRBaseProcessor::run();
250 // Execution multithread parallele
251 setRC(1);
252 int rc=0;
253 try {
254 if ((nmean_%memgr_.NbPaquets())!=0) {
255 uint_4 mnmean = (nmean_/memgr_.NbPaquets()+1)*memgr_.NbPaquets();
256 cout << " BRVisibilityCalculator::run()/Info changing nmean=" << nmean_ << " to multiple of"
257 << " memgr_.NbPaquets() -> " << mnmean << endl;
258 nmean_=mnmean;
259 }
260 paralex_.SetParallelTask(*this);
261 cout << " BRVisibilityCalculator::run()/Info : starting ParallelExecutor with nThreads="
262 << paralex_.nThreads() << " ... " << endl;
263 paralex_.start();
264
265 fgallfibok = new bool[memgr_.NbPaquets()];
266
267 size_t paqsz=memgr_.PaqSize();
268 bool fgrun=true;
269 while (fgrun) {
270 if (stop_) break;
271 if (memgr_.GetRunState() == MemZR_Stopped) break;
272 int mid = memgr_.FindMemZoneId(mmact_); // (MemZA_ProcA);
273 // Byte* buffg = memgr_.GetMemZone(mid);
274 // if (buffg == NULL) {
275 if (mid < 0) {
276 cout << "BRVisibilityCalculator[" << calcid_ << "]::run()/ERROR FindMemZoneId("
277 << (int)mmact_ << ") ->" << mid << ") -> NULL" << endl;
278 setRC(7); fgrun=false;
279 break;
280 }
281 cts_=memgr_.GetAuxData(mid)->FillTime(); // get associated date/time (DATEOBS)
282 if (totnbpaq_==0) UpdateChanIds(); // Appele ici pour etre sur que le thread de remplissage a mis l'info a jour.
283
284 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
285 fbuff_[fib] = memgr_.GetMemZone(mid,fib);
286 if (fbuff_[fib] == NULL) { // cela ne devrait pas arriver
287 cout << "BRVisibilityCalculator[" << calcid_ << "]::run()/ERROR memgr.GetMemZone(" << mid << "," << fib << ") -> NULL" << endl;
288 setRC(9); fgrun=false;
289 break;
290 }
291 }
292
293 if (totnbpaq_%nmean_ == 0) {
294 if (totnbpaq_ > 0) {
295 moyfc_/=nmean_;
296 moytt_/=nmean_;
297 UpdateVisMtxInfo(); // add/update keywords in the Info DVList
298 // ATTENTION : Matrice visibilites non moyennee
299 char nfile[48];
300 if (nbcalc_==1)
301 sprintf(nfile,"vismtx%d.ppf",numfile_);
302 else
303 sprintf(nfile,"vismtx_%d_%d.ppf",(int)calcid_,numfile_);
304 string flnm=outpath_+nfile;
305 POutPersist po(flnm);
306 po << vismtx_;
307 cout << numfile_ << "-BRVisCalc[" << calcid_ << "/" << nbcalc_ << "]::run() NPaqProc="
308 << totnbpaq_ << " TotMegaFLOP=" << (uint_8)TotNbMegaFLOP() << " -> VisibMtx in " << flnm << endl;
309
310 if (fgvisdt_) FillVisibTable(moyfc_, moytt_);
311 numfile_++;
312 }
313 vismtx_ = complex<r_4>((r_4)0.,(r_4)0.);
314 moyfc_=moytt_=0.;
315 // first_tmstamp_.SetNow(); // Current date and time
316 first_tmstamp_=cts_; // Current date and time
317 }
318
319 for(size_t jp=0; jp<memgr_.NbPaquets(); jp++) { // boucle sur les paquets d'une zone
320 fgallfibok[jp]=fgokallfibers_=true;
321 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
322 vpaq_[fib].Set(fbuff_[fib]+jp*paqsz);
323 vfgok_[fib] = vpchk_[fib].Check(vpaq_[fib],curfc_[fib]);
324 if (!vfgok_[fib]) fgallfibok[jp]=fgokallfibers_=false;
325 }
326 if (fgokallfibers_) {
327 if (totprocnpaq_==0) {
328 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
329 fcfirst_[fib]=curfc_[fib];
330 ttfirst_[fib]=vpaq_[fib].TimeTag();
331 }
332 }
333 totprocnpaq_++;
334 moyfc_ += curfc_[0];
335 moytt_ += (vpaq_[0].TimeTag()-ttfirst_[0]);
336 if ((fgcktt_)&&(calcid_==0)) CheckTimeTag();
337 if (totnbpaq_%nmean_ == 0) {
338 first_fc_=curfc_[0];
339 first_tt_= (vpaq_[0].TimeTag()-ttfirst_[0]);
340 }
341 totnbpaq_++;
342 }
343 } // Fin de boucle sur les paquets
344
345 // Execution parallele pour calcul des visibilites par bandes de frequence
346 int rcpex=paralex_.execute();
347 if (rcpex!=0) cout << " BRVisibilityCalculator[" << calcid_ << "]::run() / Error Rc[paralex_.execute()]=" << rcpex << endl;
348
349 memgr_.FreeMemZone(mid, mmsta_); // (MemZS_ProcA);
350 } // Fin de boucle sur les zones a traiter
351 //------------------------------------
352 cout << " --------- END BRVisibilityCalculator[" << calcid_ << "]::run() , TotNbProcPaq=" << totprocnpaq_ << endl;
353 /*
354 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) vpchk_[fib].Print();
355 cout << " ------------------------------------ " << endl;
356 */
357 delete[] fgallfibok;
358 }
359 catch (std::exception& exc) {
360 cout << " BRVisibilityCalculator[" << calcid_ << "]::run()/catched std::exception " << exc.what() << endl;
361 setRC(98);
362 return;
363 }
364 catch(...) {
365 cout << " BRVisibilityCalculator[" << calcid_ << "]::run()/catched unknown ... exception " << endl;
366 setRC(99);
367 return;
368 }
369
370}
371
372/* --Methode-- */
373int BRVisibilityCalculator::Process()
374{
375 if (totnbpaq_==0) UpdateChanIds(); // Appele ici pour etre sur que le thread de remplissage a mis l'info a jour.
376 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
377 vpdata_[2*fib] = vpaq_[fib].Data1C();
378 vpdata_[2*fib+1] = vpaq_[fib].Data2C();
379 }
380
381 if (totnbpaq_%nmean_ == 0) {
382 if (totnbpaq_ > 0) {
383 moyfc_/=nmean_;
384 moytt_/=nmean_;
385 UpdateVisMtxInfo(); // add/update keywords in the Info DVList
386 // ATTENTION : Matrice visibilites non moyennee
387 char nfile[48];
388 if (nbcalc_==1)
389 sprintf(nfile,"vismtx%d.ppf",numfile_);
390 else
391 sprintf(nfile,"vismtx_%d_%d.ppf",(int)calcid_,numfile_);
392 string flnm=outpath_+nfile;
393 POutPersist po(flnm);
394 po << vismtx_;
395 cout << numfile_ << "-BRVisCalc[" << calcid_ << "/" << nbcalc_ << "]::Process() NPaqProc="
396 << totnbpaq_ << " TotMegaFLOP=" << (uint_8)TotNbMegaFLOP() << " -> VisibMtx in " << flnm << endl;
397 if (fgvisdt_) FillVisibTable(moyfc_, moytt_);
398 numfile_++;
399 }
400 vismtx_ = complex<r_4>((r_4)0.,(r_4)0.);
401 moyfc_=moytt_=0.;
402 first_fc_=curfc_[0];
403 first_tt_= (vpaq_[0].TimeTag()-ttfirst_[0]);
404 // first_tmstamp_.SetNow(); // Current date and time
405 first_tmstamp_=cts_; // Current date and time
406 }
407
408// kpair=numero sequentiel de la paire: 0->(0,0), 1->(0,1), 2->(0,2), 3->(0,3), 4->(1,1), 5->(1,2) ...
409 sa_size_t kpair=0;
410 sa_size_t k=0; // numero de ligne dans la matrice des visibilites
411 for(size_t i=0; i<vpdata_.size(); i++) {
412 for(size_t j=i; j<vpdata_.size(); j++) {
413 kpair++;
414 if (kpair<(pairst_+1)) continue;
415 if (kpair>=(pairst_+nbpairs_+1)) break;
416 if (fgpimp_&&(i!=j)&&((i+j)%2==0)) continue; // calcul des visib avec numero pair-impair + autocorrel
417 TVector< complex<r_4> > vis = vismtx_.Row(k); k++;
418 TwoByteComplex* zv1=vpdata_[i];
419 TwoByteComplex* zv2=vpdata_[j];
420 for(sa_size_t f=1; f<vis.Size(); f++) {
421 vis(f) += complex<r_4>((r_4)zv1->realB(), (r_4)zv1->imagB()) *
422 complex<r_4>((r_4)zv2->realB(), -(r_4)zv2->imagB());
423 zv1++; zv2++;
424 }
425 /*
426 for(sa_size_t f=1; f<vis.Size(); f++) {
427 vis(f) += complex<r_4>((r_4)vpdata_[i][f].realB(), (r_4)vpdata_[i][f].imagB()) *
428 complex<r_4>((r_4)vpdata_[j][f].realB(), -(r_4)vpdata_[j][f].imagB());
429 }
430 */
431 nb_flop_ += (8.*(r_8)(vis.Size()-1));
432 }
433 }
434
435 moyfc_ += curfc_[0];
436 moytt_ += (vpaq_[0].TimeTag()-ttfirst_[0]);
437 if ((fgcktt_)&&(calcid_==0)) CheckTimeTag();
438 totnbpaq_++;
439 return 0;
440}
441
442/* --Methode-- */
443void BRVisibilityCalculator::UpdateVisMtxInfo()
444{
445 string ikey,ikdesc;
446 ikey="DATEOBS"; ikdesc=" Date/Time corresponding to TimeTagFirst";
447 vismtx_.Info().SetS(ikey,first_tmstamp_.ToString());
448 vismtx_.Info().SetComment(ikey,ikdesc);
449 ikey="FirstFC"; ikdesc="First FrameCounter";
450 vismtx_.Info().SetI(ikey,first_fc_);
451 vismtx_.Info().SetComment(ikey,ikdesc);
452 ikey="FirstTT"; ikdesc="First TimeTag";
453 vismtx_.Info().SetI(ikey,first_tt_);
454 vismtx_.Info().SetComment(ikey,ikdesc);
455 ikey="LastFC"; ikdesc="Last FrameCounter";
456 vismtx_.Info().SetI(ikey,curfc_[0]);
457 vismtx_.Info().SetComment(ikey,ikdesc);
458 ikey="LastTT"; ikdesc="Last TimeTag";
459 vismtx_.Info().SetI(ikey,vpaq_[0].TimeTag()-ttfirst_[0]);
460 vismtx_.Info().SetComment(ikey,ikdesc);
461 ikey="MeanFC"; ikdesc="Mean FrameCounter";
462 vismtx_.Info().SetD(ikey,moyfc_);
463 vismtx_.Info().SetComment(ikey,ikdesc);
464 ikey="MeanTT"; ikdesc="Mean TimeTag";
465 vismtx_.Info().SetD(ikey,moytt_);
466 vismtx_.Info().SetComment(ikey,ikdesc);
467 ikey="NPAQSUM"; ikdesc="Number of paquets summed";
468 vismtx_.Info().SetI(ikey,nmean_);
469}
470
471
472/* --Methode-- */
473int BRVisibilityCalculator::execute(int tid)
474{
475 vector<TwoByteComplex*> pvpdata(2*memgr_.NbFibres());
476 size_t paqsz=memgr_.PaqSize();
477 BRPaquet ppaq(paqsz);
478
479
480 sa_size_t fdelt = vismtx_.NCols()/nparthr_;
481 sa_size_t fdeb = tid*fdelt;
482 sa_size_t ffin = (tid+1)*fdelt;
483
484 if (fdeb<1) fdeb=1;
485 if ((ffin>vismtx_.NCols())||(tid==(nparthr_-1))) ffin=vismtx_.NCols();
486
487 for(size_t jp=0; jp<memgr_.NbPaquets(); jp++) { // boucle sur les paquets d'une zone
488 if (!fgallfibok[jp]) continue;
489 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
490 ppaq.Set(fbuff_[fib]+jp*paqsz);
491 pvpdata[2*fib] = ppaq.Data1C();
492 pvpdata[2*fib+1] = ppaq.Data2C();
493 }
494
495
496// kpair=numero sequentiel de la paire: 0->(0,0), 1->(0,1), 2->(0,2), 3->(0,3), 4->(1,1), 5->(1,2) ...
497 sa_size_t kpair=0;
498 sa_size_t k=0; // numero de ligne dans la matrice des visibilites
499 for(size_t i=0; i<vpdata_.size(); i++) {
500 for(size_t j=i; j<vpdata_.size(); j++) {
501 kpair++;
502 if (kpair<(pairst_+1)) continue;
503 if (kpair>=(pairst_+nbpairs_+1)) break;
504 if (fgpimp_&&(i!=j)&&((i+j)%2==0)) continue; // calcul des visib avec numero pair-impair + autocorrel
505 TVector< complex<r_4> > vis = vismtx_.Row(k); k++;
506 for(sa_size_t f=fdeb; f<ffin; f++) {
507 vis(f) += complex<r_4>((r_4)pvpdata[i][f].realB(), (r_4)pvpdata[i][f].imagB()) *
508 complex<r_4>((r_4)pvpdata[j][f].realB(), -(r_4)pvpdata[j][f].imagB());
509 }
510 nb_flop_ += (8.*(r_8)(ffin-fdeb));
511 }
512 }
513
514 } // Fin de boucle sur les paquets
515
516 return 0;
517}
518
519/* --Methode-- */
520int BRVisibilityCalculator::FillVisibTable(double fcm, double ttm)
521{
522 double xnt[10];
523 xnt[0]=fcm; xnt[1]=ttm/1.25e8;
524
525 if (djf_<2) {
526 for(sa_size_t rv=0; rv<vismtx_.NRows(); rv++) {
527 for(sa_size_t jf=jf1_; jf<jf2_; jf++) {
528 xnt[2]=jf;
529 xnt[3]=chanpairnumall_(rv+pairst_);
530 xnt[4]=vismtx_(rv,jf).real()/(r_4)(nmean_);
531 xnt[5]=vismtx_(rv,jf).imag()/(r_4)(nmean_);
532 visdt_.AddRow(xnt);
533 }
534 }
535 }
536 else {
537 for(sa_size_t rv=0; rv<vismtx_.NRows(); rv++) {
538 for(sa_size_t jf=jf1_; jf<jf2_; jf+=djf_) {
539 r_4 moyreal=0.;
540 r_4 moyimag=0.;
541 sa_size_t jjfmx=jf+djf_;
542 if (jjfmx > vismtx_.NCols()) jjfmx=vismtx_.NCols();
543 for(sa_size_t jjf=jf; jjf<jjfmx; jjf++) {
544 moyreal+=vismtx_(rv,jjf).real();
545 moyimag+=vismtx_(rv,jjf).imag();
546 }
547 xnt[2]=jf+djf_/2;
548 xnt[3]=chanpairnumall_(rv+pairst_);
549 xnt[4]=moyreal/(r_4)(nmean_*djf_);
550 xnt[5]=moyimag/(r_4)(nmean_*djf_);
551 visdt_.AddRow(xnt);
552 }
553 }
554 }
555 return 0;
556}
557
558/* --Methode-- */
559int BRVisibilityCalculator::CheckTimeTag()
560{
561 if (totnbpaq_==0) {
562 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
563 vlasttt_[fib]=ttfirst_[fib];
564 if (ttmtx_.NCols()>0) {
565 fcmtx_(fib,totnbpaq_) = curfc_[fib];
566 ttmtx_(fib,totnbpaq_) = vlasttt_[fib];
567 }
568 }
569 return 0;
570 }
571 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
572 int_8 ld = (int_8)vpaq_[fib].TimeTag()-(int_8)vlasttt_[fib];
573 int_8 fd = (int_8)vpaq_[fib].TimeTag()-(int_8)ttfirst_[fib]-(int_8)vpaq_[0].TimeTag()+(int_8)ttfirst_[0];
574 /* if ( (ld < mindeltatt_) || (fd<-5) || (fd>5)) { vbadtt_[fib]++; vnsamett_[fib]++; }
575 else {
576 if (fd!=0) vnsamett_[fib]++;
577 }
578 */
579 if (ld < mindeltatt_) vbadtt_[fib]++;
580 else {
581 if (fd != 0) vnsamett_[fib]++;
582 if ((fd<-5)||(fd>5)) vndiff5tt_[fib]++;
583 }
584 vlasttt_[fib]=vpaq_[fib].TimeTag();
585 if (totnbpaq_<ttmtx_.NCols()) {
586 fcmtx_(fib,totnbpaq_) = curfc_[fib];
587 ttmtx_(fib,totnbpaq_) = vlasttt_[fib];
588 }
589 }
590 return 0;
591}
592
593//-------------------------------------------------------------------------------
594// Classe Groupe (ensemble) de Calculateur de Visibilites, tournant en parallele
595//-------------------------------------------------------------------------------
596
597/* --Methode-- */
598BRVisCalcGroup::BRVisCalcGroup(size_t nbcalc, RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean,
599 uint_4 pair1, uint_4 nbpairs, bool fgpimp, size_t nthr)
600 : tm_(false)
601{
602 if ((nbcalc<1)||(nbcalc>6))
603 throw ParmError("BRVisCalcGroup::BRVisCalcGroup NbCalc > 6 !");
604 for(size_t i=0; i<nbcalc; i++) {
605 BRVisibilityCalculator * viscp=new BRVisibilityCalculator(memgr, outpath, nmean, nthr);
606 viscp->DefineRank(nbcalc, i, pair1, nbpairs, fgpimp);
607 viscalcp_.push_back(viscp);
608 }
609}
610/* --Methode-- */
611BRVisCalcGroup::~BRVisCalcGroup()
612{
613 for(size_t i=0; i<viscalcp_.size(); i++)
614 delete viscalcp_[i];
615}
616/* --Methode-- */
617int BRVisCalcGroup::SelectFreqBinning(uint_4 freq1, uint_4 freq2, uint_4 nbfreq)
618{
619 int rc=0;
620 for(size_t i=0; i<viscalcp_.size(); i++)
621 rc=viscalcp_[i]->SelectFreqBinning(freq1, freq2, nbfreq);
622 return rc;
623}
624/* --Methode-- */
625void BRVisCalcGroup::ActivateVisDTable(bool fgfdt)
626{
627 for(size_t i=0; i<viscalcp_.size(); i++)
628 viscalcp_[i]->ActivateVisDTable(fgfdt);
629}
630/* --Methode-- */
631void BRVisCalcGroup::start()
632{
633 for(size_t i=0; i<viscalcp_.size(); i++)
634 viscalcp_[i]->start();
635 tm_.SplitQ();
636}
637/* --Methode-- */
638void BRVisCalcGroup::join()
639{
640 r_8 totflop=0.;
641 for(size_t i=0; i<viscalcp_.size(); i++) {
642 viscalcp_[i]->join();
643 // cout << " BRVisCalcGroup::join()/ VisibCalc[" << i << "]->TotNbMegaFLOP()="
644 // << viscalcp_[i]->TotNbFLOP()/1024e3 << endl;
645 totflop += viscalcp_[i]->TotNbFLOP();
646 }
647 tm_.SplitQ();
648 cout << " ----------------------------------------------------------" << endl;
649 cout << " BRVisCalcGroup::join() : Finished " << viscalcp_.size() << " VisibilityCalculator(s)" << endl;
650 cout << " ... Elaspsed time: " << tm_.PartialElapsedTimems()
651 << " ms (total:" << tm_.TotalElapsedTimems() << ")" << endl;
652 double mflopsrate=totflop/(r_8)tm_.PartialElapsedTimems()/(1024.);
653 cout << " ... TotalMegaFLOP= " << totflop/(1024.e3) << " @ "
654 << mflopsrate << " MFLOP/s" << " (=" << mflopsrate/(r_8)viscalcp_.size() << "/VisibCalcObject)" << endl;
655 cout << " ----------------------------------------------------------" << endl;
656 return;
657}
Note: See TracBrowser for help on using the repository browser.