General Purpose Geodetic Library
SgVlbiBaselineInfo.cpp
Go to the documentation of this file.
1 /*
2  *
3  * This file is a part of Space Geodetic Library. The library is used by
4  * nuSolve, a part of CALC/SOLVE system, and designed to make analysis of
5  * geodetic VLBI observations.
6  * Copyright (C) 2010-2020 Sergei Bolotin.
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program. If not, see <http://www.gnu.org/licenses/>.
20  *
21  */
22 
23 #include <iostream>
24 #include <stdlib.h>
25 
26 
27 #include <QtCore/QDataStream>
28 
29 
30 #include <SgVlbiBaselineInfo.h>
31 #include <SgVlbiObservation.h>
32 #include <SgVlbiObservable.h>
33 
34 #include <SgLogger.h>
35 
36 
37 
38 /*=======================================================================================================
39 *
40 * METHODS:
41 *
42 *======================================================================================================*/
43 //
44 // static first:
46 {
47  return "SgVlbiBaselineInfo";
48 };
49 
50 
51 
52 //
54 {
55  QString prefix = "Bln: " + getKey() + ": ";
57  pClock_ = new SgParameter(prefix + "Clock_0");
58  pBx_ = new SgParameter(prefix + "coord-X");
59  pBy_ = new SgParameter(prefix + "coord-Y");
60  pBz_ = new SgParameter(prefix + "coord-Z");
61  dClock_ = 0.0;
62  dClockSigma_ = 0.0;
63 };
64 
65 
66 
67 //
69 {
70  if (pClock_)
71  {
73  {
76  };
77  delete pClock_;
78  pClock_ = NULL;
79  };
80  if (pBx_)
81  {
82  delete pBx_;
83  pBx_ = NULL;
84  };
85  if (pBy_)
86  {
87  delete pBy_;
88  pBy_ = NULL;
89  };
90  if (pBz_)
91  {
92  delete pBz_;
93  pBz_ = NULL;
94  };
95 };
96 
97 
98 
99 //
101 {
102  bool isOk=true;
103  int num=0, count=0;
104  numOfChanByCount_.clear();
105  grdAmbigsBySpacing_.clear();
106  phdAmbigsBySpacing_.clear();
107  //
108  // set up "typical" group delay ambiguity spacing for the band:
109  for (int i=0; i<observables_.size(); i++)
110  {
111  grdAmbigsBySpacing_[observables_.at(i)->grDelay().getAmbiguitySpacing()]++;
112  phdAmbigsBySpacing_[observables_.at(i)->phDelay().getAmbiguitySpacing()]++;
113  numOfChanByCount_[observables_.at(i)->getNumOfChannels()]++;
114  };
115  // group delay:
116  if (grdAmbigsBySpacing_.size() == 1)
117  {
119  strGrdAmbigsStat_.sprintf("%.1f", typicalGrdAmbigSpacing_*1.0e9);
120  }
121  else
122  {
123  strGrdAmbigsStat_ = "";
124  num = observables_.size();
125  count = 0;
126  for (QMap<double, int>::iterator it=grdAmbigsBySpacing_.begin(); it!=grdAmbigsBySpacing_.end(); ++it)
127  {
128  strGrdAmbigsStat_ += QString("").sprintf("%.1f (%.1f%%), ", it.key()*1.0e9, it.value()*100.0/num);
129  if (count < it.value())
130  {
131  count = it.value();
132  typicalGrdAmbigSpacing_ = it.key();
133  };
134  };
136  };
137  // phase dleay:
138  if (phdAmbigsBySpacing_.size() == 1)
139  {
141  strPhdAmbigsStat_.sprintf("%.3f", typicalPhdAmbigSpacing_*1.0e9);
142  }
143  else
144  {
145  strPhdAmbigsStat_ = "";
146  num = observables_.size();
147  count = 0;
148  for (QMap<double, int>::iterator it=phdAmbigsBySpacing_.begin(); it!=phdAmbigsBySpacing_.end(); ++it)
149  {
150  strPhdAmbigsStat_ += QString("").sprintf("%.3f (%.1f%%), ", it.key()*1.0e9, it.value()*100.0/num);
151  if (count < it.value())
152  {
153  count = it.value();
154  typicalPhdAmbigSpacing_ = it.key();
155  };
156  };
158  };
159  //
160  // num of channels:
161  if (numOfChanByCount_.size() == 1)
162  typicalNumOfCannels_ = numOfChanByCount_.begin().key();
163  else
164  {
165  count = 0;
166  for (QMap<int, int>::iterator it=numOfChanByCount_.begin(); it!=numOfChanByCount_.end(); ++it)
167  if (count < it.value())
168  {
169  count = it.value();
170  typicalNumOfCannels_ = it.key();
171  };
172  };
173  //
174  return isOk;
175 };
176 
177 
178 
179 //
181 {
182  const int M0=4;
183  const double dS=0.2E-9; // 0.2ns
184  QList<SgVlbiObservable*> obsList;
185  SgVlbiObservable *obs=NULL;
186 
187  // first, clear the flag, then, pick up processed observations:
188  for (int i=0; i<observables_.size(); i++)
189  {
190  SgVlbiObservable *obs = observables_.at(i);
193  obsList.append(obs);
194  };
195 
196  if (obsList.size()<2*M0)
197  return;
198 
199 
200  double x, y, w;
201  double A_l, B_l, C_l, P_l, Q_l, R_l;
202  double a_l, b_l, wrms_l;
203  double A_r, B_r, C_r, P_r, Q_r, R_r;
204  double a_r, b_r, wrms_r;
205  x = y = w = 0.0;
206  A_l = B_l = C_l = P_l = Q_l = R_l = 0.0;
207  a_l = b_l = wrms_l = 0.0;
208  A_r = B_r = C_r = P_r = Q_r = R_r = 0.0;
209  a_r = b_r = wrms_r = 0.0;
210 
211  // calc whole wrms residuals:
212  for (int i=0; i<obsList.size(); i++)
213  {
214  obs = obsList.at(i);
215  x = obs->epoch().toDouble();
216  y = obs->activeDelay()->getResidual();
217  w = 1.0/(fabs(obs->activeDelay()->getSigma()) + dS)/
218  (fabs(obs->activeDelay()->getSigma()) + dS);
219  A_l += w;
220  B_l += w*x;
221  C_l += w*x*x;
222  P_l += w*y;
223  Q_l += w*x*y;
224  R_l += w*y*y;
225  };
226  b_l = (P_l*B_l - A_l*Q_l)/(B_l*B_l - A_l*C_l);
227  a_l = (Q_l - C_l*b_l)/B_l;
228  cbd_total_wrms_ = sqrt(fabs((R_l + a_l*a_l*A_l + b_l*b_l*C_l +
229  2.0*(a_l*b_l*B_l - a_l*P_l - b_l*Q_l))/A_l));
230 
231  A_l = B_l = C_l = P_l = Q_l = R_l = 0.0;
232  a_l = b_l = 0.0;
233  // initial evaluating:
234  for (int i=0; i<M0; i++)
235  {
236  obs = obsList.at(i);
237  x = obs->epoch().toDouble();
238  y = obs->activeDelay()->getResidual();
239  w = 1.0/(fabs(obs->activeDelay()->getSigma()) + dS)/
240  (fabs(obs->activeDelay()->getSigma()) + dS);
241  A_l += w;
242  B_l += w*x;
243  C_l += w*x*x;
244  P_l += w*y;
245  Q_l += w*x*y;
246  R_l += w*y*y;
247  };
248  for (int i=M0; i<obsList.size(); i++)
249  {
250  obs = obsList.at(i);
251  x = obs->epoch().toDouble();
252  y = obs->activeDelay()->getResidual();
253  w = 1.0/(fabs(obs->activeDelay()->getSigma()) + dS)/
254  (fabs(obs->activeDelay()->getSigma()) + dS);
255  A_r += w;
256  B_r += w*x;
257  C_r += w*x*x;
258  P_r += w*y;
259  Q_r += w*x*y;
260  R_r += w*y*y;
261  };
262  b_l = (P_l*B_l - A_l*Q_l)/(B_l*B_l - A_l*C_l);
263  a_l = (Q_l - C_l*b_l)/B_l;
264  wrms_l = (R_l + a_l*a_l*A_l + b_l*b_l*C_l + 2.0*(a_l*b_l*B_l - a_l*P_l - b_l*Q_l))/A_l;
265  b_r = (P_r*B_r - A_r*Q_r)/(B_r*B_r - A_r*C_r);
266  a_r = (Q_r - C_r*b_r)/B_r;
267  wrms_r = (R_r + a_r*a_r*A_r + b_r*b_r*C_r + 2.0*(a_r*b_r*B_r - a_r*P_r - b_r*Q_r))/A_r;
268 // obsList.at(M0-1)->setBaselineClock_F1 ((sqrt(fabs(wrms_l)) + sqrt(fabs(wrms_r)))/cbd_total_wrms_);
269  obsList.at(M0-1)->owner()->setBaselineClock_F1 (sqrt(fabs(wrms_l)) + sqrt(fabs(wrms_r)));
270  obsList.at(M0-1)->owner()->setBaselineClock_F1l(sqrt(fabs(wrms_l)));
271  obsList.at(M0-1)->owner()->setBaselineClock_F1r(sqrt(fabs(wrms_r)));
272 // obsList.at(M0-1)->setBaselineClock_F1(sqrt(fabs(wrms_l + wrms_r)));
273  obsList.at(M0-1)->owner()->addAttr(SgVlbiObservation::Attr_PASSED_CL_FN1);
274 
275  for (int i=M0; i<obsList.size()-M0+1; i++)
276  {
277  obs = obsList.at(i);
278  x = obs->epoch().toDouble();
279  y = obs->activeDelay()->getResidual();
280  w = 1.0/(fabs(obs->activeDelay()->getSigma()) + dS)/
281  (fabs(obs->activeDelay()->getSigma()) + dS);
282 
283  A_l += w;
284  B_l += w*x;
285  C_l += w*x*x;
286  P_l += w*y;
287  Q_l += w*x*y;
288  R_l += w*y*y;
289 
290  A_r -= w;
291  B_r -= w*x;
292  C_r -= w*x*x;
293  P_r -= w*y;
294  Q_r -= w*x*y;
295  R_r -= w*y*y;
296 
297  b_l = (P_l*B_l - A_l*Q_l)/(B_l*B_l - A_l*C_l);
298  a_l = (Q_l - C_l*b_l)/B_l;
299  wrms_l = (R_l + a_l*a_l*A_l + b_l*b_l*C_l + 2.0*(a_l*b_l*B_l - a_l*P_l - b_l*Q_l))/A_l;
300  b_r = (P_r*B_r - A_r*Q_r)/(B_r*B_r - A_r*C_r);
301  a_r = (Q_r - C_r*b_r)/B_r;
302  wrms_r = (R_r + a_r*a_r*A_r + b_r*b_r*C_r + 2.0*(a_r*b_r*B_r - a_r*P_r - b_r*Q_r))/A_r;
303 // obsList.at(i)->setBaselineClock_F1 ((sqrt(fabs(wrms_l)) + sqrt(fabs(wrms_r)))/cbd_total_wrms_);
304 // obsList.at(i)->setBaselineClock_F1 (sqrt(fabs(wrms_l)) + sqrt(fabs(wrms_r)));
305  obs->owner()->setBaselineClock_F1(sqrt(fabs(wrms_l + wrms_r)));
306  obs->owner()->setBaselineClock_F1l(sqrt(fabs(wrms_l)));
307  obs->owner()->setBaselineClock_F1r(sqrt(fabs(wrms_r)));
309  };
310 
311  obsList.clear();
312 };
313 
314 
315 
316 //
318 {
319  QList<SgVlbiObservable*> obsList;
320  SgVlbiObservable *obs=NULL;
321 
322  if (!cbIndicator_)
325 
326  // first, clear the flag, then, pick up processed observations:
327  for (int i=0; i<observables_.size(); i++)
328  {
329  obs = observables_.at(i);
332  obsList.append(obs);
333  };
334  if (obsList.size()<4)
335  {
336  delete cbIndicator_;
337  cbIndicator_ = NULL;
338  return;
339  };
340  //
341  double minWrms, maxWrms;
342  int minIdx = -1;
343  minWrms = maxWrms = obsList.at(0)->owner()->getBaselineClock_F1();
344  for (int i=0; i<obsList.size(); i++)
345  {
346  obs = obsList.at(i);
347  if (minWrms > obs->owner()->getBaselineClock_F1())
348  {
349  minWrms = obs->owner()->getBaselineClock_F1();
350  minIdx = i;
351  };
352  if (maxWrms < obs->owner()->getBaselineClock_F1())
353  maxWrms = obs->owner()->getBaselineClock_F1();
354  };
355  if (maxWrms==minWrms)
356  {
357  delete cbIndicator_;
358  cbIndicator_ = NULL;
359  return;
360  };
361  if (minIdx==-1)
362  {
363  delete cbIndicator_;
364  cbIndicator_ = NULL;
365  return;
366  };
367  if (minIdx<2)
368  {
369  delete cbIndicator_;
370  cbIndicator_ = NULL;
371  return;
372  };
373  if (minIdx>obsList.size()-3)
374  {
375  delete cbIndicator_;
376  cbIndicator_ = NULL;
377  return;
378  };
379  //
380  // ok:
381  cbIndicator_->epoch_ = obsList.at(minIdx)->epoch();
382  cbIndicator_->minWrms_ = minWrms;
383  int i, n;
384  // right wing:
385  n = 0;
386  i = minIdx + 1;
387  while (i<obsList.size() &&
388  obsList.at(i-1)->owner()->getBaselineClock_F1()<=obsList.at(i)->owner()->getBaselineClock_F1())
389  {
390  n++;
391  i++;
392  };
394  cbIndicator_->tOnRight_ = obsList.at(minIdx+n)->epoch();
395  // left wing:
396  n = 0;
397  i = minIdx - 1;
398  while (i>0 &&
399  obsList.at(i)->owner()->getBaselineClock_F1()<=obsList.at(i-1)->owner()->getBaselineClock_F1())
400  {
401  n++;
402  i--;
403  };
405  cbIndicator_->tOnLeft_ = obsList.at(minIdx-n)->epoch();
406  obsList.clear();
407 };
408 
409 
410 
411 //
413 {
415 // scan4Ambiguities_m2();
416 };
417 
418 
419 
420 //
422 {
424  SgVlbiObservable *o=NULL;
425 
426  // first, clear the flag, then, pick up processed observations:
427  for (int i=0; i<observables_.size(); i++)
428  {
429  o = observables_.at(i);
431  oList.append(o);
432  };
433  if (!oList.size())
434  {
436  ": scan4Ambiguities(): the number of processed observations at the baseline [" +
437  getKey() + "] is zero; skipping");
438  oList.clear();
439  return;
440  };
441  //
442  int num=oList.size(), numUp=0, numDn=0;
443  for (int i=0; i<num; i++)
444  {
445  o = oList.at(i);
447  if (o->activeDelay()->getResidual() > 0.0)
448  numUp++;
449  if (o->activeDelay()->getResidual() < 0.0)
450  numDn++;
451  };
452  bool isUp=numUp>numDn;
453  int n=std::max(numUp, numDn);
454  if (n<4)
455  {
457  ": scan4Ambiguities(): the number of observations in the good stratum at the baseline [" +
458  getKey() + "] less than 4; applying simple correction");
459  for (int i=0; i<oList.size()-1; i++)
460  {
461  double closestResidual=oList.at(i)->activeDelay()->getResidual();
462  o = oList.at(i+1);
463  o->activeDelay()->adjustAmbiguity(closestResidual);
464  };
465  oList.clear();
466  return;
467  };
468  SgVector x(n), y(n), e(n);
469  SgMJD t0 = (*oList.at(oList.size()-1)->owner() - *oList.at(0)->owner())/2.0;
470  int j=0;
471  for (int i=0; i<num; i++)
472  {
473  o = oList.at(i);
474  if ((isUp && o->activeDelay()->getResidual()>0.0) ||
475  (!isUp && o->activeDelay()->getResidual()<0.0) )
476  {
477  x(j) = *o->owner() - t0;
478  y(j) = o->activeDelay()->getResidual();
479  e(j) = o->activeDelay()->getSigma() + 10.0E-12;
480  j++;
481  };
482  };
483  // determine mean shift:
484  double sA=0.0, sB=0.0, sC=0.0, closestResidual, d;
485  for (int i=0; i<n; i++)
486  {
487  sA += 1.0/e.getElement(i)/e.getElement(i);
488  sB += (d=y.getElement(i)/e.getElement(i))/e.getElement(i);
489  sC += d*d;
490  };
491  closestResidual = sB/sA;
492 
493  oList.clear();
494  // reprocess residuals:
495  //
496  for (int i=0; i<observables_.size(); i++)
497  {
498  o = observables_.at(i);
499  o->activeDelay()->adjustAmbiguity(closestResidual);
500  };
501 };
502 
503 
504 
505 //
507 {
508  QList<SgVlbiObservable*> obsList;
509  SgVlbiObservable *o=NULL;
510 
511  // first, clear the flag, then, pick up processed observations:
512  for (int i=0; i<observables_.size(); i++)
513  {
514  o = observables_.at(i);
516  obsList.append(o);
517  };
518  if (!obsList.size())
519  {
521  ": scan4Ambiguities(): the number of processed observations at the baseline [" +
522  getKey() + "] is zero; skipping");
523  obsList.clear();
524  return;
525  };
526  //
527  int nAvg=5;
528  double closestResidual;
529  if (obsList.size() <= nAvg)
530  {
531  obsList.at(0)->activeDelay()->adjustAmbiguity();
532  closestResidual = obsList.at(0)->activeDelay()->getResidual();
533  for (int i=0; i<obsList.size()-1; i++)
534  {
535  obsList.at(i+1)->activeDelay()->adjustAmbiguity(closestResidual);
536  closestResidual = obsList.at(i+1)->activeDelay()->getResidual();
537  };
538  }
539  else
540  {
541  closestResidual = 0.0;
542  for (int i=0; i<nAvg; i++)
543  closestResidual += obsList.at(i)->activeDelay()->getResidual();
544  closestResidual /= nAvg;
545  for (int i=0; i<nAvg; i++)
546  obsList.at(i)->activeDelay()->adjustAmbiguity(closestResidual);
547  for (int i=nAvg; i<obsList.size(); i++)
548  {
549  closestResidual = 0.0;
550  for (int j=0; j<nAvg; j++)
551  closestResidual += obsList.at(i + j - nAvg)->activeDelay()->getResidual();
552  closestResidual /= nAvg;
553 
554  obsList.at(i)->activeDelay()->adjustAmbiguity(closestResidual);
555  };
556  };
557  return;
558 
559 
560 
561  int crIdx=0;
562  closestResidual = fabs(obsList.at(crIdx)->activeDelay()->getResidual());
563  for (int i=0; i<obsList.size(); i++)
564  {
565  o = obsList.at(i);
566  if (fabs(o->activeDelay()->getResidual()) < closestResidual)
567  {
568  closestResidual = fabs(o->activeDelay()->getResidual());
569  crIdx = i;
570  };
571  };
572  closestResidual = obsList.at(crIdx)->activeDelay()->getResidual();
573  // adjust the closest residual:
574  obsList.at(crIdx)->activeDelay()->adjustAmbiguity(closestResidual);
575  closestResidual = obsList.at(crIdx)->activeDelay()->getResidual();
576  // process other residuals:
577  for (int i=crIdx; i>0; i--)
578  {
579  closestResidual = obsList.at(i)->activeDelay()->getResidual();
580  obsList.at(i-1)->activeDelay()->adjustAmbiguity(closestResidual);
581  };
582  for (int i=crIdx; i<obsList.size()-1; i++)
583  {
584  closestResidual = obsList.at(i)->activeDelay()->getResidual();
585  o = obsList.at(i + 1);
586  obsList.at(i+1)->activeDelay()->adjustAmbiguity(closestResidual);
587  };
588  obsList.clear();
589 };
590 
591 
592 
593 //
595 {
597  SgVlbiObservable *o=NULL;
598  //
599  // first, clear the flag, then, pick up processed observations:
600  for (int i=0; i<observables_.size(); i++)
601  {
602  o = observables_.at(i);
604  oList.append(o);
605  };
606  if (oList.size() == 0)
607  {
609  ": evaluateMeanGrDelResiduals(): the number of processed observations at the baseline [" +
610  getKey() + "] is zero; skipping");
611  oList.clear();
612  return;
613  };
614  //
615  double sA=0.0, sB=0.0, sC=0.0;
616  double y, w;
617  for (int i=0; i<oList.size(); i++)
618  {
619  o = oList.at(i);
620  y = o->activeDelay()->getResidual();
621  w = o->activeDelay()->getSigma() + 5.0E-12;
622  w = 1.0/w/w;
623  sA += w;
624  sB += w*y;
625  sC += w*y*y;
626  };
627  meanGrDelResiduals_ = sB/sA;
628  meanGrDelResidualsSigma_= (sC - sB)/sA;
629  //
630  oList.clear();
631 };
632 
633 
634 
635 //
637 {
638  if (deltaN==0 || observables_.size()==0)
639  return; // nothing to do
640 
642  double ambigSpacing=typicalGrdAmbigSpacing_, shift;
644  ambigSpacing = typicalPhdAmbigSpacing_;
645  shift = deltaN*ambigSpacing;
646  int n;
647  for (int i=0; i<observables_.size(); i++)
648  {
649  o = observables_.at(i);
650  n = rint(shift/o->activeDelay()->getAmbiguitySpacing());
652  n*o->activeDelay()->getAmbiguitySpacing());
654  };
655 };
656 
657 
658 
659 //
660 SgVlbiStationInfo* SgVlbiBaselineInfo::stn_1(QMap<QString, SgVlbiStationInfo*> stations) const
661 {
662  SgVlbiStationInfo *stn=NULL;
663  QString name(getKey().left(8));
664  if (stations.contains(name))
665  stn = stations.value(name);
666  return stn;
667 };
668 
669 
670 
671 //
672 SgVlbiStationInfo* SgVlbiBaselineInfo::stn_2(QMap<QString, SgVlbiStationInfo*> stations) const
673 {
674  SgVlbiStationInfo *stn=NULL;
675  QString name(getKey().right(8));
676  if (stations.contains(name))
677  stn = stations.value(name);
678  return stn;
679 };
680 
681 
682 
683 //
685 {
687  SgVlbiObservable *o=NULL;
688 
689  // first, clear the flag, then, pick up processed observations:
690  for (int i=0; i<observables_.size(); i++)
691  {
692  o = observables_.at(i);
694  oList.append(o);
695  };
696  if (!oList.size())
697  {
699  ": setAmbiguities2min(): the number of processed observations at the baseline [" +
700  getKey() + "] is zero; skipping");
701  oList.clear();
702  return;
703  };
704  //
705  int num=oList.size(), meanAmbig;
706  double sum=0.0;
707  for (int i=0; i<num; i++)
708  sum += oList.at(i)->activeDelay()->getNumOfAmbiguities();
709  meanAmbig = round(sum/num);
710  if (meanAmbig != 0)
711  for (int i=0; i<observables_.size(); i++)
712  {
713  o = observables_.at(i);
715  - meanAmbig);
716  };
717 };
718 
719 
720 
721 //
723 {
725  //
726  s << dClock_ << dClockSigma_;
727  //
728  if (s.status() != QDataStream::Ok)
729  {
731  ": saveIntermediateResults(): error writting data");
732  return false;
733  };
734  return s.status() == QDataStream::Ok;
735 };
736 
737 
738 
739 //
741 {
742  double dClock, dClockSigma;
743  //
745  //
746  s >> dClock >> dClockSigma;
747  //
748  if (s.status() != QDataStream::Ok)
749  {
751  ": loadIntermediateResults(): error reading data: " +
752  (s.status()==QDataStream::ReadPastEnd?"read past end of the file":"read corrupt data"));
753  return false;
754  };
755  dClock_ = dClock;
757  //
758  return s.status()==QDataStream::Ok;
759 };
760 /*=====================================================================================================*/
761 
762 
763 
764 
765 /*=====================================================================================================*/
766 //
767 // FRIENDS:
768 //
769 /*=====================================================================================================*/
770 //
771 
772 /*=====================================================================================================*/
773 //
774 // aux functions:
775 //
776 
777 /*=====================================================================================================*/
778 //
779 // constants:
780 //
781 
782 /*=====================================================================================================*/
SgLogger * logger
Definition: SgLogger.cpp:231
bool isAttr(uint a) const
Definition: SgAttribute.h:226
void delAttr(uint a)
Definition: SgAttribute.h:210
void addAttr(uint a)
Definition: SgAttribute.h:202
virtual void write(LogLevel, quint32, const QString &, bool=false)
Definition: SgLogger.cpp:88
@ IO_BIN
Definition: SgLogger.h:64
Definition: SgMJD.h:59
double toDouble() const
Definition: SgMJD.h:533
bool loadIntermediateResults(QDataStream &)
const QString & getKey() const
Definition: SgObjectInfo.h:319
bool saveIntermediateResults(QDataStream &) const
@ Attr_PROCESSED
the observation has been processed;
Definition: SgObservation.h:79
double getSolution() const
Definition: SgParameter.h:435
double getSigma() const
Definition: SgParameter.h:443
@ Attr_IS_IN_RUN
Definition: SgPartial.h:52
double getElement(unsigned int i) const
Definition: SgVector.h:362
SgVlbiStationInfo * stn_2(QMap< QString, SgVlbiStationInfo * >) const
QList< SgVlbiObservable * > observables_
QMap< int, int > numOfChanByCount_
QMap< double, int > grdAmbigsBySpacing_
SgVlbiStationInfo * stn_1(QMap< QString, SgVlbiStationInfo * >) const
SgClockBreakIndicator * cbIndicator_
double dClockSigma() const
bool loadIntermediateResults(QDataStream &)
void calculateClockF1(SgTaskConfig *)
static const QString className()
bool saveIntermediateResults(QDataStream &) const
QMap< double, int > phdAmbigsBySpacing_
void shiftAmbiguities(int deltaN)
double getAmbiguitySpacing() const
void setResidual(double)
void adjustAmbiguity(double closestResidual=0.0)
void setNumOfAmbiguities(int)
int getNumOfAmbiguities() const
double getSigma() const
SgTaskConfig::VlbiDelayType getDelayType() const
double getResidual() const
const SgMJD & epoch() const
SgVlbiObservation * owner()
SgVlbiMeasurement * activeDelay()
@ Attr_PASSED_CL_FN1
the observation participated in the procedure "calc clc fn#1"
void setBaselineClock_F1l(double f)
double getBaselineClock_F1() const
void setBaselineClock_F1(double f)
void setBaselineClock_F1r(double f)