General Purpose Geodetic Library
SgVlbiObservable.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 #include <QtCore/QVector>
29 
30 
31 #include <SgLogger.h>
32 #include <SgMathSupport.h>
33 #include <SgTaskConfig.h>
34 #include <SgVector.h>
35 #include <SgVlbiBand.h>
36 #include <SgVlbiObservable.h>
37 #include <SgVlbiObservation.h>
38 #include <SgVlbiSession.h>
39 
40 
41 
42 //
43 // declarations (just to use them only here):
44 //void subroutineParab(const double* pCXD, int n, double &dD, double &dA, double &dP);
45 void subroutineParab(const double* pX, const double* pY, int n, double &dD, double &dA, double &dP);
46 
47 
48 
49 //
50 bool evaluatePhaseCals(const SgVector& pcPhases, const SgVector& pcAmplitudes,
51  const SgVector& pcFreqByChan, double refFreq,
52  double& phaseCalGrd, double& phaseCalGrdAmbig,
53  double& phaseCalPhd, double& phaseCalPhdAmbig,
54  const QString& oId);
55 //bool evaluatePhaseCals(const SgVector& pcPhaseByChan, const SgVector& pcFreqByChan,
56 // double& phaseCal4grd, const QString& oId);
57 
58 
59 
60 /*=======================================================================================================
61 *
62 * METHODS:
63 *
64 *======================================================================================================*/
65 //
66 // static first:
68 {
69  return "SgVlbiObservable";
70 };
71 
72 
73 
74 // CONSTRUCTORS:
75 //
76 // An empty constructor:
78  bandKey_(""),
79  sbDelay_("Single Band Delay", SgTaskConfig::VD_SB_DELAY, SgTaskConfig::VR_NONE),
80  grDelay_("Group Delay", SgTaskConfig::VD_GRP_DELAY, SgTaskConfig::VR_NONE),
81  phDelay_("Phase Delay", SgTaskConfig::VD_PHS_DELAY, SgTaskConfig::VR_NONE),
82  phDRate_("Phase Rate", SgTaskConfig::VD_NONE, SgTaskConfig::VR_PHS_RATE),
83  errorCode_(""),
84  tapeQualityCode_(""),
85  nonUsableReason_(),
86  fourfitOutputFName_(""),
87  fourfitControlFile_(""),
88  fourfitCommandOverride_(""),
89  epochOfCorrelation_(tZero),
90  epochOfFourfitting_(tZero),
91  epochOfScan_(tZero),
92  epochCentral_(tZero),
93  tStart_(tZero),
94  tStop_(tZero)
95 {
96  mediaIdx_ = -1;
97  owner_ = obs;
98  band_ = NULL;
99  baseline_ = NULL;
100  stn_1_ = NULL;
101  stn_2_ = NULL;
102  src_ = NULL;
103  referenceFrequency_ = 0.0;
104  totalPhase_ = 0.0;
105  corrCoeff_ = 0.0;
106  snr_ = 0.0;
107  qualityFactor_ = 0;
108  numOfChannels_ = 0;
109  isUsable_ = true;
110 // nonUsableReason_ = NUR_UNDEF;
112  activeRate_ = NULL;
113  fourfitVersion_[0] = -1;
114  fourfitVersion_[1] = -1;
115  //
116  startOffset_ = 0;
117  stopOffset_ = 0;
118  centrOffset_ = 0.0;
119  sampleRate_ = 0.0;
120  bitsPerSample_ = 0;
121  effIntegrationTime_ = 0.0;
122  acceptedRatio_ = 0.0;
123  discardRatio_ = 0.0;
124  incohChanAddAmp_ = 0.0;
125  incohSegmAddAmp_ = 0.0;
127  geocenterTotalPhase_ = 0.0;
128  geocenterResidPhase_ = 0.0;
129  aPrioriDra_[0] = aPrioriDra_[1] = aPrioriDra_[2] = 0.0;
133 
134  //
135  for (int i=0; i<2; i++)
136  {
139  phaseCalRates_[i] = uvFrPerAsec_[i] = uRvR_[i] = corrClocks_[i][0] =
140  corrClocks_[i][1] = instrDelay_[i] = 0.0;
142  };
143  nLags_ = 0;
144  for (int i=0; i<6; i++)
145  fourfitSearchParameters_[i] = 0.0;
147 
152  refFreqByChan_ = NULL;
153  fringeAmplitudeByChan_ = NULL;
154  fringePhaseByChan_ = NULL;
155  polarization_1ByChan_ = NULL;
156  polarization_2ByChan_ = NULL;
157  phaseCalData_1ByChan_ = NULL;
158  phaseCalData_2ByChan_ = NULL;
159  vDlys_ = NULL;
160  vAuxData_ = NULL;
161  corelIndexNumUSB_ = NULL;
162  corelIndexNumLSB_ = NULL;
163 
164  chanIdByChan_ = NULL;
165  loFreqByChan_1_ = NULL;
166  loFreqByChan_2_ = NULL;
167  bbcIdxByChan_1_ = NULL;
168  bbcIdxByChan_2_ = NULL;
169 
170 
171  phaseCalModes_ = -1;
172  //
173  // temporary/tests:
174  sbdDiffBand_ = 0.0;
175  grdDiffBand_ = 0.0;
176  phrDiffBand_ = 0.0;
177  sbdQ_ = 0.0;
178  grdQ_ = 0.0;
179  phrQ_ = 0.0;
180  dTauS_= 0.0;
181  dTest_ = dTest2_ = 0.0;
182 };
183 
184 
185 
186 //
188  bandKey_(band?band->getKey():""),
189  sbDelay_("Single Band Delay", SgTaskConfig::VD_SB_DELAY, SgTaskConfig::VR_NONE),
190  grDelay_("Group Delay", SgTaskConfig::VD_GRP_DELAY, SgTaskConfig::VR_NONE),
191  phDelay_("Phase Delay", SgTaskConfig::VD_PHS_DELAY, SgTaskConfig::VR_NONE),
192  phDRate_("Phase Rate", SgTaskConfig::VD_NONE, SgTaskConfig::VR_PHS_RATE),
193  errorCode_(""),
194  tapeQualityCode_(""),
195  nonUsableReason_(),
196  fourfitOutputFName_(""),
197  fourfitControlFile_(""),
198  fourfitCommandOverride_(""),
199  epochOfCorrelation_(tZero),
200  epochOfFourfitting_(tZero),
201  epochOfScan_(tZero),
202  epochCentral_(tZero),
203  tStart_(tZero),
204  tStop_(tZero)
205 {
206  mediaIdx_ = -1;
207  owner_ = obs;
208  band_ = band;
209  baseline_ = NULL;
210  stn_1_ = NULL;
211  stn_2_ = NULL;
212  src_ = NULL;
213  referenceFrequency_ = 0.0;
214  totalPhase_ = 0.0;
215  corrCoeff_ = 0.0;
216  snr_ = 0.0;
217  qualityFactor_ = 0;
218  numOfChannels_ = 0;
219  isUsable_ = true;
220 // nonUsableReason_ = NUR_UNDEF;
222  activeRate_ = NULL;
223  fourfitVersion_[0] = 0;
224  fourfitVersion_[1] = 0;
225  //
226  startOffset_ = 0;
227  stopOffset_ = 0;
228  centrOffset_ = 0.0;
229  sampleRate_ = 0.0;
230  bitsPerSample_ = 0;
231  effIntegrationTime_ = 0.0;
232  acceptedRatio_ = 0.0;
233  discardRatio_ = 0.0;
234  incohChanAddAmp_ = 0.0;
235  incohSegmAddAmp_ = 0.0;
237  geocenterTotalPhase_ = 0.0;
238  geocenterResidPhase_ = 0.0;
239  aPrioriDra_[0] = aPrioriDra_[1] = aPrioriDra_[2] = 0.0 ;
243  //
244  for (int i=0; i<2; i++)
245  {
248  phaseCalRates_[i] = uvFrPerAsec_[i] = uRvR_[i] = corrClocks_[i][0] =
249  corrClocks_[i][1] = instrDelay_[i] = 0.0;
251  };
252  nLags_ = 0;
253  for (int i=0; i<6; i++)
254  fourfitSearchParameters_[i] = 0.0;
256  //
261  refFreqByChan_ = NULL;
262  fringeAmplitudeByChan_ = NULL;
263  fringePhaseByChan_ = NULL;
264  polarization_1ByChan_ = NULL;
265  polarization_2ByChan_ = NULL;
266  phaseCalData_1ByChan_ = NULL;
267  phaseCalData_2ByChan_ = NULL;
268  vDlys_ = NULL;
269  vAuxData_ = NULL;
270  corelIndexNumUSB_ = NULL;
271  corelIndexNumLSB_ = NULL;
272 
273  chanIdByChan_ = NULL;
274  loFreqByChan_1_ = NULL;
275  loFreqByChan_2_ = NULL;
276  bbcIdxByChan_1_ = NULL;
277  bbcIdxByChan_2_ = NULL;
278 
279  phaseCalModes_ = -1;
280  //
281  // temporary/tests:
282  sbdDiffBand_ = 0.0;
283  grdDiffBand_ = 0.0;
284  phrDiffBand_ = 0.0;
285  sbdQ_ = 0.0;
286  grdQ_ = 0.0;
287  phrQ_ = 0.0;
288  dTauS_= 0.0;
289  dTest_ = dTest2_ = 0.0;
290 };
291 
292 
293 
294 
295 
296 
297 // A copy constructor:
299  bandKey_(o.getBandKey()),
300  sbDelay_(o.sbDelay_),
301  grDelay_(o.grDelay_),
302  phDelay_(o.phDelay_),
303  phDRate_(o.phDRate_),
304  errorCode_(o.getErrorCode()),
305  tapeQualityCode_(o.getTapeQualityCode()),
306  fourfitOutputFName_(o.getFourfitOutputFName()),
307  fourfitControlFile_(o.getFourfitControlFile()),
308  fourfitCommandOverride_(o.getFourfitCommandOverride()),
309  epochOfCorrelation_(o.getEpochOfCorrelation()),
310  epochOfFourfitting_(o.getEpochOfFourfitting()),
311  epochOfScan_(o.getEpochOfScan()),
312  epochCentral_(o.getEpochCentral()),
313  tStart_(o.getTstart()),
314  tStop_(o.getTstop())
315 {
316  owner_ = obs;
317  band_ = o.band_;
318  baseline_ = o.getBaseline();
319  stn_1_ = o.getStn_1();
320  stn_2_ = o.getStn_2();
321  src_ = o.getSrc();
326  setSnr(o.getSnr());
330  activeRate_ = NULL;
333  //
347  setAprioriDra(0, o.getAprioriDra(0));
348  setAprioriDra(1, o.getAprioriDra(1));
349  setAprioriDra(2, o.getAprioriDra(2));
356 
357  for (int i=0; i<2; i++)
358  {
363  setUrVr(i, o.getUrVr(i));
364  setCorrClocks(i, 0, o.getCorrClocks(i, 0));
365  setCorrClocks(i, 1, o.getCorrClocks(i, 1));
366  setInstrDelay(i, o.getInstrDelay(i));
367  }
368  setNlags(o.getNlags());
369  for (int i=0; i<6; i++)
372 
373  //
376  else
378 
381  else
383 
384  if (o.numOfSamplesByChan_USB())
386  else
388 
389  if (o.numOfSamplesByChan_LSB())
391  else
393 
394  if (o.refFreqByChan())
396  else
397  refFreqByChan_ = NULL;
398 
399  if (o.fringeAmplitudeByChan())
401  else
402  fringeAmplitudeByChan_ = NULL;
403 
404  if (o.fringePhaseByChan())
406  else
407  fringePhaseByChan_ = NULL;
408 
409  if (o.polarization_1ByChan())
410  polarization_1ByChan_ = new QVector<char>(*o.polarization_1ByChan());
411  else
412  polarization_1ByChan_ = NULL;
413 
414  if (o.polarization_2ByChan())
415  polarization_2ByChan_ = new QVector<char>(*o.polarization_2ByChan());
416  else
417  polarization_2ByChan_ = NULL;
418 
419  if (o.phaseCalData_1ByChan())
421  else
422  phaseCalData_1ByChan_ = NULL;
423 
424  if (o.vDlys())
425  vDlys_ = new SgVector(*o.vDlys());
426  else
427  vDlys_ = NULL;
428 
429  if (o.vAuxData())
430  vAuxData_ = new SgVector(*o.vAuxData());
431  else
432  vAuxData_ = NULL;
433 
434  if (o.phaseCalData_2ByChan())
436  else
437  phaseCalData_2ByChan_ = NULL;
438 
440 
441  if (o.corelIndexNumUSB())
442  corelIndexNumUSB_ = new QVector<int>(*o.corelIndexNumUSB());
443  else
444  corelIndexNumUSB_ = NULL;
445 
446  if (o.corelIndexNumLSB())
447  corelIndexNumLSB_ = new QVector<int>(*o.corelIndexNumLSB());
448  else
449  corelIndexNumLSB_ = NULL;
450 
451  //
452  if (o.chanIdByChan())
453  chanIdByChan_ = new QVector<char>(*o.chanIdByChan());
454  else
455  chanIdByChan_ = NULL;
456 
457  if (o.loFreqByChan_1())
459  else
460  loFreqByChan_1_ = NULL;
461  if (o.loFreqByChan_2())
463  else
464  loFreqByChan_2_ = NULL;
465 
466  bbcIdxByChan_1_ = o.bbcIdxByChan_1() ? new QVector<int>(*o.bbcIdxByChan_1()) : NULL;
467  bbcIdxByChan_2_ = o.bbcIdxByChan_2() ? new QVector<int>(*o.bbcIdxByChan_2()) : NULL;
468  //
469  // temporary/tests:
473  setSbdQ(o.getSbdQ());
474  setGrdQ(o.getGrdQ());
475  setPhrQ(o.getPhrQ());
476  dTauS_ = o.getTauS();
477  dTest_ = o.dTest_;
478  dTest2_ = o.dTest2_;
479 };
480 
481 
482 
483 //
485 {
486  switch (cfg->getUseDelayType())
487  {
488  default:
490  activeDelay_ = NULL;
491  break;
494  break;
497  break;
500  break;
501  };
502  switch (cfg->getUseRateType())
503  {
504  default:
506  activeRate_ = NULL;
507  break;
510  break;
511  };
512 };
513 
514 
515 
516 // returns true if the obs is potentially good:
518 {
519  bool isOk=true;
520  // quality code:
521  if (cfg && getQualityFactor()<cfg->getQualityCodeThreshold())
522  isOk = false;
523  // deselected station, baseline, source:
525  return false;
527  return false;
529  return false;
531  return false;
532  // ionosphere:
533  //if (isOk && owner_->session()->isAttr(SgVlbiSession::Attr_FF_ION_C_CALCULATED))
535  {
536  if (owner_->observableByKey().size() == 1) //missed obs on the other band
537  isOk = false;
538  if (isOk && cfg && owner_->minQualityFactor() < cfg->getQualityCodeThreshold()) //not enough quality
539  isOk = false;
540  };
541  return isOk;
542 };
543 
544 
545 
547 {
548  isUsable_ = true;
550  //
551  if (cfg && getQualityFactor()<cfg->getQualityCodeThreshold())
552  {
553  isUsable_ = false;
555  };
556  if (1<band_->getMaxNumOfChannels() && numOfChannels_ < 2)
557  {
558  isUsable_ = false;
560  };
562  {
563  isUsable_ = false;
565  };
567  {
568  isUsable_ = false;
570  };
572  {
573  isUsable_ = false;
575  };
577  {
578  isUsable_ = false;
580  };
581  if (errorCode_.simplified().size() &&
582  !((cfg->getUseQualityCodeG() && errorCode_.contains('G')) ||
583  (cfg->getUseQualityCodeH() && errorCode_.contains('H')) ) )
584  {
585  isUsable_ = false;
587  };
588  //
589  // dual band combinations, check other band:
590  if (owner_->session()->bands().size()>1 &&
591 // owner_->session()->isAttr(SgVlbiSession::Attr_FF_ION_C_CALCULATED) &&
599  )
600  {
601  if (owner_->observableByKey().size() == 1)
602  {
603  isUsable_ = false;
605  }
606  else
607  for (int i=0; i<owner_->passiveObses().size(); i++)
608  {
610  if (o->getQualityFactor() < cfg->getQualityCodeThreshold())
611  {
612  isUsable_ = false;
614  };
615  if (1<o->band()->getMaxNumOfChannels() && o->getNumOfChannels() < 2)
616  {
617  isUsable_ = false;
619  };
620  if (o->getErrorCode().simplified().size() &&
621  !((cfg->getUseQualityCodeG() && o->getErrorCode().contains('G')) ||
622  (cfg->getUseQualityCodeH() && o->getErrorCode().contains('H')) ) )
623  {
624  isUsable_ = false;
626  };
627  };
628  };
629 };
630 
631 
632 
633 //
635 {
636  return owner_?(*owner_):tZero;
637 };
638 
639 
640 
641 //
642 QString SgVlbiObservable::strId() const
643 {
644  QString srcN("?"), blnN("?:?");
647  if (!si)
649  if (!bi)
651  if (si)
652  srcN = si->getKey();
653  if (bi)
654  blnN = bi->getKey();
655  return
656  " #" + QString("").setNum(mediaIdx_) + " on " + bandKey_ + "-band, " +
657  epoch().toString(SgMJD::F_YYYYMMDDHHMMSSSS) + " of " + srcN + " at " + blnN +
658  " [" + owner_->getScanName() + "]";
659 };
660 
661 
662 
663 //
665 {
667  if ((numOfChannels_=numOfChans) > 0)
668  {
676  polarization_1ByChan_ = new QVector<char>(numOfChannels_);
677  polarization_2ByChan_ = new QVector<char>(numOfChannels_);
680  //
681  vDlys_ = new SgVector(3);
682  vAuxData_ = new SgVector(5);
683  // fixed size (mimic dbedit behavior):
684  corelIndexNumUSB_ = new QVector<int>(numOfChannels_);
685  corelIndexNumLSB_ = new QVector<int>(numOfChannels_);
686  //
687  chanIdByChan_ = new QVector<char>(numOfChannels_);
690  bbcIdxByChan_1_ = new QVector<int>(numOfChannels_);
691  bbcIdxByChan_2_ = new QVector<int>(numOfChannels_);
692  }
693  else
695  ": allocateChannelsSetupStorages(): an attempt to allocate data with zero number of channels");
696 };
697 
698 
699 
700 //
702 {
704  {
707  };
709  {
712  };
714  {
717  };
719  {
722  };
723  if (refFreqByChan_)
724  {
725  delete refFreqByChan_;
726  refFreqByChan_ = NULL;
727  };
729  {
730  delete fringeAmplitudeByChan_;
731  fringeAmplitudeByChan_ = NULL;
732  };
733  if (fringePhaseByChan_)
734  {
735  delete fringePhaseByChan_;
736  fringePhaseByChan_ = NULL;
737  };
739  {
740  delete polarization_1ByChan_;
741  polarization_1ByChan_ = NULL;
742  };
744  {
745  delete polarization_2ByChan_;
746  polarization_2ByChan_ = NULL;
747  };
749  {
750  delete phaseCalData_1ByChan_;
751  phaseCalData_1ByChan_ = NULL;
752  };
754  {
755  delete phaseCalData_2ByChan_;
756  phaseCalData_2ByChan_ = NULL;
757  };
758  if (vDlys_)
759  {
760  delete vDlys_;
761  vDlys_ = NULL;
762  };
763  if (vAuxData_)
764  {
765  delete vAuxData_;
766  vAuxData_ = NULL;
767  };
768  if (corelIndexNumUSB_)
769  {
770  delete corelIndexNumUSB_;
771  corelIndexNumUSB_ = NULL;
772  };
773  if (corelIndexNumLSB_)
774  {
775  delete corelIndexNumLSB_;
776  corelIndexNumLSB_ = NULL;
777  };
778 
779  if (chanIdByChan_)
780  {
781  delete chanIdByChan_;
782  chanIdByChan_ = NULL;
783  };
784  if (loFreqByChan_1_)
785  {
786  delete loFreqByChan_1_;
787  loFreqByChan_1_ = NULL;
788  };
789  if (loFreqByChan_2_)
790  {
791  delete loFreqByChan_2_;
792  loFreqByChan_2_ = NULL;
793  };
794  if (bbcIdxByChan_1_)
795  {
796  delete bbcIdxByChan_1_;
797  bbcIdxByChan_1_ = NULL;
798  };
799  if (bbcIdxByChan_2_)
800  {
801  delete bbcIdxByChan_2_;
802  bbcIdxByChan_2_ = NULL;
803  };
804 };
805 
806 
807 
808 //
809 /*
810 int SgVlbiObservable::qualityFactor() const
811 {
812  int qFactor;
813  bool isOk;
814  qFactor = qualityCode_.toInt(&isOk);
815  if (!isOk)
816  qFactor = -1;
817  return qFactor;
818 };
819 */
820 
821 
822 
823 //
825 {
826  int n=-29;
827  if (errorCode_ == "" || errorCode_ == " " || errorCode_ == " ")
828  n = 0;
829  else if (errorCode_ == "A")
830  n = -1;
831  else if (errorCode_ == "B")
832  n = -2;
833  else if (errorCode_ == "C")
834  n = -3;
835  else if (errorCode_ == "D")
836  n = -4;
837  else if (errorCode_ == "E")
838  n = -5;
839  else if (errorCode_ == "F")
840  n = -6;
841  else if (errorCode_ == "G")
842  n = -7;
843  else if (errorCode_ == "H")
844  n = -8;
845  else if (errorCode_ == "I")
846  n = -9;
847  else if (errorCode_ == "J")
848  n = -10;
849  else if (errorCode_ == "K")
850  n = -11;
851  else if (errorCode_ == "L")
852  n = -12;
853  else if (errorCode_ == "M")
854  n = -13;
855  else if (errorCode_ == "N")
856  n = -14;
857  else if (errorCode_ == "O")
858  n = -15;
859  else if (errorCode_ == "P")
860  n = -16;
861  else if (errorCode_ == "Q")
862  n = -17;
863  else if (errorCode_ == "R")
864  n = -18;
865  else if (errorCode_ == "S")
866  n = -19;
867  else if (errorCode_ == "T")
868  n = -20;
869  else if (errorCode_ == "U")
870  n = -21;
871  else if (errorCode_ == "V")
872  n = -22;
873  else if (errorCode_ == "W")
874  n = -23;
875  else if (errorCode_ == "X")
876  n = -24;
877  else if (errorCode_ == "Y")
878  n = -25;
879  else if (errorCode_ == "Z")
880  n = -26;
881  return n;
882 };
883 
884 
885 
886 //
888 {
893  if (sbDelay_.getSigma() < 5.0e-12)
895  if (grDelay_.getSigma() < 1.0e-15)
897 };
898 
899 
900 
901 //
903 {
905  if (s.status() == QDataStream::Ok &&
910  return s.status() == QDataStream::Ok;
911  else
912  return false;
913 };
914 
915 
916 
917 //
919 {
920  QString bandKey;
921  int mediaIdx;
922  bool is;
923  unsigned int attributes;
924  s >> bandKey >> mediaIdx >> is >> attributes;
925  if (s.status() == QDataStream::Ok)
926  {
927  if (bandKey_ != bandKey)
928  {
930  ": loadIntermediateResults(): error reading " + bandKey_ +
931  "-band data: bandKey mismatch: got [" + bandKey + "], expected [" + bandKey_ + "]");
932  return false;
933  };
934  if (mediaIdx_ != mediaIdx)
935  {
937  ": loadIntermediateResults(): error reading " + bandKey_ +
938  "-band data: media index mismatch: got [" +
939  QString("").setNum(mediaIdx) + "], expected [" + QString("").setNum(mediaIdx_) + "]");
940  return false;
941  };
942  isUsable_ = is;
943  nonUsableReason_.setAttributes(attributes);
948  return true;
949  };
951  ": loadIntermediateResults(): error reading data: " +
952  (s.status()==QDataStream::ReadPastEnd?"read past end of the file":"read corrupt data"));
953  return false;
954 };
955 
956 
957 
958 //
960 {
961  if (snr_ <= 0.0) // just noise
962  return;
963 
964  if (!owner_)
965  {
967  ": calcPhaseDelay(): cannot calculate phase delay: the owner is NULL");
968  return;
969  };
970  if (!band_)
971  {
973  ": calcPhaseDelay(): cannot calculate phase delay: the band is NULL");
974  return;
975  };
976  SgVlbiAuxObservation *aux_1=owner_->auxObs_1(), *aux_2=owner_->auxObs_2();
977  if (!(aux_1 && aux_2))
978  {
980  ": calcPhaseDelay(): cannot calculate phase delay: the aux obss are NULL");
981  return;
982  };
983  double vPhDly, ePhDly, aPhDly, dNumAmbigs;
984 
985  vPhDly = (totalPhase_ - (aux_2->getParallacticAngle() - aux_1->getParallacticAngle()))*1.0e-6
986  /(2.0*M_PI*referenceFrequency_);
987  if (1.0e-10 < snr_)
988  ePhDly = 1.0e-6/(2.0*M_PI*referenceFrequency_*snr_);
989  else
990  {
992  ": calcPhaseDelay(): got unusual value for SNR: " + QString("").setNum(snr_));
993  ePhDly = 1.0e-6/(2.0*M_PI*referenceFrequency_);
994  };
995  aPhDly = 1.0e-6/referenceFrequency_; // refFreq is in Mhz
996  dNumAmbigs = round((grDelay_.getValue() + grDelay_.ambiguity() - vPhDly)/aPhDly);
997 
998  phDelay_.setValue(vPhDly + dNumAmbigs*aPhDly);
999  phDelay_.setSigma(ePhDly);
1000  phDelay_.setAmbiguitySpacing(aPhDly);
1001 };
1002 
1003 
1004 
1005 //
1007 {
1008  if (!band_)
1009  {
1011  ": calcPhaseCalDelay(): cannot calculate phase cal effects: band is NULL");
1012  return;
1013  };
1014  if (!refFreqByChan_)
1015  {
1017  ": calcPhaseCalDelay(): cannot calculate phase cal effects: ref.freq storage is NULL");
1018  return;
1019  };
1020  if (!phaseCalData_1ByChan_)
1021  {
1023  ": calcPhaseCalDelay(): cannot calculate phase cal effects: pcal phases @1 storage is NULL");
1024  return;
1025  };
1026  if (!phaseCalData_2ByChan_)
1027  {
1029  ": calcPhaseCalDelay(): cannot calculate phase cal effects: pcal phases @2 storage is NULL");
1030  return;
1031  };
1033  {
1035  ": calcPhaseCalDelay(): cannot calculate phase cal effects: size mismatch for @1: " +
1036  QString("").sprintf("#chan(%d) != #PCchan(%d)",
1038  return;
1039  };
1041  {
1043  ": calcPhaseCalDelay(): cannot calculate phase cal effects: size mismatch for @2");
1044  return;
1045  };
1046  int n=refFreqByChan_->n();
1047  SgVector *pcPhases_1 = new SgVector(n);
1048  SgVector *pcPhases_2 = new SgVector(n);
1049  SgVector *pcAmplitudes_1 = new SgVector(n);
1050  SgVector *pcAmplitudes_2 = new SgVector(n);
1051 
1052  for (int i=0; i<n; i++)
1053  {
1054  pcPhases_1 ->setElement(i, phaseCalData_1ByChan_->getElement(PCCI_PHASE, i) +
1056  pcPhases_2 ->setElement(i, phaseCalData_2ByChan_->getElement(PCCI_PHASE, i) +
1058 // pcAmplitudes_1->setElement(i, phaseCalData_1ByChan_->getElement(PCCI_AMPLITUDE, i)*1.0e-4);
1059 // pcAmplitudes_2->setElement(i, phaseCalData_2ByChan_->getElement(PCCI_AMPLITUDE, i)*1.0e-4);
1060  pcAmplitudes_1->setElement(i, phaseCalData_1ByChan_->getElement(PCCI_AMPLITUDE, i));
1061  pcAmplitudes_2->setElement(i, phaseCalData_2ByChan_->getElement(PCCI_AMPLITUDE, i));
1062  pcAmplitudes_1->setElement(i, 1.0);
1063  pcAmplitudes_2->setElement(i, 1.0);
1064  };
1065 
1066  double phaseCalGrd=0.0;
1067  double phaseCalGrdAmbig=0.0;
1068  double phaseCalPhd=0.0;
1069  double phaseCalPhdAmbig=0.0;
1070 
1071  if (evaluatePhaseCals(*pcPhases_1, *pcAmplitudes_1, *refFreqByChan_, referenceFrequency_,
1072  phaseCalGrd, phaseCalGrdAmbig, phaseCalPhd, phaseCalPhdAmbig, strId()))
1073  {
1074  phaseCalGrDelays_[0] = phaseCalGrd*1.0e-9;
1075  phaseCalPhDelays_[0] = phaseCalPhd*1.0e-9;
1076  phaseCalGrAmbigSpacings_[0] = phaseCalGrdAmbig*1.0e-9;
1077  phaseCalPhAmbigSpacings_[0] = phaseCalPhdAmbig*1.0e-9;
1078  };
1079 
1080  if (evaluatePhaseCals(*pcPhases_2, *pcAmplitudes_2, *refFreqByChan_, referenceFrequency_,
1081  phaseCalGrd, phaseCalGrdAmbig, phaseCalPhd, phaseCalPhdAmbig, strId()))
1082  {
1083  phaseCalGrDelays_[1] = phaseCalGrd*1.0e-9;
1084  phaseCalPhDelays_[1] = phaseCalPhd*1.0e-9;
1085  phaseCalGrAmbigSpacings_[1] = phaseCalGrdAmbig*1.0e-9;
1086  phaseCalPhAmbigSpacings_[1] = phaseCalPhdAmbig*1.0e-9;
1087  };
1088  //
1089  delete pcPhases_1;
1090  delete pcPhases_2;
1091  delete pcAmplitudes_1;
1092  delete pcAmplitudes_2;
1093 };
1094 /*=====================================================================================================*/
1095 
1096 
1097 
1098 /*=====================================================================================================*/
1099 //
1100 // FRIENDS:
1101 //
1102 /*=====================================================================================================*/
1103 //
1104 
1105 
1106 
1107 /*=====================================================================================================*/
1108 //
1109 // aux functions:
1110 //
1111 /*=====================================================================================================*/
1112 //
1113 bool evaluatePhaseCals(const SgVector& pcPhases, const SgVector& pcAmplitudes,
1114  const SgVector& pcFreqByChan, double refFreq,
1115  double& phaseCalGrd, double& phaseCalGrdAmbig,
1116  double& phaseCalPhd, double& phaseCalPhdAmbig,
1117  const QString& oId)
1118 {
1119  int nChan=pcFreqByChan.n();
1120  phaseCalGrdAmbig = 0.0;
1121  phaseCalPhdAmbig = 0.0;
1122  if (nChan == 0)
1123  {
1125  "evaluatePhaseCals: number of actual channels is zero, nothing to do for the obs " + oId);
1126  return false;
1127  };
1128  if (nChan == 1)
1129  {
1131  "evaluatePhaseCals: have only one actual channel, nothing to do for the obs " + oId);
1132  return false;
1133  };
1134  // $MK5_ROOT/progs/dbcal/pcclc.f:
1135 //--
1136 // COMPLEX*16 CDD(16), CD(256)
1137  double *pX=NULL, *pY=NULL;
1138  double *pXsvd=NULL, *pYsvd=NULL;
1139 // REAL*8 SUMI, SUMR, SPP, CPP, SINP, COSP, FFF, AWOPI
1140 // double cosPh, sinPh;
1141 // REAL*8 REFFR, PCGRP, PCPHA, GPAMB, PHAMB
1142 // REAL*8 RFREQ(16), RPCP(16), PHRES(16)
1143 // REAL*8 A, B, RFMIN, TWOPI
1144  double rfMin, diffMin, d;
1145 // int *idxs=new int[nChan], nData=256;
1146  int *idxs=new int[nChan], nData=512;
1147 // REAL*8 D, A4, P
1148  double dD, dA4, dP;
1149 // INTEGER*4 I, J, K, IERR, luout, IELEM(16), I256, I1
1150 // INTEGER*2 NFREQ
1151 //
1152 // DATA TWOPI /6.2831853071796D0/
1153 // !
1154 // ! GET LOWEST FREQUENCY. GET SMALLEST SPACING.
1155 // !
1156 // A=1.D6
1157 // RFMIN=1.D15
1158  diffMin = 1.0e6;
1159  diffMin = 1.0e12;
1160  rfMin = 1.0e15;
1161 // DO I=1,NFREQ
1162 // RFREQ(I)=DABS(RFREQ(I))
1163 // IF (RFREQ(I).LT.RFMIN) RFMIN=RFREQ(I)
1164 // ENDDO
1165  for (int i=0; i<nChan; i++)
1166  if ( (d=fabs(pcFreqByChan.getElement(i))) < rfMin)
1167  rfMin = d;
1168 // !
1169 // DO I=1,NFREQ
1170 // K=I+1
1171 // DO J=K,NFREQ
1172 // B=DABS(RFREQ(J)-RFREQ(I))
1173 // IF (A.GT.B .AND. B.GT.0.D0) A=B
1174 // ENDDO
1175 // ENDDO
1176  for (int i=0; i<nChan; i++)
1177  for (int j=i+1; j<nChan; j++)
1178  {
1179  d = fabs(pcFreqByChan.getElement(j) - pcFreqByChan.getElement(i));
1180  if (0.0 < d && d < diffMin)
1181  diffMin = d;
1182  };
1183 // !
1184 // ! GROUP DELAY AMBIGUITY IN NANOSEC (FREQS ARE MHZ)
1185 // !
1186 // GPAMB=1.D0/A
1187 // GPAMB=GPAMB*1000.D0
1188  phaseCalGrdAmbig = 1.0/diffMin*1.0e3;
1189 // !
1190 // ! PHASE DELAY AMBIGUITY IN NANOSEC (FREQS ARE MHZ)
1191 // !
1192 // PHAMB=1.D0/REFFR
1193 // PHAMB=PHAMB*1000.D0
1194  phaseCalPhdAmbig = 1.0/refFreq*1.0e3;
1195 // !
1196 // ! ASSIGN ARRAY ELEMENTS;
1197 // !
1198 // DO I=1,NFREQ
1199 // IELEM(I)=((RFREQ(I)-RFMIN)/A)+1.D0
1200 // IF (IELEM(I).GT.256) THEN
1201 // Write (luout,'(" Array overrun ")')
1202 // IERR=1
1203 // RETURN
1204 // ENDIF
1205 // ENDDO
1206  for (int i=0; i<nChan; i++)
1207  if (nData <= (idxs[i]=((fabs(pcFreqByChan.getElement(i)) - rfMin)/diffMin)))
1208  {
1210  "evaluatePCal4GrpDelay: Array overrun for the obs " + oId +
1211  QString("").sprintf(": idxs[%d]=%d for %.2f and Fmin=%.2f Dmin=%.2f",
1212  i, idxs[i], pcFreqByChan.getElement(i), rfMin, diffMin));
1213  delete[] idxs;
1214  return false;
1215  };
1216 // !
1217 // ! PUT PHASES IN THE APPROPRIATE BINS
1218 // ! (AMPLITUDES ARE NOT USED).
1219 // !
1220 // DO I=1,256
1221 // CD(I)=DCMPLX(0.D0,0.D0)
1222 // ENDDO
1223 // !
1224 // DO I=1,16
1225 // CDD(I)=DCMPLX(0.D0,0.D0)
1226 // ENDDO
1227  pX = new double[nData];
1228  pY = new double[nData];
1229  pXsvd = new double[nChan];
1230  pYsvd = new double[nChan];
1231  for (int i=0; i<nChan; i++)
1232  pXsvd[i] = pYsvd[i] = 0.0;
1233  for (int i=0; i<nData; i++)
1234  pX[i] = pY[i] = 0.0;
1235 // !
1236 // DO I=1 ,NFREQ
1237 // COSP=DCOS(RPCP(I))
1238 // SINP=DSIN(RPCP(I))
1239 // CD(IELEM(I))=DCMPLX(COSP,SINP)
1240 // CDD(I)=DCMPLX(COSP,SINP)
1241 // ENDDO
1242  for (int i=0; i<nChan; i++)
1243  {
1244  pX[idxs[i]] = pXsvd[i] = pcAmplitudes.getElement(i)*cos(pcPhases.getElement(i));
1245  pY[idxs[i]] = pYsvd[i] = pcAmplitudes.getElement(i)*sin(pcPhases.getElement(i));
1246  };
1247 // !
1248 // ! COMPUTE DELAY RESOLUTION FUNCTION
1249 // !
1250 // I256 = 256
1251 // I1 = 1
1252 // CALL FOUR1 ( CD, I256, I1 )
1253 
1254 //std::cout << "------------\n";
1255 //for (int i=0; i<nData; i++)
1256 //std::cout << i << " " << dData[2*i] << " " << dData[2*i + 1] << "\n";
1257 
1258 //-> four1(dData, nData, 1);
1259  fft(pX, pY, nData, -1);
1260 
1261 //for (int i=0; i<nData; i++)
1262 //std::cout << i << " " << dData[2*i] << " " << dData[2*i + 1] << "\n";
1263 //std::cout << "------------\n";
1264 
1265 // !
1266 // ! LOCATE MAXIMUM
1267 // !
1268 // CALL PARAB ( CD, I256, D, A4, P )
1269  subroutineParab(pX, pY, nData, dD, dA4, dP);
1270 // !
1271 // ! FIND GROUP DELAY EFFECT IN NANOSECONDS;
1272 // !
1273 // D=D-1.D0
1274 // PCGRP=GPAMB* D/256.D0
1275 // PCGRP=DMOD(PCGRP+GPAMB*2.5D0, GPAMB) - 0.5D0*GPAMB
1276  phaseCalGrd = phaseCalGrdAmbig*dD/nData;
1277  phaseCalGrd = fmod(phaseCalGrd + phaseCalGrdAmbig*2.5, phaseCalGrdAmbig) - 0.5*phaseCalGrdAmbig;
1278 // !
1279 // !
1280 // ! FIND PHASE DELAY EFFECT IN NANOSECONDS.
1281 // ! P is the best estimate for the fringe phase at RFMIN
1282 // ! i.e. P = < phase(F) - gpdly * (F-RFMIN) >
1283 // ! where phase(F) =observed phasecal phase at frequency F.
1284 // ! But we want the phase at REFFR, which may not = RFMIN
1285 // !
1286 // PCPHA = ((P)/TWOPI)*PHAMB + (REFFR-RFMIN)*0.001D0*PCGRP
1287  phaseCalPhd = dP/(2.0*M_PI)*phaseCalPhdAmbig + (refFreq - rfMin)*1.0e-3*phaseCalGrd;
1288 
1289 //std::cout
1290 //<< " -- dP=" << dP << " "
1291 //<< " phaseCalPhdAmbig=" << phaseCalPhdAmbig << " "
1292 //<< " refFreq=" << refFreq << " "
1293 //<< " rfMin=" << rfMin << " "
1294 //<< " phaseCalGrd=" << phaseCalGrd << " \n";
1295 
1296 
1297  // will add the rest later, when/if need it:
1298 // !
1299 // ! CALCULATE RESIDUAL PHASES
1300 // !
1301 // AWOPI=TWOPI
1302 // DO I=1,NFREQ
1303 // !XX AA=IELEM(I)
1304 // FFF=(RFREQ(I)-RFMIN)*0.001D0
1305 // CPP=DCOS( AWOPI*FFF*(PCGRP-0.5D0*GPAMB))
1306 // SPP=DSIN( AWOPI*FFF*(PCGRP-0.5D0*GPAMB))
1307 // CDD(I)=CDD(I)*DCMPLX(CPP,SPP)
1308 // ENDDO
1309 // !
1310 // !
1311 // ! AVERAGE THE VECTORS AND TAKE OUT THE MEAN PHASE
1312 // !
1313 // SUMR=0.D0
1314 // SUMI=0.D0
1315 // DO I=1,NFREQ
1316 // SUMR=SUMR+DREAL(CDD(I))
1317 // SUMI=SUMI+DIMAG(CDD(I))
1318 // ENDDO
1319 // !
1320 // DO I=1,NFREQ
1321 // CDD(I)=CDD(I)*DCMPLX(-SUMR,-SUMI)
1322 // PHRES(I)=DATAN2(DIMAG(CDD(I)),DREAL(CDD(I)))
1323 // ENDDO
1324 // !
1325 // ! ALL IS DONE. GO HOME.
1326 // !
1327 // IERR = 0
1328 // RETURN
1329 // END
1330 //--
1331  delete[] idxs;
1332  delete[] pX;
1333  delete[] pY;
1334  delete[] pXsvd;
1335  delete[] pYsvd;
1336  return true;
1337 };
1338 
1339 
1340 
1341 
1342 // just translation of $MK5_ROOT/progs/dbcal/parab.f from FORTRAN to C:
1343 // SUBROUTINE PARAB (CXD, N, D, A, P)
1344 void subroutineParab(const double* pX, const double* pY, int n, double &dD, double &dA, double &dP)
1345 {
1346 // !
1347 // !***Modifications:
1348 // ! 91.09.25 Darin Miller Converted all variables to Double
1349 // ! Precision.
1350 // ! 92.07.27 Brent Archinal "(1)" dimensions => "(*)".
1351 // ! 93.02.10 MSW General cleanup.
1352 // !
1353 // !***Flow chart for PARAB:
1354 // ! DBCAL|
1355 // ! |-> PUTDA|
1356 // ! |-> PUPCL|
1357 // ! |-> PCCLC|
1358 // ! |-> PARAB
1359 // !
1360 // IMPLICIT NONE
1361 // !
1362 // COMPLEX*16 CXD(*)
1363 // REAL*8 A, D, P
1364 // REAL*8 P1, P2, P3, A1, A2, A3 ! PHASE, AMP AT MAX CHANNELS
1365  double dP1, dP2, dP3, dA1, dA2, dA3;
1366 // REAL*8 PI, DREL, AA, AMAX
1367  double dDrel, dAa, dAmax;
1368 // INTEGER*4 I1, I2, I3, I, N
1369  int nI1=0, nI2=0, nI3=0;
1370 // !
1371 // ! GIVEN A COMPLEX ARRAY CXD, FIND THE POSITION WITH
1372 // ! MAXIMAL AMPLITUDE, AND THE AMP AND PHASE AT THAT POSITION.
1373 // ! FIRST, FIND THE CELL WITH HIGHEST AMPLITUDE.
1374 // ! SUBROUTINE PERFORMS PARABOLIC INTERPOLATION WITH CELL ON
1375 // ! EITHER SIDE OF MAX, TO OBTAIN REFINED ESTIMATE OF
1376 // ! POSITION AND AMPLITUDE AT MAX, AND DOES A LINEAR INTERPOLATION
1377 // ! TO OBTAIN THE PHASE OF CDD AT THE POSITION OF MAXIMUM AMP.
1378 // !
1379 // ! THE CHANNEL OF HIGHEST AMP CORRESPONDS TO THE LAG CHANNEL
1380 // ! WITH HIGHEST AUTOCORRELATION. THE REFINED ESTIMATE
1381 // ! IS OUR GROUP DELAY, IN UNITS GPAMB/N. THE PHASE AT
1382 // ! THIS LAG IS THE PHASE OFFSET (AT ZERO FREQ?, RFMIN?,REFFR?)
1383 // ! (I THINK; MAY????).
1384 // ! THUS, THE TOTAL PHASE IS
1385 // ! PTOT = P + TWOPI * FREQ * GPAMB * (DD-1)/N
1386 // !
1387 // ! SEARCH FOR MAX AMP
1388 // !
1389 // AMAX=-1000.D0
1390 // DO I=1,N
1391 // AA=CDABS(CXD(I))
1392 // IF (AA.LT.AMAX) GO TO 1
1393 // AMAX=AA
1394 // I2=I
1395 // A2=AMAX
1396 // 1 CONTINUE
1397 // ENDDO
1398  dA2 = dAmax = -1000.0;
1399  for (int i=0; i<n; i++)
1400  {
1401  dAa = hypot(pX[i], pY[i]);
1402  if (dAa >= dAmax)
1403  {
1404  dAmax = dAa;
1405  nI2 = i;
1406  dA2 = dAmax;
1407  };
1408  };
1409 // I1=I2-1
1410 // IF (I1.LT.1) I1=I1+N
1411 // I3=I2+1
1412 // IF (I3.GT.N) I3=I3-N
1413 // A1=CDABS(CXD(I1))
1414 // A3=CDABS(CXD(I3))
1415  nI1 = nI2 - 1;
1416  if (nI1 < 0)
1417  nI1 = nI1 + n;
1418  nI3 = nI2 + 1;
1419  if (nI3 >= n)
1420  nI3 = nI3 - n;
1421  dA1 = hypot(pX[nI1], pY[nI1]);
1422  dA3 = hypot(pX[nI3], pY[nI3]);
1423 // !
1424 // ! POSITION OF MAXIMUM
1425 // ! (in cells, relative to I2)
1426 // !
1427 // DREL=(A3-A1)/(2.D0*(2.D0*A2-A1-A3))
1428 // IF (DREL.GT. 1.D0) DREL=1.D0
1429 // IF (DREL.LT.-1.D0) DREL=-1.D0
1430 // AA=I2
1431 // D=AA+DREL
1432  dDrel = (dA3 - dA1)/(2.0*(2.0*dA2 - dA1 - dA3));
1433  if (dDrel > 1.0)
1434  dDrel = 1.0;
1435  if (dDrel < -1.0)
1436  dDrel = -1.0;
1437  dAa = nI2; // wtf??
1438  dD = dAa + dDrel;
1439 // !
1440 // ! AMPLITUDE AT MAXIMUM
1441 // ! (THIS IS EXACT QUADRATIC FIT!)
1442 // !
1443 // A=A2+DREL*(A3-A1)/4.D0
1444  dA = dA2 + dDrel*(dA3 - dA1)/4.0;
1445 // !
1446 // ! PHASE AT MAXIMUM (POSSIBLE PROBLEM HERE IF PHASE CROSSES
1447 // ! TWOPI IN THE RANGE P1-P3)
1448 // !
1449 // !***Warning generated in compilation: "Argument has same name as
1450 // !***INTRINSIC function" for following statements.
1451 // !
1452 // P1=DATAN2(DIMAG(CXD(I1)),DREAL(CXD(I1)))
1453 // P2=DATAN2(DIMAG(CXD(I2)),DREAL(CXD(I2)))
1454 // P3=DATAN2(DIMAG(CXD(I3)),DREAL(CXD(I3)))
1455  dP1 = atan2(pY[nI1], pX[nI1]);
1456  dP2 = atan2(pY[nI2], pX[nI2]);
1457  dP3 = atan2(pY[nI3], pX[nI3]);
1458 // !
1459 // ! (BETTER FIXUP FOR PHASE AMBIGUITY PROBLEM)
1460 // !
1461 // PI = 3.14159265358979323846264338328D0
1462 // IF (DABS(P1-P2).GE.PI .OR. DABS(P2-P3).GE.PI ) THEN
1463 // P1 = P2 + DMOD( P1-P2 + 5.D0*PI, 2.D0*PI ) - PI
1464 // P3 = P2 + DMOD( P3-P2 + 5.D0*PI, 2.D0*PI ) - PI
1465 // ENDIF
1466  if (fabs(dP1-dP2)>=M_PI || fabs(dP2-dP3)>=M_PI)
1467  {
1468  dP1 = dP2 + fmod(dP1 - dP2 + 5.0*M_PI, 2.0*M_PI) - M_PI;
1469  dP3 = dP2 + fmod(dP3 - dP2 + 5.0*M_PI, 2.0*M_PI) - M_PI;
1470  };
1471 // !
1472 // P=P2
1473  dP = dP2;
1474 // ! IF (ABS(P2-0.5D0*(P3+P1)).GT.0.1D0) RETURN
1475 // P=P2 + 0.5D0*(P3-P1)*DREL + 0.5D0*(P3-P2-P2+P1)*DREL**2
1476  dP = dP2 + 0.5*(dP3 - dP1)*dDrel + 0.5*(dP3 - dP2 - dP2 + dP1)*dDrel*dDrel;
1477 // !
1478 // RETURN
1479 // END
1480  return;
1481 };
1482 
1483 
1484 
1485 
1486 /*=====================================================================================================*/
1487 //
1488 // statics:
1489 //
1490 /*=====================================================================================================*/
1491 
1492 
1493 
1494 
1495 /*=====================================================================================================*/
SgLogger * logger
Definition: SgLogger.cpp:231
const SgMJD tZero(1957, 10, 4)
void fft(std::complex< double > buf[], int n)
bool evaluatePhaseCals(const SgVector &pcPhases, const SgVector &pcAmplitudes, const SgVector &pcFreqByChan, double refFreq, double &phaseCalGrd, double &phaseCalGrdAmbig, double &phaseCalPhd, double &phaseCalPhdAmbig, const QString &oId)
void subroutineParab(const double *pX, const double *pY, int n, double &dD, double &dA, double &dP)
bool isAttr(uint a) const
Definition: SgAttribute.h:226
void setAttributes(unsigned int a)
Definition: SgAttribute.h:191
void clearAll()
Definition: SgAttribute.h:234
unsigned int getAttributes() const
Definition: SgAttribute.h:183
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
@ IO_DBH
Definition: SgLogger.h:67
@ PREPROC
Definition: SgLogger.h:98
Definition: SgMJD.h:59
@ F_YYYYMMDDHHMMSSSS
Long verbose: Fri, the 2nd of Apr, 2010; 17hr 02min 43.6400sec.
Definition: SgMJD.h:67
QString toString(Format format=F_Verbose) const
Definition: SgMJD.cpp:1007
double getElement(unsigned int i, unsigned int j) const
Definition: SgMatrix.h:385
unsigned int nCol() const
Definition: SgMatrix.h:360
const QString & getKey() const
Definition: SgObjectInfo.h:319
@ Attr_NOT_VALID
omit the observation;
Definition: SgObservation.h:78
bool getUseQualityCodeH() const
Definition: SgTaskConfig.h:833
VlbiDelayType getUseDelayType() const
Definition: SgTaskConfig.h:857
int getQualityCodeThreshold() const
Definition: SgTaskConfig.h:817
VlbiRateType getUseRateType() const
Definition: SgTaskConfig.h:865
bool getUseQualityCodeG() const
Definition: SgTaskConfig.h:825
unsigned int n() const
Definition: SgVector.h:327
void setElement(unsigned int i, double d)
Definition: SgVector.h:348
double getElement(unsigned int i) const
Definition: SgVector.h:362
double getParallacticAngle() const
int getMaxNumOfChannels() const
Definition: SgVlbiBand.h:392
@ Attr_USE_IONO4GRD
use ionosphere corrections for group delays;
@ Attr_USE_IONO4PHD
use ionosphere corrections for phase delays;
@ Attr_NOT_VALID
omit the baseline;
void setAmbiguitySpacing(double)
bool saveIntermediateResults(QDataStream &) const
double ambiguity() const
double getValue() const
bool loadIntermediateResults(QDataStream &)
double getSigma() const
SgVlbiSourceInfo * src_
bool saveIntermediateResults(QDataStream &) const
void releaseChannelsSetupStorages()
QVector< int > * corelIndexNumLSB()
QVector< int > * bbcIdxByChan_2_
double getPhaseCalPhDelays(int i) const
void setNumOfChannels(int)
double getUvFrPerAsec(int i) const
bool isRestorable_old(const SgTaskConfig *)
double getPhaseCalGrDelays(int i) const
void setBitsPerSample(int bps)
const SgMJD & epoch() const
double getSbdQ() const
SgMatrix * phaseCalData_1ByChan_
int getQualityFactor() const
void setGrdQ(double)
int phaseCalGrAmbigMultipliers_[2]
double getGrdQ() const
void setCorrClocks(int i, int j, double d)
void setTotalPhase(double)
void setHopsRevisionNumber(int num)
QVector< char > * chanIdByChan_
void setGrdDiffBand(double)
SgVlbiMeasurement phDelay_
SgVlbiStationInfo * getStn_1() const
void setPhaseCalGrDelays(int i, double d)
double getSampleRate() const
QVector< char > * polarization_1ByChan()
double getInstrDelay(int i) const
SgVector * loFreqByChan_1()
QVector< char > * chanIdByChan()
void setIncohSegmAddAmp(double d)
QVector< int > * corelIndexNumUSB()
double getFourfitSearchParameters(int i) const
double getTauS() const
int getNumOfChannels() const
void setupActiveMeasurements(const SgTaskConfig *)
SgVector * loFreqByChan_2_
void setPhaseCalModes(int modes)
SgMatrix * phaseCalData_2ByChan()
void setAcceptedRatio(double d)
const QString & getErrorCode() const
SgVlbiBand * band()
SgVector * fringeAmplitudeByChan_
double getSbdDiffBand() const
int getPhaseCalModes() const
double getIncohChanAddAmp() const
QVector< int > * bbcIdxByChan_1_
QVector< int > * corelIndexNumLSB_
SgVlbiObservation * owner()
double probabOfFalseDetection_
SgVlbiMeasurement sbDelay_
void setPhaseCalPhDelays(int i, double d)
SgVector * numOfSamplesByChan_USB_
void setPhrQ(double)
SgVector * numOfAccPeriodsByChan_LSB()
double getAcceptedRatio() const
void setIncohChanAddAmp(double d)
double getCalcFeedCorrDelay() const
SgVlbiObservable(SgVlbiObservation *)
SgVector * numOfSamplesByChan_LSB_
void setCentrOffset(double offset)
double getProbabOfFalseDetection() const
double getPhrDiffBand() const
void setEffIntegrationTime(double d)
QVector< char > * polarization_2ByChan()
SgVector * numOfAccPeriodsByChan_USB()
QVector< int > * bbcIdxByChan_1()
static const QString className()
SgVlbiStationInfo * getStn_2() const
SgVlbiSourceInfo * getSrc() const
double phaseCalPhDelays_[2]
void setGeocenterResidPhase(double d)
void setCorrelStarElev_2(double v)
double getGrdDiffBand() const
void setSnr(double)
void setProbabOfFalseDetection(double d)
void setQualityFactor(int)
double phaseCalRates_[2]
QString strId() const
int phaseCalPhAmbigMultipliers_[2]
double getCorrelZdelay_1() const
double getGeocenterTotalPhase() const
void setNlags(int n)
void setGeocenterTotalPhase(double d)
double getEffIntegrationTime() const
SgMatrix * phaseCalData_2ByChan_
void setDiscardRatio(double d)
double getCorrClocks(int i, int j) const
double phaseCalGrAmbigSpacings_[2]
SgVector * fringeAmplitudeByChan()
void setCorrCoeff(double)
SgVector * vAuxData()
double phaseCalGrDelays_[2]
SgVlbiBaselineInfo * baseline_
void setUrVr(int i, double d)
void setCorrelZdelay_1(double v)
int getStartOffset() const
QVector< char > * polarization_1ByChan_
SgVector * fringePhaseByChan_
SgVector * refFreqByChan_
void checkUsability(const SgTaskConfig *)
double getUrVr(int i) const
double getCentrOffset() const
int errorCode2Int() const
SgVector * numOfSamplesByChan_LSB()
QVector< int > * corelIndexNumUSB_
void setPhrDiffBand(double)
double getAprioriDra(int i) const
void setAprioriDra(int i, double d)
void setInstrDelay(int i, double d)
double getCorrelStarElev_2() const
double getDiscardRatio() const
void setPhaseCalRates(int i, double d)
int getNlags() const
double getTotalPhase() const
void setStopOffset(int offset)
SgVector * vDlys()
SgVlbiStationInfo * stn_2_
int getHopsRevisionNumber() const
int getFourfitVersion(int idx) const
double getIncohSegmAddAmp() const
int getStopOffset() const
void setUvFrPerAsec(int i, double d)
double getSnr() const
QVector< char > * polarization_2ByChan_
SgVector * numOfAccPeriodsByChan_LSB_
SgMatrix * phaseCalData_1ByChan()
SgVector * numOfSamplesByChan_USB()
SgVlbiBaselineInfo * getBaseline() const
void setReferenceFrequency(double)
double getPhaseCalRates(int i) const
void setCorrelZdelay_2(double v)
double getCalcFeedCorrRate() const
double getReferenceFrequency() const
void allocateChannelsSetupStorages(int numOfChans)
SgVlbiMeasurement * activeRate_
double getCorrelStarElev_1() const
bool loadIntermediateResults(QDataStream &)
SgVlbiMeasurement * activeDelay_
int getBitsPerSample() const
SgVlbiBand * band_
void setCalcFeedCorrDelay(double v)
double getCorrCoeff() const
SgVlbiMeasurement phDRate_
double fourfitSearchParameters_[6]
SgVector * loFreqByChan_2()
double phaseCalPhAmbigSpacings_[2]
SgVector * numOfAccPeriodsByChan_USB_
double corrClocks_[2][2]
void setStartOffset(int offset)
double getPhrQ() const
void setSbdDiffBand(double)
SgAttribute nonUsableReason_
SgVector * fringePhaseByChan()
double getGeocenterResidPhase() const
void setSbdQ(double)
SgVector * refFreqByChan()
void setFourfitSearchParameters(int i, double d)
SgVector * loFreqByChan_1_
void setSampleRate(double sr)
SgVlbiObservation * owner_
int getMediaIdx() const
void setCorrelStarElev_1(double v)
void setCalcFeedCorrRate(double v)
QVector< int > * bbcIdxByChan_2()
SgVlbiStationInfo * stn_1_
double getCorrelZdelay_2() const
SgVlbiMeasurement grDelay_
@ Attr_SBD_NOT_VALID
omit the observation if single band delay is analysed;
SgVlbiStationInfo * stn_1()
SgVlbiAuxObservation * auxObs_2()
SgVlbiSession * session()
SgVlbiSourceInfo * src()
SgVlbiBaselineInfo * baseline()
QList< SgVlbiObservable * > & passiveObses()
short int getSourceIdx() const
SgVlbiStationInfo * stn_2()
int minQualityFactor() const
const QString & getScanName() const
QMap< QString, SgVlbiObservable * > & observableByKey()
SgVlbiAuxObservation * auxObs_1()
short int getBaselineIdx() const
@ Attr_HAS_IONO_CORR
the theoretical values are available;
QList< SgVlbiBand * > & bands()
SgVlbiSourceInfo * lookupSourceByIdx(int)
SgVlbiBaselineInfo * lookupBaselineByIdx(int)
@ Attr_NOT_VALID
omit the source;
@ Attr_NOT_VALID
omit the station;