General Purpose Geodetic Library
SgVlbiAuxObservation.h
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 #ifndef SG_VLBI_AUX_OBSERVATION_H
24 #define SG_VLBI_AUX_OBSERVATION_H
25 
26 
27 #ifdef HAVE_CONFIG_H
28 # include <config.h>
29 #endif
30 
31 
32 #include <math.h>
33 
34 #include <Sg3dVector.h>
35 #include <SgObservation.h>
36 #include <SgMeteoData.h>
37 #include <SgVector.h>
38 
39 
40 
41 
42 
43 class SgVlbiObservation;
44 /***===================================================================================================*/
52 {
53 public:
55  {
56 // Attr_NOT_VALID = 1<<0, //!< omit the observation;
57 // Attr_PROCESSED = 1<<1, //!< the observation has been processed;
58 // Attr_FORCE_2_PROCESS = 1<<2, //!< include the observation in data analysis in any condition;
61  };
62 
63 
64  // Statics:
65 
66  //
67  // constructors/destructors:
68  //
72  inline SgVlbiAuxObservation();
73 
74 
78  inline virtual ~SgVlbiAuxObservation();
79 
80 
81 
82  //
83  // Interfaces:
84  //
85 
86  // gets:
87  inline SgVlbiObservation* getOwner() const;
88 
91  inline short int getStationIdx() const;
92 
95  inline const SgMeteoData& getMeteoData() const;
96 
99  inline SgMeteoData& meteoData();
100 
103  inline double getCableCalibration() const;
104 
107  inline double getCableCalSign() const;
108 
111  inline double getAzimuthAngle() const;
112 
115  inline double getAzimuthAngleRate() const;
116 
119  inline double getElevationAngle() const;
120 
123  inline double getElevationAngleRate() const;
124 
127  inline double getParallacticAngle() const;
128 
131  inline double getAprioriClocks() const;
132 
135  inline double getEstClocks() const;
136 
139  inline double getEstClocksSigma() const;
140 
143  inline double getEstZenithDelay() const;
144 
147  inline double getEstZenithDelaySigma() const;
148 
151  inline double getEstAtmGradN() const;
152 
155  inline double getEstAtmGradNSigma() const;
156 
159  inline double getEstAtmGradE() const;
160 
163  inline double getEstAtmGradESigma() const;
164 
167  inline double getZenithDelayH() const;
168 
171  inline double getZenithDelayW() const;
172 
175  inline double getCalcNdryCont4Delay() const;
176  inline double getCalcNdryCont4Rate() const;
177 
180  inline double getCalcNwetCont4Delay() const;
181  inline double getCalcNwetCont4Rate() const;
182 
185  inline double getCalcUnPhaseCal() const;
186 
189  inline double getCalcAxisOffset4Delay() const;
190  inline double getCalcAxisOffset4Rate() const;
191 
194  inline double getCalcOLoadHorz4Delay() const;
195  inline double getCalcOLoadHorz4Rate() const;
196 
199  inline double getCalcOLoadVert4Delay() const;
200  inline double getCalcOLoadVert4Rate() const;
201 
204  inline double getDdel_dAxsOfs() const;
205 
208  inline double getDrat_dAxsOfs() const;
209 
210  inline double getDdel_dTzdDry() const {return dDel_dTzdDry_;}
211  inline double getDrat_dTzdDry() const {return dRat_dTzdDry_;}
212  inline double getDdel_dTzdWet() const {return dDel_dTzdWet_;}
213  inline double getDrat_dTzdWet() const {return dRat_dTzdWet_;}
214  inline double getDdel_dTzdGrdN() const {return dDel_dTzdGrdN_;}
215  inline double getDrat_dTzdGrdN() const {return dRat_dTzdGrdN_;}
216  inline double getDdel_dTzdGrdE() const {return dDel_dTzdGrdE_;}
217  inline double getDrat_dTzdGrdE() const {return dRat_dTzdGrdE_;}
218 
219  inline const Sg3dVector& getOcnLdR() const {return ocnLdR_;};
220  inline const Sg3dVector& getOcnLdV() const {return ocnLdV_;};
221 
222  inline double getRefClockOffset() const {return refClockOffset_;};
223 
224  inline double getSlantDelayH() const {return slantDelayH_;};
225  inline double getSlantRateH() const {return slantRateH_;};
226  inline double getSlantDelayW() const {return slantDelayW_;};
227  inline double getSlantRateW() const {return slantRateW_;};
228  inline double getPartDelayW() const {return partDelayW_;};
229  inline double getPartRateW() const {return partRateW_;};
230 
231  inline const SgVector* getTsyses() const {return tSyses_;};
232  inline double getTsys(unsigned int idx) const
233  {return (tSyses_ && idx<tSyses_->n())?tSyses_->getElement(idx):-10.0;};
234 
235  inline const QString& getTapeId() const {return tapeId_;};
236 
237 
238 
239  // sets:
240  //
241  inline void setOwner(SgVlbiObservation*);
242 
246  inline void setStationIdx(short int idx);
247 
251  inline void setMeteoData(const SgMeteoData& meteo);
252 
256  inline void setCableCalibration(double cable);
257 
261  inline void setCableCalSign(double s);
262 
266  inline void setAzimuthAngle(double angle);
267 
271  inline void setAzimuthAngleRate(double rate);
272 
276  inline void setElevationAngle(double angle);
277 
281  inline void setElevationAngleRate(double rate);
282 
286  inline void setParallacticAngle(double angle);
287 
291  inline void setAprioriClocks(double clocks);
292 
296  inline void setEstClocks(double d);
297 
301  inline void setEstClocksSigma(double e);
302 
306  inline void setEstZenithDelay(double d);
307 
311  inline void setEstZenithDelaySigma(double e);
312 
316  inline void setEstAtmGradN(double g);
317 
321  inline void setEstAtmGradNSigma(double s);
322 
326  inline void setEstAtmGradE(double g);
327 
331  inline void setEstAtmGradESigma(double s);
332 
336  inline void setZenithDelayH(double d);
337 
341  inline void setZenithDelayW(double d);
342 
346  inline void setCalcNdryCont4Delay(double v);
347  inline void setCalcNdryCont4Rate(double v);
348 
352  inline void setCalcNwetCont4Delay(double v);
353  inline void setCalcNwetCont4Rate(double v);
354 
358  inline void setCalcUnPhaseCal(double v);
359 
363  inline void setCalcAxisOffset4Delay(double v);
364  inline void setCalcAxisOffset4Rate(double v);
365 
368  inline void setCalcOLoadHorz4Delay(double v);
369  inline void setCalcOLoadHorz4Rate(double v);
370 
373  inline void setCalcOLoadVert4Delay(double v);
374  inline void setCalcOLoadVert4Rate(double v);
375 
379  inline void setDdel_dAxsOfs(double v);
380  inline void setDrat_dAxsOfs(double v);
381 
382  inline void setDdel_dTzdDry(double v) {dDel_dTzdDry_ = v;};
383  inline void setDrat_dTzdDry(double v) {dRat_dTzdDry_ = v;};
384  inline void setDdel_dTzdWet(double v) {dDel_dTzdWet_ = v;};
385  inline void setDrat_dTzdWet(double v) {dRat_dTzdWet_ = v;};
386 
387  inline void setDdel_dTzdGrdN(double v) {dDel_dTzdGrdN_ = v;};
388  inline void setDrat_dTzdGrdN(double v) {dRat_dTzdGrdN_ = v;};
389  inline void setDdel_dTzdGrdE(double v) {dDel_dTzdGrdE_ = v;};
390  inline void setDrat_dTzdGrdE(double v) {dRat_dTzdGrdE_ = v;};
391 
392  inline void setOcnLdR(const Sg3dVector& r) {ocnLdR_ = r;};
393  inline void setOcnLdV(const Sg3dVector& v) {ocnLdV_ = v;};
394 
395  inline void setRefClockOffset(double d) {refClockOffset_ = d;};
396 
397  inline void setSlantDelayH(double d) {slantDelayH_ = d;};
398  inline void setSlantRateH(double d) {slantRateH_ = d;};
399  inline void setSlantDelayW(double d) {slantDelayW_ = d;};
400  inline void setSlantRateW(double d) {slantRateW_ = d;};
401  inline void setPartDelayW(double d) {partDelayW_ = d;};
402  inline void setPartRateW(double d) {partRateW_ = d;};
403 
404  inline void setTsyses(const SgVector& ts);
405  inline SgVector* tSyses() {return tSyses_;};
406 
407  inline void setTapeId(const QString id) {tapeId_=id;};
408 
409 
410  //
411  // Functions:
412  //
415  virtual inline const QString className() const;
416 
419  virtual bool selfCheck();
420 
423  virtual bool isEligible(const SgTaskConfig*);
424 
427  virtual void prepare4Analysis(SgTaskManager*);
428 
432 
435  virtual void evaluateResiduals(SgTaskManager*, SgVlbiBand*, bool);
436 
439  virtual void evaluateResiduals(SgTaskManager*);
440 
443  virtual const SgVector& o_c();
444 
447  virtual const SgVector& sigma();
448 
451  inline void resetCable();
452 
455  inline void resetMeteo();
456 
459  inline void resetTsys();
460 
463  inline virtual bool operator==(const SgVlbiAuxObservation& auxObs) const;
464 
467  inline virtual bool operator!=(const SgVlbiAuxObservation& auxObs) const;
468 
469  inline void setTsysesSize(int n);
470 
471 
472  //
473  // Friends:
474  //
475 
476  //
477  // I/O:
478  //
479  // ...
480 
481 private:
483  short int stationIdx_;
492  double estClocks_;
496  double estAtmGradN_;
498  double estAtmGradE_;
502  // CALC's products: station dependent contributions:
516  // station dependent partials (mostly, form CALC):
527  // KOMB contribution:
529  //
530  double slantDelayH_;
531  double slantRateH_;
532  double slantDelayW_;
533  double slantRateW_;
534  double partDelayW_;
535  double partRateW_;
536 
537  //
538  // tsys:
540  //
541  QString tapeId_;
542 };
543 /*=====================================================================================================*/
544 
545 
546 
547 
548 
549 /*=====================================================================================================*/
550 /* */
551 /* SgObservation inline members: */
552 /* */
553 /*=====================================================================================================*/
554 //
555 //
556 // CONSTRUCTORS:
557 //
558 // An empty constructor:
560  SgObservation(), meteoData_(),
561  ocnLdR_(v3Zero),
562  ocnLdV_(v3Zero),
563  tapeId_("")
564 {
565  owner_ = NULL;
566  stationIdx_ = -1;
567  cableCalibration_ = 0.0;
568  azimuthAngle_ = -10.0; // unrealistic data
569  elevationAngle_ = -10.0; // unrealistic data
570  azimuthAngleRate_ = -10.0; // unrealistic data
571  elevationAngleRate_ = -10.0; // unrealistic data
572  parallacticAngle_ = 0.0;
573  aprioriClocks_ = 0.0;
574  estClocks_ = 0.0;
575  estClocksSigma_ = 0.0;
576  estZenithDelay_ = 0.0;
577  estZenithDelaySigma_ = 0.0;
578  estAtmGradN_ = 0.0;
579  estAtmGradNSigma_ = 0.0;
580  estAtmGradE_ = 0.0;
581  estAtmGradESigma_ = 0.0;
582  zenithDelayH_ = 0.0;
583  zenithDelayW_ = 0.0;
584  calcNdryCont4Delay_ = 0.0;
585  calcNdryCont4Rate_ = 0.0;
586  calcNwetCont4Delay_ = 0.0;
587  calcNwetCont4Rate_ = 0.0;
588  calcUnPhaseCal_ = 0.0;
589  calcAxisOffset4Delay_ = 0.0;
590  calcAxisOffset4Rate_ = 0.0;
591  calcOLoadHorz4Delay_ = 0.0;
592  calcOLoadHorz4Rate_ = 0.0;
593  calcOLoadVert4Delay_ = 0.0;
594  calcOLoadVert4Rate_ = 0.0;
595  dDel_dAxsOfs_ = 0.0;
596  dRat_dAxsOfs_ = 0.0;
597  dDel_dTzdDry_ = 0.0;
598  dRat_dTzdDry_ = 0.0;
599  dDel_dTzdWet_ = 0.0;
600  dRat_dTzdWet_ = 0.0;
601  dDel_dTzdGrdN_ = 0.0;
602  dRat_dTzdGrdN_ = 0.0;
603  dDel_dTzdGrdE_ = 0.0;
604  dRat_dTzdGrdE_ = 0.0;
605  refClockOffset_= 0.0;
606 
607  slantDelayH_ = 0.0;
608  slantRateH_ = 0.0;
609  slantDelayW_ = 0.0;
610  slantRateW_ = 0.0;
611  partDelayW_ = 0.0;
612  partRateW_ = 0.0;
613  tSyses_ = NULL;
614 };
615 
616 
617 
618 // A destructor:
620 {
621  // nothing to do
622  if (tSyses_)
623  {
624  delete tSyses_;
625  tSyses_ = NULL;
626  };
627 };
628 
629 
630 
631 //
632 // INTERFACES:
633 //
634 // Gets:
635 //
637 {
638  return owner_;
639 };
640 
641 
642 
643 // returns idx of St.#1
644 inline short int SgVlbiAuxObservation::getStationIdx() const
645 {
646  return stationIdx_;
647 };
648 
649 
650 
651 //
653 {
654  return meteoData_;
655 };
656 
657 
658 
659 //
661 {
662  return meteoData_;
663 };
664 
665 
666 
667 //
669 {
670  return cableCalibration_;
671 };
672 
673 
674 
675 //
677 {
678  return azimuthAngle_;
679 };
680 
681 
682 
683 //
685 {
686  return azimuthAngleRate_;
687 };
688 
689 
690 
691 //
693 {
694  return elevationAngle_;
695 };
696 
697 
698 
699 //
701 {
702  return elevationAngleRate_;
703 };
704 
705 
706 
707 //
709 {
710  return parallacticAngle_;
711 };
712 
713 
714 
715 //
717 {
718  return aprioriClocks_;
719 };
720 
721 
722 
723 //
725 {
726  return estClocks_;
727 };
728 
729 
730 
731 //
733 {
734  return estClocksSigma_;
735 };
736 
737 
738 
739 //
741 {
742  return estZenithDelay_;
743 };
744 
745 
746 
747 //
749 {
750  return estZenithDelaySigma_;
751 };
752 
753 
754 
755 //
757 {
758  return estAtmGradN_;
759 };
760 
761 
762 
763 //
765 {
766  return estAtmGradNSigma_;
767 };
768 
769 
770 
771 //
773 {
774  return estAtmGradE_;
775 };
776 
777 
778 
779 //
781 {
782  return estAtmGradESigma_;
783 };
784 
785 
786 
787 //
789 {
790  return zenithDelayH_;
791 };
792 
793 
794 
795 //
797 {
798  return zenithDelayW_;
799 };
800 
801 
802 
803 //
805 {
806  return calcNdryCont4Delay_;
807 };
808 
809 
810 
811 //
813 {
814  return calcNdryCont4Rate_;
815 };
816 
817 
818 
819 //
821 {
822  return calcNwetCont4Delay_;
823 };
824 
825 
826 
827 //
829 {
830  return calcNwetCont4Rate_;
831 };
832 
833 
834 
835 //
837 {
838  return calcUnPhaseCal_;
839 };
840 
841 
842 
843 //
845 {
846  return calcAxisOffset4Delay_;
847 };
848 
849 
850 
851 //
853 {
854  return calcAxisOffset4Rate_;
855 };
856 
857 
858 
859 //
861 {
862  return calcOLoadHorz4Delay_;
863 };
864 
865 
866 
867 //
869 {
870  return calcOLoadHorz4Rate_;
871 };
872 
873 
874 
875 //
877 {
878  return calcOLoadVert4Delay_;
879 };
880 
881 
882 
883 //
885 {
886  return calcOLoadVert4Rate_;
887 };
888 
889 
890 
891 //
893 {
894  return dDel_dAxsOfs_;
895 };
896 
897 
898 
899 //
901 {
902  return dRat_dAxsOfs_;
903 };
904 
905 
906 
907 
908 
909 // Sets:
910 //
912 {
913  owner_ = obs;
914 };
915 
916 
917 
918 //
919 inline void SgVlbiAuxObservation::setStationIdx(short int idx)
920 {
921  stationIdx_ = idx;
922 };
923 
924 
925 
926 //
928 {
929  meteoData_ = meteo;
930 };
931 
932 
933 
934 //
936 {
937  cableCalibration_ = cable;
938 };
939 
940 
941 
942 //
943 inline void SgVlbiAuxObservation::setAzimuthAngle(double angle)
944 {
945  azimuthAngle_ = angle;
946 };
947 
948 
949 
950 //
952 {
953  azimuthAngleRate_ = rate;
954 };
955 
956 
957 
958 //
960 {
961  elevationAngle_ = angle;
962 };
963 
964 
965 
966 //
968 {
969  elevationAngleRate_ = rate;
970 };
971 
972 
973 
974 //
976 {
977  parallacticAngle_ = angle;
978 };
979 
980 
981 
982 //
983 inline void SgVlbiAuxObservation::setAprioriClocks(double clocks)
984 {
985  aprioriClocks_ = clocks;
986 };
987 
988 
989 
990 //
992 {
993  estClocks_ = d;
994 };
995 
996 
997 
998 //
1000 {
1001  estClocksSigma_ = e;
1002 };
1003 
1004 
1005 
1006 //
1008 {
1009  estZenithDelay_ = d;
1010 };
1011 
1012 
1013 
1014 //
1016 {
1018 };
1019 
1020 
1021 
1022 //
1024 {
1025  estAtmGradN_ = g;
1026 };
1027 
1028 
1029 
1030 //
1032 {
1033  estAtmGradNSigma_ = s;
1034 };
1035 
1036 
1037 
1038 //
1040 {
1041  estAtmGradE_ = g;
1042 };
1043 
1044 
1045 
1046 //
1048 {
1049  estAtmGradESigma_ = s;
1050 };
1051 
1052 
1053 
1054 //
1056 {
1057  zenithDelayH_ = d;
1058 };
1059 
1060 
1061 
1062 //
1064 {
1065  zenithDelayW_ = d;
1066 };
1067 
1068 
1069 
1070 //
1072 {
1073  calcNdryCont4Delay_ = v;
1074 };
1075 
1076 
1077 
1078 //
1080 {
1081  calcNdryCont4Rate_ = v;
1082 };
1083 
1084 
1085 
1086 //
1088 {
1089  calcNwetCont4Delay_ = v;
1090 };
1091 
1092 
1093 
1094 //
1096 {
1097  calcNwetCont4Rate_ = v;
1098 };
1099 
1100 
1101 
1102 //
1104 {
1105  calcUnPhaseCal_ = v;
1106 };
1107 
1108 
1109 
1110 //
1112 {
1114 };
1115 
1116 
1117 
1118 //
1120 {
1122 };
1123 
1124 
1125 
1126 //
1128 {
1130 };
1131 
1132 
1133 
1134 //
1136 {
1137  calcOLoadHorz4Rate_ = v;
1138 };
1139 
1140 
1141 
1142 //
1144 {
1146 };
1147 
1148 
1149 
1150 //
1152 {
1153  calcOLoadVert4Rate_ = v;
1154 };
1155 
1156 
1157 
1158 //
1160 {
1161  dDel_dAxsOfs_ = v;
1162 };
1163 
1164 
1165 
1166 //
1168 {
1169  dRat_dAxsOfs_ = v;
1170 };
1171 
1172 
1173 
1174 //
1176 {
1177  if (!tSyses_)
1178  tSyses_ = new SgVector(ts);
1179  else
1180  {
1181  if (tSyses_->n() != ts.n())
1182  tSyses_->reSize(ts.n());
1183  *tSyses_ = ts;
1184  };
1185 };
1186 
1187 
1188 
1189 
1190 
1191 
1192 
1193 //
1194 // FUNCTIONS:
1195 //
1196 //
1197 //
1198 inline const QString SgVlbiAuxObservation::className() const
1199 {
1200  return "SgVlbiAuxObservation";
1201 };
1202 
1203 
1204 
1205 //
1207 {
1208  cableCalibration_ = 0.0;
1209 };
1210 
1211 
1212 
1213 //
1215 {
1217  meteoData_.setPressure(0.0);
1219 };
1220 
1221 
1222 
1223 //
1225 {
1226  if (tSyses_)
1227  tSyses_->clear();
1228 };
1229 
1230 
1231 
1232 //
1234 {
1235  return SgObservation::operator==(auxObs) &&
1236  stationIdx_ == auxObs.getStationIdx() &&
1237  meteoData_ == auxObs.getMeteoData() &&
1238  cableCalibration_ == auxObs.getCableCalibration() &&
1239  azimuthAngle_ == auxObs.getAzimuthAngle() &&
1240  elevationAngle_ == auxObs.getElevationAngle() &&
1241  azimuthAngleRate_ == auxObs.getAzimuthAngleRate() &&
1243  parallacticAngle_ == auxObs.getParallacticAngle() &&
1244  aprioriClocks_ == auxObs.getAprioriClocks() &&
1245  tapeId_ == auxObs.getTapeId();
1246  // should we compare the estimated parameters here?
1247 };
1248 
1249 
1250 
1251 //
1253 {
1254  return !(*this==auxObs);
1255 };
1256 
1257 
1258 
1259 //
1261 {
1262  if (!tSyses_)
1263  tSyses_ = new SgVector(n);
1264  else if ((int)tSyses_->n() != n)
1265  tSyses_->reSize(n);
1266 };
1267 
1268 
1269 
1270 
1271 
1272 
1273 //
1274 // FRIENDS:
1275 //
1276 //
1277 //
1278 
1279 
1280 /*=====================================================================================================*/
1281 
1282 
1283 
1284 
1285 
1286 /*=====================================================================================================*/
1287 //
1288 // aux functions:
1289 //
1290 
1291 /*=====================================================================================================*/
1292 #endif // SG_VLBI_AUX_OBSERVATION_H
const Sg3dVector v3Zero(0.0, 0.0, 0.0)
void setRelativeHumidity(double rho)
Definition: SgMeteoData.h:274
void setTemperature(double t)
Definition: SgMeteoData.h:258
void setPressure(double p)
Definition: SgMeteoData.h:266
virtual bool operator==(const SgObservation &obs) const
unsigned int n() const
Definition: SgVector.h:327
void reSize(unsigned int n)
Definition: SgVector.h:313
void clear()
Definition: SgVector.h:389
double getElement(unsigned int i) const
Definition: SgVector.h:362
double getDrat_dAxsOfs() const
void setOcnLdV(const Sg3dVector &v)
double getZenithDelayW() const
virtual const SgVector & o_c()
void setTsyses(const SgVector &ts)
double getCalcAxisOffset4Rate() const
void setCableCalibration(double cable)
SgVlbiObservation * owner_
void setMeteoData(const SgMeteoData &meteo)
void setAzimuthAngle(double angle)
void setDdel_dTzdDry(double v)
short int getStationIdx() const
double getDdel_dTzdGrdN() const
double getCableCalibration() const
double getCalcOLoadHorz4Delay() const
@ Attr_CABLE_CAL_BAD
clock break occured at the station
@ Attr_CLOCK_BREAK
clock break occured at the station
double getCalcOLoadVert4Rate() const
double getCalcUnPhaseCal() const
const QString & getTapeId() const
void setEstAtmGradESigma(double s)
double getCalcAxisOffset4Delay() const
void setCableCalSign(double s)
void setCalcNwetCont4Delay(double v)
virtual const QString className() const
void setEstClocksSigma(double e)
void setEstAtmGradNSigma(double s)
double getCalcOLoadVert4Delay() const
double getElevationAngle() const
double getDrat_dTzdWet() const
double getEstZenithDelay() const
double getCalcNwetCont4Delay() const
virtual bool isEligible(const SgTaskConfig *)
void setCalcNdryCont4Delay(double v)
void setDrat_dTzdWet(double v)
const Sg3dVector & getOcnLdR() const
virtual void evaluateResiduals(SgTaskManager *, SgVlbiBand *, bool)
void setCalcOLoadHorz4Delay(double v)
void setCalcOLoadHorz4Rate(double v)
void setDdel_dTzdGrdE(double v)
double getElevationAngleRate() const
void setAzimuthAngleRate(double rate)
void setCalcOLoadVert4Rate(double v)
void setDrat_dTzdGrdE(double v)
void setAprioriClocks(double clocks)
double getEstAtmGradNSigma() const
void setParallacticAngle(double angle)
double getDrat_dTzdGrdN() const
double getRefClockOffset() const
double getCalcNdryCont4Rate() const
double getCalcNdryCont4Delay() const
SgVlbiObservation * getOwner() const
const SgVector * getTsyses() const
void setCalcUnPhaseCal(double v)
void setEstZenithDelaySigma(double e)
void setStationIdx(short int idx)
const SgMeteoData & getMeteoData() const
void setDdel_dTzdGrdN(double v)
void setCalcOLoadVert4Delay(double v)
double getAprioriClocks() const
double getCableCalSign() const
double getZenithDelayH() const
double getTsys(unsigned int idx) const
virtual bool operator!=(const SgVlbiAuxObservation &auxObs) const
double getEstAtmGradESigma() const
double getEstClocksSigma() const
void setCalcAxisOffset4Delay(double v)
virtual bool operator==(const SgVlbiAuxObservation &auxObs) const
virtual void evaluateTheoreticalValues(SgTaskManager *)
void setDrat_dTzdGrdN(double v)
double getEstZenithDelaySigma() const
double getParallacticAngle() const
double getDdel_dTzdWet() const
void setOcnLdR(const Sg3dVector &r)
double getCalcNwetCont4Rate() const
void setCalcNwetCont4Rate(double v)
void setEstZenithDelay(double d)
void setElevationAngle(double angle)
void setElevationAngleRate(double rate)
double getAzimuthAngle() const
double getDrat_dTzdDry() const
void setCalcNdryCont4Rate(double v)
double getDdel_dTzdDry() const
void setDdel_dTzdWet(double v)
void setDrat_dTzdDry(double v)
double getAzimuthAngleRate() const
virtual void prepare4Analysis(SgTaskManager *)
void setRefClockOffset(double d)
void setOwner(SgVlbiObservation *)
virtual const SgVector & sigma()
double getDdel_dAxsOfs() const
double getDrat_dTzdGrdE() const
void setTapeId(const QString id)
void setCalcAxisOffset4Rate(double v)
double getCalcOLoadHorz4Rate() const
double getDdel_dTzdGrdE() const
const Sg3dVector & getOcnLdV() const