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 <SgTaskConfig.h>
37 #include <SgMeteoData.h>
38 #include <SgVector.h>
39 
40 
41 
42 
43 
44 class SgVlbiObservation;
45 /***===================================================================================================*/
53 {
54 public:
56  {
57 // Attr_NOT_VALID = 1<<0, //!< omit the observation;
58 // Attr_PROCESSED = 1<<1, //!< the observation has been processed;
59 // Attr_FORCE_2_PROCESS = 1<<2, //!< include the observation in data analysis in any condition;
62  };
63  //
65  {
66  CCT_FSLG = 0, // field system log
67  CCT_CDMS = 1, // CDMS
68  CCT_PCMT = 2, // PCMT
69  CCT_DFLT = 3, // Default
70  };
71 
72 
73 
74  // Statics:
75 
76  //
77  // constructors/destructors:
78  //
82  inline SgVlbiAuxObservation();
83 
84 
88  inline virtual ~SgVlbiAuxObservation();
89 
90 
91 
92  //
93  // Interfaces:
94  //
95 
96  // gets:
97  inline SgVlbiObservation* getOwner() const;
98 
101  inline short int getStationIdx() const;
102 
105  inline const SgMeteoData& getMeteoData() const;
106 
109  inline SgMeteoData& meteoData();
110 
113  inline double getCableCalibration() const;
114 
117  inline double getCableCalSign() const;
118 
121  inline double getAzimuthAngle() const;
122 
125  inline double getAzimuthAngleRate() const;
126 
129  inline double getElevationAngle() const;
130 
133  inline double getElevationAngleRate() const;
134 
137  inline double getParallacticAngle() const;
138 
141  inline double getAprioriClocks() const;
142 
145  inline double getEstClocks() const;
146 
149  inline double getEstClocksSigma() const;
150 
153  inline double getEstZenithDelay() const;
154 
157  inline double getEstZenithDelaySigma() const;
158 
161  inline double getEstAtmGradN() const;
162 
165  inline double getEstAtmGradNSigma() const;
166 
169  inline double getEstAtmGradE() const;
170 
173  inline double getEstAtmGradESigma() const;
174 
177  inline double getZenithDelayH() const;
178 
181  inline double getZenithDelayW() const;
182 
185  inline double getCalcNdryCont4Delay() const;
186  inline double getCalcNdryCont4Rate() const;
187 
190  inline double getCalcNwetCont4Delay() const;
191  inline double getCalcNwetCont4Rate() const;
192 
195  inline double getCalcUnPhaseCal() const;
196 
199  inline double getCalcAxisOffset4Delay() const;
200  inline double getCalcAxisOffset4Rate() const;
201 
204  inline double getCalcOLoadHorz4Delay() const;
205  inline double getCalcOLoadHorz4Rate() const;
206 
209  inline double getCalcOLoadVert4Delay() const;
210  inline double getCalcOLoadVert4Rate() const;
211 
214  inline double getDdel_dAxsOfs() const;
215 
218  inline double getDrat_dAxsOfs() const;
219 
220  inline double getDdel_dTzdDry() const {return dDel_dTzdDry_;}
221  inline double getDrat_dTzdDry() const {return dRat_dTzdDry_;}
222  inline double getDdel_dTzdWet() const {return dDel_dTzdWet_;}
223  inline double getDrat_dTzdWet() const {return dRat_dTzdWet_;}
224  inline double getDdel_dTzdGrdN() const {return dDel_dTzdGrdN_;}
225  inline double getDrat_dTzdGrdN() const {return dRat_dTzdGrdN_;}
226  inline double getDdel_dTzdGrdE() const {return dDel_dTzdGrdE_;}
227  inline double getDrat_dTzdGrdE() const {return dRat_dTzdGrdE_;}
228 
229  inline const Sg3dVector& getOcnLdR() const {return ocnLdR_;};
230  inline const Sg3dVector& getOcnLdV() const {return ocnLdV_;};
231 
232  inline double getRefClockOffset() const {return refClockOffset_;};
233 
234  inline double getSlantDelayH() const {return slantDelayH_;};
235  inline double getSlantRateH() const {return slantRateH_;};
236  inline double getSlantDelayW() const {return slantDelayW_;};
237  inline double getSlantRateW() const {return slantRateW_;};
238  inline double getPartDelayW() const {return partDelayW_;};
239  inline double getPartRateW() const {return partRateW_;};
240 
241  inline const SgVector* getTsyses() const {return tSyses_;};
242  inline const SgVector& cableCorrections() const {return cableCorrections_;};
243  inline double getTsys(unsigned int idx) const
244  {return (tSyses_ && idx<tSyses_->n())?tSyses_->getElement(idx):-10.0;};
245 
246  inline const QString& getTapeId() const {return tapeId_;};
247 
248 
249 
250  // sets:
251  //
252  inline void setOwner(SgVlbiObservation*);
253 
257  inline void setStationIdx(short int idx);
258 
262  inline void setMeteoData(const SgMeteoData& meteo);
263 
267  inline void setCableCalibration(double cable);
268 
272  inline void setCableCalSign(double s);
273 
277  inline void setAzimuthAngle(double angle);
278 
282  inline void setAzimuthAngleRate(double rate);
283 
287  inline void setElevationAngle(double angle);
288 
292  inline void setElevationAngleRate(double rate);
293 
297  inline void setParallacticAngle(double angle);
298 
302  inline void setAprioriClocks(double clocks);
303 
307  inline void setEstClocks(double d);
308 
312  inline void setEstClocksSigma(double e);
313 
317  inline void setEstZenithDelay(double d);
318 
322  inline void setEstZenithDelaySigma(double e);
323 
327  inline void setEstAtmGradN(double g);
328 
332  inline void setEstAtmGradNSigma(double s);
333 
337  inline void setEstAtmGradE(double g);
338 
342  inline void setEstAtmGradESigma(double s);
343 
347  inline void setZenithDelayH(double d);
348 
352  inline void setZenithDelayW(double d);
353 
357  inline void setCalcNdryCont4Delay(double v);
358  inline void setCalcNdryCont4Rate(double v);
359 
363  inline void setCalcNwetCont4Delay(double v);
364  inline void setCalcNwetCont4Rate(double v);
365 
369  inline void setCalcUnPhaseCal(double v);
370 
374  inline void setCalcAxisOffset4Delay(double v);
375  inline void setCalcAxisOffset4Rate(double v);
376 
379  inline void setCalcOLoadHorz4Delay(double v);
380  inline void setCalcOLoadHorz4Rate(double v);
381 
384  inline void setCalcOLoadVert4Delay(double v);
385  inline void setCalcOLoadVert4Rate(double v);
386 
390  inline void setDdel_dAxsOfs(double v);
391  inline void setDrat_dAxsOfs(double v);
392 
393  inline void setDdel_dTzdDry(double v) {dDel_dTzdDry_ = v;};
394  inline void setDrat_dTzdDry(double v) {dRat_dTzdDry_ = v;};
395  inline void setDdel_dTzdWet(double v) {dDel_dTzdWet_ = v;};
396  inline void setDrat_dTzdWet(double v) {dRat_dTzdWet_ = v;};
397 
398  inline void setDdel_dTzdGrdN(double v) {dDel_dTzdGrdN_ = v;};
399  inline void setDrat_dTzdGrdN(double v) {dRat_dTzdGrdN_ = v;};
400  inline void setDdel_dTzdGrdE(double v) {dDel_dTzdGrdE_ = v;};
401  inline void setDrat_dTzdGrdE(double v) {dRat_dTzdGrdE_ = v;};
402 
403  inline void setOcnLdR(const Sg3dVector& r) {ocnLdR_ = r;};
404  inline void setOcnLdV(const Sg3dVector& v) {ocnLdV_ = v;};
405 
406  inline void setRefClockOffset(double d) {refClockOffset_ = d;};
407 
408  inline void setSlantDelayH(double d) {slantDelayH_ = d;};
409  inline void setSlantRateH(double d) {slantRateH_ = d;};
410  inline void setSlantDelayW(double d) {slantDelayW_ = d;};
411  inline void setSlantRateW(double d) {slantRateW_ = d;};
412  inline void setPartDelayW(double d) {partDelayW_ = d;};
413  inline void setPartRateW(double d) {partRateW_ = d;};
414 
415  inline void setTsyses(const SgVector& ts);
416  inline SgVector* tSyses() {return tSyses_;};
418 
419  inline void setTapeId(const QString id) {tapeId_=id;};
420 
421 
422  //
423  // Functions:
424  //
427  virtual inline const QString className() const;
428 
431  virtual bool selfCheck();
432 
435  virtual bool isEligible(const SgTaskConfig*);
436 
439  virtual void prepare4Analysis(SgTaskManager*);
440 
444 
447  virtual void evaluateResiduals(SgTaskManager*, SgVlbiBand*, bool);
448 
451  virtual void evaluateResiduals(SgTaskManager*);
452 
455  virtual const SgVector& o_c();
456 
459  virtual const SgVector& sigma();
460 
463  inline void resetCable();
464 
467  inline void resetMeteo();
468 
471  inline void resetTsys();
472 
475  inline virtual bool operator==(const SgVlbiAuxObservation& auxObs) const;
476 
479  inline virtual bool operator!=(const SgVlbiAuxObservation& auxObs) const;
480 
481  inline void setTsysesSize(int n);
482  //
483  //
485  {
486  return cableCorrections_.getElement(idx);
487  };
488 
489 
490 
491  //
492  // Friends:
493  //
494 
495  //
496  // I/O:
497  //
498  // ...
499 
500 private:
502  short int stationIdx_;
511  double estClocks_;
515  double estAtmGradN_;
517  double estAtmGradE_;
521  // CALC's products: station dependent contributions:
535  // station dependent partials (mostly, form CALC):
546  // KOMB contribution:
548  //
549  double slantDelayH_;
550  double slantRateH_;
551  double slantDelayW_;
552  double slantRateW_;
553  double partDelayW_;
554  double partRateW_;
555 
556  //
557  // tsys:
559  // a set of cable cals: from logs, CDMS and PCMT (extension of cableCalibration_):
561  //
562  QString tapeId_;
563 };
564 /*=====================================================================================================*/
565 
566 
567 
568 
569 
570 /*=====================================================================================================*/
571 /* */
572 /* SgObservation inline members: */
573 /* */
574 /*=====================================================================================================*/
575 //
576 //
577 // CONSTRUCTORS:
578 //
579 // An empty constructor:
581  SgObservation(), meteoData_(),
582  ocnLdR_(v3Zero),
583  ocnLdV_(v3Zero),
584  cableCorrections_(4),
585  tapeId_("")
586 {
587  owner_ = NULL;
588  stationIdx_ = -1;
589  cableCalibration_ = 0.0;
590  azimuthAngle_ = -10.0; // unrealistic data
591  elevationAngle_ = -10.0; // unrealistic data
592  azimuthAngleRate_ = -10.0; // unrealistic data
593  elevationAngleRate_ = -10.0; // unrealistic data
594  parallacticAngle_ = 0.0;
595  aprioriClocks_ = 0.0;
596  estClocks_ = 0.0;
597  estClocksSigma_ = 0.0;
598  estZenithDelay_ = 0.0;
599  estZenithDelaySigma_ = 0.0;
600  estAtmGradN_ = 0.0;
601  estAtmGradNSigma_ = 0.0;
602  estAtmGradE_ = 0.0;
603  estAtmGradESigma_ = 0.0;
604  zenithDelayH_ = 0.0;
605  zenithDelayW_ = 0.0;
606  calcNdryCont4Delay_ = 0.0;
607  calcNdryCont4Rate_ = 0.0;
608  calcNwetCont4Delay_ = 0.0;
609  calcNwetCont4Rate_ = 0.0;
610  calcUnPhaseCal_ = 0.0;
611  calcAxisOffset4Delay_ = 0.0;
612  calcAxisOffset4Rate_ = 0.0;
613  calcOLoadHorz4Delay_ = 0.0;
614  calcOLoadHorz4Rate_ = 0.0;
615  calcOLoadVert4Delay_ = 0.0;
616  calcOLoadVert4Rate_ = 0.0;
617  dDel_dAxsOfs_ = 0.0;
618  dRat_dAxsOfs_ = 0.0;
619  dDel_dTzdDry_ = 0.0;
620  dRat_dTzdDry_ = 0.0;
621  dDel_dTzdWet_ = 0.0;
622  dRat_dTzdWet_ = 0.0;
623  dDel_dTzdGrdN_ = 0.0;
624  dRat_dTzdGrdN_ = 0.0;
625  dDel_dTzdGrdE_ = 0.0;
626  dRat_dTzdGrdE_ = 0.0;
627  refClockOffset_ = 0.0;
628 
629  slantDelayH_ = 0.0;
630  slantRateH_ = 0.0;
631  slantDelayW_ = 0.0;
632  slantRateW_ = 0.0;
633  partDelayW_ = 0.0;
634  partRateW_ = 0.0;
635  tSyses_ = NULL;
636 };
637 
638 
639 
640 // A destructor:
642 {
643  // nothing to do
644  if (tSyses_)
645  {
646  delete tSyses_;
647  tSyses_ = NULL;
648  };
649 };
650 
651 
652 
653 //
654 // INTERFACES:
655 //
656 // Gets:
657 //
659 {
660  return owner_;
661 };
662 
663 
664 
665 // returns idx of St.#1
666 inline short int SgVlbiAuxObservation::getStationIdx() const
667 {
668  return stationIdx_;
669 };
670 
671 
672 
673 //
675 {
676  return meteoData_;
677 };
678 
679 
680 
681 //
683 {
684  return meteoData_;
685 };
686 
687 
688 
689 //
691 {
692  return cableCalibration_;
693 };
694 
695 
696 
697 //
699 {
700  return azimuthAngle_;
701 };
702 
703 
704 
705 //
707 {
708  return azimuthAngleRate_;
709 };
710 
711 
712 
713 //
715 {
716  return elevationAngle_;
717 };
718 
719 
720 
721 //
723 {
724  return elevationAngleRate_;
725 };
726 
727 
728 
729 //
731 {
732  return parallacticAngle_;
733 };
734 
735 
736 
737 //
739 {
740  return aprioriClocks_;
741 };
742 
743 
744 
745 //
747 {
748  return estClocks_;
749 };
750 
751 
752 
753 //
755 {
756  return estClocksSigma_;
757 };
758 
759 
760 
761 //
763 {
764  return estZenithDelay_;
765 };
766 
767 
768 
769 //
771 {
772  return estZenithDelaySigma_;
773 };
774 
775 
776 
777 //
779 {
780  return estAtmGradN_;
781 };
782 
783 
784 
785 //
787 {
788  return estAtmGradNSigma_;
789 };
790 
791 
792 
793 //
795 {
796  return estAtmGradE_;
797 };
798 
799 
800 
801 //
803 {
804  return estAtmGradESigma_;
805 };
806 
807 
808 
809 //
811 {
812  return zenithDelayH_;
813 };
814 
815 
816 
817 //
819 {
820  return zenithDelayW_;
821 };
822 
823 
824 
825 //
827 {
828  return calcNdryCont4Delay_;
829 };
830 
831 
832 
833 //
835 {
836  return calcNdryCont4Rate_;
837 };
838 
839 
840 
841 //
843 {
844  return calcNwetCont4Delay_;
845 };
846 
847 
848 
849 //
851 {
852  return calcNwetCont4Rate_;
853 };
854 
855 
856 
857 //
859 {
860  return calcUnPhaseCal_;
861 };
862 
863 
864 
865 //
867 {
868  return calcAxisOffset4Delay_;
869 };
870 
871 
872 
873 //
875 {
876  return calcAxisOffset4Rate_;
877 };
878 
879 
880 
881 //
883 {
884  return calcOLoadHorz4Delay_;
885 };
886 
887 
888 
889 //
891 {
892  return calcOLoadHorz4Rate_;
893 };
894 
895 
896 
897 //
899 {
900  return calcOLoadVert4Delay_;
901 };
902 
903 
904 
905 //
907 {
908  return calcOLoadVert4Rate_;
909 };
910 
911 
912 
913 //
915 {
916  return dDel_dAxsOfs_;
917 };
918 
919 
920 
921 //
923 {
924  return dRat_dAxsOfs_;
925 };
926 
927 
928 
929 
930 
931 // Sets:
932 //
934 {
935  owner_ = obs;
936 };
937 
938 
939 
940 //
941 inline void SgVlbiAuxObservation::setStationIdx(short int idx)
942 {
943  stationIdx_ = idx;
944 };
945 
946 
947 
948 //
950 {
951  meteoData_ = meteo;
952 };
953 
954 
955 
956 //
958 {
959  cableCalibration_ = cable;
960 };
961 
962 
963 
964 //
965 inline void SgVlbiAuxObservation::setAzimuthAngle(double angle)
966 {
967  azimuthAngle_ = angle;
968 };
969 
970 
971 
972 //
974 {
975  azimuthAngleRate_ = rate;
976 };
977 
978 
979 
980 //
982 {
983  elevationAngle_ = angle;
984 };
985 
986 
987 
988 //
990 {
991  elevationAngleRate_ = rate;
992 };
993 
994 
995 
996 //
998 {
999  parallacticAngle_ = angle;
1000 };
1001 
1002 
1003 
1004 //
1005 inline void SgVlbiAuxObservation::setAprioriClocks(double clocks)
1006 {
1007  aprioriClocks_ = clocks;
1008 };
1009 
1010 
1011 
1012 //
1014 {
1015  estClocks_ = d;
1016 };
1017 
1018 
1019 
1020 //
1022 {
1023  estClocksSigma_ = e;
1024 };
1025 
1026 
1027 
1028 //
1030 {
1031  estZenithDelay_ = d;
1032 };
1033 
1034 
1035 
1036 //
1038 {
1040 };
1041 
1042 
1043 
1044 //
1046 {
1047  estAtmGradN_ = g;
1048 };
1049 
1050 
1051 
1052 //
1054 {
1055  estAtmGradNSigma_ = s;
1056 };
1057 
1058 
1059 
1060 //
1062 {
1063  estAtmGradE_ = g;
1064 };
1065 
1066 
1067 
1068 //
1070 {
1071  estAtmGradESigma_ = s;
1072 };
1073 
1074 
1075 
1076 //
1078 {
1079  zenithDelayH_ = d;
1080 };
1081 
1082 
1083 
1084 //
1086 {
1087  zenithDelayW_ = d;
1088 };
1089 
1090 
1091 
1092 //
1094 {
1095  calcNdryCont4Delay_ = v;
1096 };
1097 
1098 
1099 
1100 //
1102 {
1103  calcNdryCont4Rate_ = v;
1104 };
1105 
1106 
1107 
1108 //
1110 {
1111  calcNwetCont4Delay_ = v;
1112 };
1113 
1114 
1115 
1116 //
1118 {
1119  calcNwetCont4Rate_ = v;
1120 };
1121 
1122 
1123 
1124 //
1126 {
1127  calcUnPhaseCal_ = v;
1128 };
1129 
1130 
1131 
1132 //
1134 {
1136 };
1137 
1138 
1139 
1140 //
1142 {
1144 };
1145 
1146 
1147 
1148 //
1150 {
1152 };
1153 
1154 
1155 
1156 //
1158 {
1159  calcOLoadHorz4Rate_ = v;
1160 };
1161 
1162 
1163 
1164 //
1166 {
1168 };
1169 
1170 
1171 
1172 //
1174 {
1175  calcOLoadVert4Rate_ = v;
1176 };
1177 
1178 
1179 
1180 //
1182 {
1183  dDel_dAxsOfs_ = v;
1184 };
1185 
1186 
1187 
1188 //
1190 {
1191  dRat_dAxsOfs_ = v;
1192 };
1193 
1194 
1195 
1196 //
1198 {
1199  if (!tSyses_)
1200  tSyses_ = new SgVector(ts);
1201  else
1202  {
1203  if (tSyses_->n() != ts.n())
1204  tSyses_->reSize(ts.n());
1205  *tSyses_ = ts;
1206  };
1207 };
1208 
1209 
1210 
1211 
1212 
1213 
1214 
1215 //
1216 // FUNCTIONS:
1217 //
1218 //
1219 //
1220 inline const QString SgVlbiAuxObservation::className() const
1221 {
1222  return "SgVlbiAuxObservation";
1223 };
1224 
1225 
1226 
1227 //
1229 {
1230  cableCalibration_ = 0.0;
1231 };
1232 
1233 
1234 
1235 //
1237 {
1239  meteoData_.setPressure(0.0);
1241 };
1242 
1243 
1244 
1245 //
1247 {
1248  if (tSyses_)
1249  tSyses_->clear();
1250 };
1251 
1252 
1253 
1254 //
1256 {
1257  return SgObservation::operator==(auxObs) &&
1258  stationIdx_ == auxObs.getStationIdx() &&
1259  meteoData_ == auxObs.getMeteoData() &&
1260  cableCalibration_ == auxObs.getCableCalibration() &&
1261  azimuthAngle_ == auxObs.getAzimuthAngle() &&
1262  elevationAngle_ == auxObs.getElevationAngle() &&
1263  azimuthAngleRate_ == auxObs.getAzimuthAngleRate() &&
1265  parallacticAngle_ == auxObs.getParallacticAngle() &&
1266  aprioriClocks_ == auxObs.getAprioriClocks() &&
1267  tapeId_ == auxObs.getTapeId();
1268  // should we compare the estimated parameters here?
1269 };
1270 
1271 
1272 
1273 //
1275 {
1276  return !(*this==auxObs);
1277 };
1278 
1279 
1280 
1281 //
1283 {
1284  if (!tSyses_)
1285  tSyses_ = new SgVector(n);
1286  else if ((int)tSyses_->n() != n)
1287  tSyses_->reSize(n);
1288 };
1289 
1290 
1291 
1292 
1293 
1294 
1295 
1296 
1297 //
1298 // FRIENDS:
1299 //
1300 //
1301 //
1302 
1303 
1304 /*=====================================================================================================*/
1305 
1306 
1307 
1308 
1309 
1310 /*=====================================================================================================*/
1311 //
1312 // aux functions:
1313 //
1314 
1315 /*=====================================================================================================*/
1316 #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)
double effectiveCableCalValue(CableCorrectionType idx) const
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)
const SgVector & cableCorrections() const
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