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

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

amelioration mineures au niveau de l'impression, 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 if ((prtlev_>0)&&(numfile_%prtmodulo_==0)) {
308 cout << numfile_ << "-BRVisCalc[" << calcid_ << "/" << nbcalc_ << "]::run() NPaqProc="
309 << totnbpaq_ << " TotMegaFLOP=" << (uint_8)TotNbMegaFLOP() << " -> VisibMtx in " << flnm << endl;
310 }
311 if (fgvisdt_) FillVisibTable(moyfc_, moytt_);
312 numfile_++;
313 }
314 vismtx_ = complex<r_4>((r_4)0.,(r_4)0.);
315 moyfc_=moytt_=0.;
316 // first_tmstamp_.SetNow(); // Current date and time
317 first_tmstamp_=cts_; // Current date and time
318 }
319
320 for(size_t jp=0; jp<memgr_.NbPaquets(); jp++) { // boucle sur les paquets d'une zone
321 fgallfibok[jp]=fgokallfibers_=true;
322 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
323 vpaq_[fib].Set(fbuff_[fib]+jp*paqsz);
324 vfgok_[fib] = vpchk_[fib].Check(vpaq_[fib],curfc_[fib]);
325 if (!vfgok_[fib]) fgallfibok[jp]=fgokallfibers_=false;
326 }
327 if (fgokallfibers_) {
328 if (totprocnpaq_==0) {
329 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
330 fcfirst_[fib]=curfc_[fib];
331 ttfirst_[fib]=vpaq_[fib].TimeTag();
332 }
333 }
334 totprocnpaq_++;
335 moyfc_ += curfc_[0];
336 moytt_ += (vpaq_[0].TimeTag()-ttfirst_[0]);
337 if ((fgcktt_)&&(calcid_==0)) CheckTimeTag();
338 if (totnbpaq_%nmean_ == 0) {
339 first_fc_=curfc_[0];
340 first_tt_= (vpaq_[0].TimeTag()-ttfirst_[0]);
341 }
342 totnbpaq_++;
343 }
344 } // Fin de boucle sur les paquets
345
346 // Execution parallele pour calcul des visibilites par bandes de frequence
347 int rcpex=paralex_.execute();
348 if (rcpex!=0) cout << " BRVisibilityCalculator[" << calcid_ << "]::run() / Error Rc[paralex_.execute()]=" << rcpex << endl;
349
350 memgr_.FreeMemZone(mid, mmsta_); // (MemZS_ProcA);
351 } // Fin de boucle sur les zones a traiter
352 //------------------------------------
353 cout << " --------- END BRVisibilityCalculator[" << calcid_ << "]::run() , TotNbProcPaq=" << totprocnpaq_ << endl;
354 /*
355 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) vpchk_[fib].Print();
356 cout << " ------------------------------------ " << endl;
357 */
358 delete[] fgallfibok;
359 }
360 catch (std::exception& exc) {
361 cout << " BRVisibilityCalculator[" << calcid_ << "]::run()/catched std::exception " << exc.what() << endl;
362 setRC(98);
363 return;
364 }
365 catch(...) {
366 cout << " BRVisibilityCalculator[" << calcid_ << "]::run()/catched unknown ... exception " << endl;
367 setRC(99);
368 return;
369 }
370
371}
372
373/* --Methode-- */
374int BRVisibilityCalculator::Process()
375{
376 if (totnbpaq_==0) UpdateChanIds(); // Appele ici pour etre sur que le thread de remplissage a mis l'info a jour.
377 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
378 vpdata_[2*fib] = vpaq_[fib].Data1C();
379 vpdata_[2*fib+1] = vpaq_[fib].Data2C();
380 }
381
382 if (totnbpaq_%nmean_ == 0) {
383 if (totnbpaq_ > 0) {
384 moyfc_/=nmean_;
385 moytt_/=nmean_;
386 UpdateVisMtxInfo(); // add/update keywords in the Info DVList
387 // ATTENTION : Matrice visibilites non moyennee
388 char nfile[48];
389 if (nbcalc_==1)
390 sprintf(nfile,"vismtx%d.ppf",numfile_);
391 else
392 sprintf(nfile,"vismtx_%d_%d.ppf",(int)calcid_,numfile_);
393 string flnm=outpath_+nfile;
394 POutPersist po(flnm);
395 po << vismtx_;
396 if ((prtlev_>0)&&(numfile_%prtmodulo_==0)) {
397 cout << numfile_ << "-BRVisCalc[" << calcid_ << "/" << nbcalc_ << "]::Process() NPaqProc="
398 << totnbpaq_ << " TotMegaFLOP=" << (uint_8)TotNbMegaFLOP() << " -> VisibMtx in " << flnm << endl;
399 }
400 if (fgvisdt_) FillVisibTable(moyfc_, moytt_);
401 numfile_++;
402 }
403 vismtx_ = complex<r_4>((r_4)0.,(r_4)0.);
404 moyfc_=moytt_=0.;
405 first_fc_=curfc_[0];
406 first_tt_= (vpaq_[0].TimeTag()-ttfirst_[0]);
407 // first_tmstamp_.SetNow(); // Current date and time
408 first_tmstamp_=cts_; // Current date and time
409 }
410
411// kpair=numero sequentiel de la paire: 0->(0,0), 1->(0,1), 2->(0,2), 3->(0,3), 4->(1,1), 5->(1,2) ...
412 sa_size_t kpair=0;
413 sa_size_t k=0; // numero de ligne dans la matrice des visibilites
414 for(size_t i=0; i<vpdata_.size(); i++) {
415 for(size_t j=i; j<vpdata_.size(); j++) {
416 kpair++;
417 if (kpair<(pairst_+1)) continue;
418 if (kpair>=(pairst_+nbpairs_+1)) break;
419 if (fgpimp_&&(i!=j)&&((i+j)%2==0)) continue; // calcul des visib avec numero pair-impair + autocorrel
420 TVector< complex<r_4> > vis = vismtx_.Row(k); k++;
421 for(sa_size_t f=1; f<vis.Size(); f++) {
422 vis(f) += complex<r_4>((r_4)vpdata_[i][f].realB(), (r_4)vpdata_[i][f].imagB()) *
423 complex<r_4>((r_4)vpdata_[j][f].realB(), -(r_4)vpdata_[j][f].imagB());
424 }
425 nb_flop_ += (8.*(r_8)(vis.Size()-1));
426 }
427 }
428
429 moyfc_ += curfc_[0];
430 moytt_ += (vpaq_[0].TimeTag()-ttfirst_[0]);
431 if ((fgcktt_)&&(calcid_==0)) CheckTimeTag();
432 totnbpaq_++;
433 return 0;
434}
435
436/* --Methode-- */
437void BRVisibilityCalculator::UpdateVisMtxInfo()
438{
439 string ikey,ikdesc;
440 ikey="DATEOBS"; ikdesc=" Date/Time corresponding to TimeTagFirst";
441 vismtx_.Info().SetS(ikey,first_tmstamp_.ToString());
442 vismtx_.Info().SetComment(ikey,ikdesc);
443 ikey="FirstFC"; ikdesc="First FrameCounter";
444 vismtx_.Info().SetI(ikey,first_fc_);
445 vismtx_.Info().SetComment(ikey,ikdesc);
446 ikey="FirstTT"; ikdesc="First TimeTag";
447 vismtx_.Info().SetI(ikey,first_tt_);
448 vismtx_.Info().SetComment(ikey,ikdesc);
449 ikey="LastFC"; ikdesc="Last FrameCounter";
450 vismtx_.Info().SetI(ikey,curfc_[0]);
451 vismtx_.Info().SetComment(ikey,ikdesc);
452 ikey="LastTT"; ikdesc="Last TimeTag";
453 vismtx_.Info().SetI(ikey,vpaq_[0].TimeTag()-ttfirst_[0]);
454 vismtx_.Info().SetComment(ikey,ikdesc);
455 ikey="MeanFC"; ikdesc="Mean FrameCounter";
456 vismtx_.Info().SetD(ikey,moyfc_);
457 vismtx_.Info().SetComment(ikey,ikdesc);
458 ikey="MeanTT"; ikdesc="Mean TimeTag";
459 vismtx_.Info().SetD(ikey,moytt_);
460 vismtx_.Info().SetComment(ikey,ikdesc);
461 ikey="NPAQSUM"; ikdesc="Number of paquets summed";
462 vismtx_.Info().SetI(ikey,nmean_);
463}
464
465
466/* --Methode-- */
467int BRVisibilityCalculator::execute(int tid)
468{
469 vector<TwoByteComplex*> pvpdata(2*memgr_.NbFibres());
470 size_t paqsz=memgr_.PaqSize();
471 BRPaquet ppaq(paqsz);
472
473
474 sa_size_t fdelt = vismtx_.NCols()/nparthr_;
475 sa_size_t fdeb = tid*fdelt;
476 sa_size_t ffin = (tid+1)*fdelt;
477
478 if (fdeb<1) fdeb=1;
479 if ((ffin>vismtx_.NCols())||(tid==(nparthr_-1))) ffin=vismtx_.NCols();
480
481 for(size_t jp=0; jp<memgr_.NbPaquets(); jp++) { // boucle sur les paquets d'une zone
482 if (!fgallfibok[jp]) continue;
483 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
484 ppaq.Set(fbuff_[fib]+jp*paqsz);
485 pvpdata[2*fib] = ppaq.Data1C();
486 pvpdata[2*fib+1] = ppaq.Data2C();
487 }
488
489
490// kpair=numero sequentiel de la paire: 0->(0,0), 1->(0,1), 2->(0,2), 3->(0,3), 4->(1,1), 5->(1,2) ...
491 sa_size_t kpair=0;
492 sa_size_t k=0; // numero de ligne dans la matrice des visibilites
493 for(size_t i=0; i<vpdata_.size(); i++) {
494 for(size_t j=i; j<vpdata_.size(); j++) {
495 kpair++;
496 if (kpair<(pairst_+1)) continue;
497 if (kpair>=(pairst_+nbpairs_+1)) break;
498 if (fgpimp_&&(i!=j)&&((i+j)%2==0)) continue; // calcul des visib avec numero pair-impair + autocorrel
499 TVector< complex<r_4> > vis = vismtx_.Row(k); k++;
500 for(sa_size_t f=fdeb; f<ffin; f++) {
501 vis(f) += complex<r_4>((r_4)pvpdata[i][f].realB(), (r_4)pvpdata[i][f].imagB()) *
502 complex<r_4>((r_4)pvpdata[j][f].realB(), -(r_4)pvpdata[j][f].imagB());
503 }
504 nb_flop_ += (8.*(r_8)(ffin-fdeb));
505 }
506 }
507
508 } // Fin de boucle sur les paquets
509
510 return 0;
511}
512
513/* --Methode-- */
514int BRVisibilityCalculator::FillVisibTable(double fcm, double ttm)
515{
516 double xnt[10];
517 xnt[0]=fcm; xnt[1]=ttm/1.25e8;
518
519 if (djf_<2) {
520 for(sa_size_t rv=0; rv<vismtx_.NRows(); rv++) {
521 for(sa_size_t jf=jf1_; jf<jf2_; jf++) {
522 xnt[2]=jf;
523 xnt[3]=chanpairnumall_(rv+pairst_);
524 xnt[4]=vismtx_(rv,jf).real()/(r_4)(nmean_);
525 xnt[5]=vismtx_(rv,jf).imag()/(r_4)(nmean_);
526 visdt_.AddRow(xnt);
527 }
528 }
529 }
530 else {
531 for(sa_size_t rv=0; rv<vismtx_.NRows(); rv++) {
532 for(sa_size_t jf=jf1_; jf<jf2_; jf+=djf_) {
533 r_4 moyreal=0.;
534 r_4 moyimag=0.;
535 sa_size_t jjfmx=jf+djf_;
536 if (jjfmx > vismtx_.NCols()) jjfmx=vismtx_.NCols();
537 for(sa_size_t jjf=jf; jjf<jjfmx; jjf++) {
538 moyreal+=vismtx_(rv,jjf).real();
539 moyimag+=vismtx_(rv,jjf).imag();
540 }
541 xnt[2]=jf+djf_/2;
542 xnt[3]=chanpairnumall_(rv+pairst_);
543 xnt[4]=moyreal/(r_4)(nmean_*djf_);
544 xnt[5]=moyimag/(r_4)(nmean_*djf_);
545 visdt_.AddRow(xnt);
546 }
547 }
548 }
549 return 0;
550}
551
552/* --Methode-- */
553int BRVisibilityCalculator::CheckTimeTag()
554{
555 if (totnbpaq_==0) {
556 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
557 vlasttt_[fib]=ttfirst_[fib];
558 if (ttmtx_.NCols()>0) {
559 fcmtx_(fib,totnbpaq_) = curfc_[fib];
560 ttmtx_(fib,totnbpaq_) = vlasttt_[fib];
561 }
562 }
563 return 0;
564 }
565 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
566 int_8 ld = (int_8)vpaq_[fib].TimeTag()-(int_8)vlasttt_[fib];
567 int_8 fd = (int_8)vpaq_[fib].TimeTag()-(int_8)ttfirst_[fib]-(int_8)vpaq_[0].TimeTag()+(int_8)ttfirst_[0];
568 /* if ( (ld < mindeltatt_) || (fd<-5) || (fd>5)) { vbadtt_[fib]++; vnsamett_[fib]++; }
569 else {
570 if (fd!=0) vnsamett_[fib]++;
571 }
572 */
573 if (ld < mindeltatt_) vbadtt_[fib]++;
574 else {
575 if (fd != 0) vnsamett_[fib]++;
576 if ((fd<-5)||(fd>5)) vndiff5tt_[fib]++;
577 }
578 vlasttt_[fib]=vpaq_[fib].TimeTag();
579 if (totnbpaq_<ttmtx_.NCols()) {
580 fcmtx_(fib,totnbpaq_) = curfc_[fib];
581 ttmtx_(fib,totnbpaq_) = vlasttt_[fib];
582 }
583 }
584 return 0;
585}
586
587//-------------------------------------------------------------------------------
588// Classe Groupe (ensemble) de Calculateur de Visibilites, tournant en parallele
589//-------------------------------------------------------------------------------
590
591/* --Methode-- */
592BRVisCalcGroup::BRVisCalcGroup(size_t nbcalc, RAcqMemZoneMgr& memgr, string outpath, uint_4 nmean,
593 uint_4 pair1, uint_4 nbpairs, bool fgpimp, size_t nthr)
594 : tm_(false)
595{
596 if ((nbcalc<1)||(nbcalc>6))
597 throw ParmError("BRVisCalcGroup::BRVisCalcGroup NbCalc > 6 !");
598 for(size_t i=0; i<nbcalc; i++) {
599 BRVisibilityCalculator * viscp=new BRVisibilityCalculator(memgr, outpath, nmean, nthr);
600 viscp->DefineRank(nbcalc, i, pair1, nbpairs, fgpimp);
601 viscalcp_.push_back(viscp);
602 }
603}
604/* --Methode-- */
605BRVisCalcGroup::~BRVisCalcGroup()
606{
607 for(size_t i=0; i<viscalcp_.size(); i++)
608 delete viscalcp_[i];
609}
610/* --Methode-- */
611int BRVisCalcGroup::SelectFreqBinning(uint_4 freq1, uint_4 freq2, uint_4 nbfreq)
612{
613 int rc=0;
614 for(size_t i=0; i<viscalcp_.size(); i++)
615 rc=viscalcp_[i]->SelectFreqBinning(freq1, freq2, nbfreq);
616 return rc;
617}
618/* --Methode-- */
619void BRVisCalcGroup::ActivateVisDTable(bool fgfdt)
620{
621 for(size_t i=0; i<viscalcp_.size(); i++)
622 viscalcp_[i]->ActivateVisDTable(fgfdt);
623}
624/* --Methode-- */
625void BRVisCalcGroup::SetPrintLevel(int lev, uint_8 prtmodulo)
626{
627 for(size_t i=0; i<viscalcp_.size(); i++)
628 viscalcp_[i]->SetPrintLevel(lev,prtmodulo);
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.