General Purpose Geodetic Library
SgGuiTaskConfig.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 
24 
25 
26 
27 #include <SgGuiTaskConfig.h>
28 #include <SgGuiParameterCfg.h>
29 #include <SgLogger.h>
30 #include <SgVlbiBand.h>
31 #include <SgVlbiNetworkId.h>
32 
33 
34 #if QT_VERSION >= 0x050000
35 # include <QtWidgets/QBoxLayout>
36 # include <QtWidgets/QButtonGroup>
37 # include <QtWidgets/QCheckBox>
38 # include <QtWidgets/QComboBox>
39 # include <QtWidgets/QFrame>
40 # include <QtWidgets/QGroupBox>
41 # include <QtWidgets/QHeaderView>
42 # include <QtWidgets/QLabel>
43 # include <QtWidgets/QLineEdit>
44 # include <QtWidgets/QMessageBox>
45 # include <QtWidgets/QPushButton>
46 # include <QtWidgets/QRadioButton>
47 # include <QtWidgets/QSpinBox>
48 #else
49 # include <QtGui/QBoxLayout>
50 # include <QtGui/QButtonGroup>
51 # include <QtGui/QCheckBox>
52 # include <QtGui/QComboBox>
53 # include <QtGui/QFrame>
54 # include <QtGui/QGroupBox>
55 # include <QtGui/QHeaderView>
56 # include <QtGui/QLabel>
57 # include <QtGui/QLineEdit>
58 # include <QtGui/QMessageBox>
59 # include <QtGui/QPushButton>
60 # include <QtGui/QRadioButton>
61 # include <QtGui/QSpinBox>
62 #endif
63 
64 
65 
66 
67 
68 
69 
70 
71 /*=======================================================================================================
72 *
73 * SgGuiTaskConfig's METHODS:
74 *
75 *======================================================================================================*/
76 //
78  SgVlbiSession* session, QWidget* parent, Qt::WindowFlags f)
79  : QWidget(parent, f),
80  ratTypeButtons_()
81 {
82  //
83  config_ = config;
85  session_ = session;
86 
88 
89  QTabWidget *tabs = new QTabWidget (this);
90  QBoxLayout *layout=new QVBoxLayout(this);
91  tabs->addTab((tabGeneralOptions_=makeTab4GeneralOptions()), "General");
92  tabs->addTab((tabOperations_=makeTab4Operations()), "Operation");
93  tabs->addTab((tabModels_=makeTab4models()), "External a priori and models");
94  if (session_==NULL)
95  tabs->addTab((tabPia_=makeTab4pia()), "Post import actions");
96  else
97  {
98  tabs->setCurrentWidget(tabOperations_);
99  tabs->setTabPosition(QTabWidget::North);
100 // tabs->setTabPosition(QTabWidget::South);
101  };
102  layout->addWidget(tabs);
103  // adjust status of stoch.parameters:
105  for (int i=0; i<stcParsButtons_.size(); i++)
106  stcParsButtons_.at(i)->setEnabled(false);
107  //
108  tweUserCorrections_ = NULL;
109 };
110 
111 
112 
113 //
115 {
116  // consts:
117  // observables:
118  static const QString delayTypeNames[] =
119  { QString("None"),
120  QString("Single band"),
121  QString("Group"),
122  QString("Phase")};
123  static const QString rateTypeNames[] =
124  { QString("None"),
125  QString("Phase")};
126  static const int numOfDelayTypes = sizeof(delayTypeNames)/sizeof(QString);
127  static const int numOfRateTypes = sizeof(rateTypeNames)/sizeof(QString);
128 
129  QWidget *w=new QWidget(this);
130  QGroupBox *gbox;
131  QCheckBox *cb;
132  QBoxLayout *mainLayout;
133  QBoxLayout *layout;
134  QBoxLayout *aLayout;
135 
136  mainLayout = new QVBoxLayout(w);
137  layout = new QHBoxLayout;
138  mainLayout->addLayout(layout);
139  //
140  // delays:
141  QRadioButton *rbDelTypes[numOfDelayTypes];
142  gbox = new QGroupBox("Delay type:", w);
143  aLayout = new QVBoxLayout(gbox);
144  bgDelTypes_ = new QButtonGroup(gbox);
145  for (int i=0; i<numOfDelayTypes; i++)
146  {
147  rbDelTypes[i] = new QRadioButton(delayTypeNames[i], gbox);
148  rbDelTypes[i]-> setMinimumSize(rbDelTypes[i]->sizeHint());
149  bgDelTypes_->addButton(rbDelTypes[i], i);
150  aLayout->addWidget(rbDelTypes[i]);
151  };
152  rbDelTypes[config_->getUseDelayType()]->setChecked(true);
153  connect(bgDelTypes_, SIGNAL(buttonClicked(int)), SLOT(modifyDelayType(int)));
154  layout->addWidget(gbox);
155  //
156  // rates:
157  QRadioButton *rbRatTypes[numOfRateTypes];
158  gbox = new QGroupBox("Rate type:", w);
159  aLayout = new QVBoxLayout(gbox);
160  aLayout->addStretch(1);
161  bgRatTypes_ = new QButtonGroup(gbox);
162  for (int i=0; i<numOfRateTypes; i++)
163  {
164  rbRatTypes[i] = new QRadioButton(rateTypeNames[i], gbox);
165  rbRatTypes[i]-> setMinimumSize(rbRatTypes[i]->sizeHint());
166  bgRatTypes_->addButton(rbRatTypes[i], i);
167  aLayout->addWidget(rbRatTypes[i]);
168  ratTypeButtons_ << rbRatTypes[i];
169  };
170  aLayout->addStretch(1);
171  rbRatTypes[config_->getUseRateType()]->setChecked(true);
172  connect(bgRatTypes_, SIGNAL(buttonClicked(int)), SLOT(modifyRateType(int)));
173  layout->addWidget(gbox);
174  //
175  // bands:
176  if (session_ && session_->bands().size())
177  {
178  QRadioButton *rbBands[session_->bands().size()];
179  gbox = new QGroupBox("Band:", w);
180  aLayout = new QVBoxLayout(gbox);
181  bgBands_ = new QButtonGroup(gbox);
182  for (int i=0; i<session_->bands().size(); i++)
183  {
184  rbBands[i] = new QRadioButton(session_->bands().at(i)->getKey() + "-Band", gbox);
185  rbBands[i]-> setMinimumSize(rbBands[i]->sizeHint());
186  bgBands_->addButton(rbBands[i], i);
187  aLayout->addWidget(rbBands[i]);
188  };
189  rbBands[0]->setChecked(true);
190  connect(bgBands_, SIGNAL(buttonClicked(int)), SLOT(band2UseModified(int)));
191  layout->addWidget(gbox);
192  };
193  //
194  //
195  // GUI interaction:
196  gbox = new QGroupBox("Interactions with GUI:", w);
197  aLayout = new QVBoxLayout(gbox);
198  // Active band:
199  cb = new QCheckBox("Active band follows tab", gbox);
200  cb->setCheckState(config_->getIsActiveBandFollowsTab()?Qt::Checked:Qt::Unchecked);
201  aLayout->addWidget(cb);
202  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeGUI_activeBand(int)));
204  // Active Observable:
205  cb = new QCheckBox("Observable follows plot", gbox);
206  cb->setCheckState(config_->getIsObservableFollowsPlot()?Qt::Checked:Qt::Unchecked);
207  aLayout->addWidget(cb);
208  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeGUI_observable(int)));
210  //
211  mainLayout->addWidget(gbox);
212  //
213  //
214  // QC threshold:
215  aLayout = new QHBoxLayout;
216  mainLayout->addLayout(aLayout);
217  aLayout->addWidget(new QLabel("Observation Quality Code threshold (use obs of this code or higher):",
218  w));
219  sbQualityCodeThreshold_ = new QSpinBox(w);
221  sbQualityCodeThreshold_->setRange(0, 10);
222 // sbQualityCodeThreshold_->setMaximum(10);
223  connect(sbQualityCodeThreshold_, SIGNAL(valueChanged(int)),
224  SLOT (qualityCodeThresholdModified(int)));
225  aLayout->addStretch(1);
226  aLayout->addWidget(sbQualityCodeThreshold_);
227  //
228  // G-codes:
229  cb = new QCheckBox("Use observations with `G' error code", w);
230  cb->setCheckState(config_->getUseQualityCodeG()?Qt::Checked:Qt::Unchecked);
231  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeUseQualityCodeG(int)));
232  mainLayout->addWidget(cb);
233  cbUseQualityCodeG_ = cb;
234  //
235  // H-codes:
236  cb = new QCheckBox("Use observations with `H' error code", w);
237  cb->setCheckState(config_->getUseQualityCodeH()?Qt::Checked:Qt::Unchecked);
238  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeUseQualityCodeH(int)));
239  mainLayout->addWidget(cb);
240  cbUseQualityCodeH_ = cb;
241  //
242  //
243  // Compatibility:
244  cb = new QCheckBox("Interactive SOLVE compatible mode", w);
245  cb->setCheckState(config_->getIsSolveCompatible()?Qt::Checked:Qt::Unchecked);
246  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeCompatibility(int)));
247  mainLayout->addWidget(cb);
249  // dynamic clock breaks:
250  cb = new QCheckBox("Estimate clock break parameters in common solution", w);
251  cb->setCheckState(config_->getUseDynamicClockBreaks()?Qt::Checked:Qt::Unchecked);
252  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeDynamicClockBreaks(int)));
253  mainLayout->addWidget(cb);
255  //
256  //
257  cb = new QCheckBox("Use SOLVE's observation elimination flags", w);
258  cb->setCheckState(config_->getUseSolveObsSuppresionFlags()?Qt::Checked:Qt::Unchecked);
259  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeCompat_UseSolveElimFlags(int)));
260  mainLayout->addWidget(cb);
262  //
263  //
264  aLayout = new QHBoxLayout;
265  mainLayout->addLayout(aLayout);
266  cb = new QCheckBox("Initially use observations with Quality Code of or higher: ", w);
267  cb->setCheckState(config_->getUseGoodQualityCodeAtStartup()?Qt::Checked:Qt::Unchecked);
268  aLayout->addWidget(cb);
269  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeUseGoodQualityCodeAtStartup(int)));
271  // QC threshold:
272  sbGoodQualityCodeAtStartup_ = new QSpinBox(w);
274  sbGoodQualityCodeAtStartup_->setRange(0, 10);
275 // sbGoodQualityCodeAtStartup_->setMaximum(10);
276  //
277  connect(sbGoodQualityCodeAtStartup_, SIGNAL(valueChanged(int)),
279  aLayout->addStretch(1);
280  aLayout->addWidget(sbGoodQualityCodeAtStartup_);
281  //
282  //
283  // Novice mode:
284  cb = new QCheckBox("Novice user mode", w);
285  cb->setCheckState(config_->getIsNoviceUser()?Qt::Checked:Qt::Unchecked);
286  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeIsNoviceUser(int)));
287  cbIsNoviceUser_ = cb;
288  mainLayout->addWidget(cb);
289  //
290  // Have to make output of a covariance matrix:
291  cb = new QCheckBox("Make output of a covariance matrix in an ASCII file", w);
292  cb->setCheckState(config_->getHave2outputCovarMatrix()?Qt::Checked:Qt::Unchecked);
293  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeHave2outputCovarMatrix(int)));
295  mainLayout->addWidget(cb);
296  //
297  //
298  mainLayout->addStretch(1);
299  //
300  // 4tests:
301  cb = new QCheckBox("Testing (for test purposes only)", w);
302  cb->setCheckState(config_->getIsTesting()?Qt::Checked:Qt::Unchecked);
303  connect(cb, SIGNAL(stateChanged(int)), SLOT(changeIsTesting(int)));
304  cbIsTesting_ = cb;
305  mainLayout->addWidget(cb);
306  mainLayout->addStretch(1);
307  //
308  return w;
309 };
310 
311 
312 
313 //
315 {
316  static const QString parTypeName[] =
317  { QString("No"),
318  QString("Lcl"),
319  QString("Arc"),
320  QString("Pwl"),
321  QString("Stc") };
322  static const int numOfParTypeNames = sizeof(parTypeName)/sizeof(QString);
323  static const QString parKindName[] =
324  { QString("Clocks"),
325  QString("Zenith delay"),
326  QString("Atm gradients"),
327  QString("Station coords"),
328  QString("Axis offsets"),
329  QString("Source coords"),
330  QString("Source structure model"),
331  QString("PM"),
332  QString("PM rates"),
333  QString("dUT1"),
334  QString("dUT1 rate"),
335  QString("Nutation angles"),
336  QString("Baseline clocks"),
337  QString("Baseline vector"),
338  QString("Test") };
339  static const int numOfParKindNames = sizeof(parKindName)/sizeof(QString);
340  static const QString estimatorPwlModeNames[] =
341  { QString("Incremental rates"),
342  QString("B-Splines: linear"),
343  QString("B-Splines: quadratic") };
344  static const int numOfEstimatorPwlModes = sizeof(estimatorPwlModeNames)/sizeof(QString);
345  static const QString reweightingModeNames[] =
346  { QString("Band-wide"),
347  QString("Baseline dependent") };
348  static const int numOfReweightingModes = sizeof(reweightingModeNames)/sizeof(QString);
349  // outliers processing:
350  static const QString outliersProcessingModeNames[] =
351  { QString("Band-wide"),
352  QString("Baseline dependent") };
353  static const int numOfOutliersProcessingModes = sizeof(outliersProcessingModeNames)/sizeof(QString);
354  static const QString outliersProcessingActionNames[] =
355  { QString("Elimination"),
356  QString("Restoration") };
357  static const int numOfOutliersProcessingActions = sizeof(outliersProcessingActionNames)/sizeof(QString);
358  //
359  //
360 
361  QGroupBox *gbox;
362  QWidget *w=new QWidget(this);
363  QBoxLayout *mainLayout=new QHBoxLayout(w);
364  QBoxLayout *layout;
365  QBoxLayout *aLayout;
366  QGridLayout *grid;
367 
368  layout = new QVBoxLayout;
369  mainLayout->addLayout(layout);
370 
371  //
372  // left part:
373  gbox = new QGroupBox("Parameters to estimate:", w);
374  grid = new QGridLayout(gbox);
375  // Qt::AlignHCenter
376  // Qt::AlignCenter
377  // parameter types:
378  for (int i=0; i<numOfParTypeNames; i++)
379  grid->addWidget(new QLabel(parTypeName[i], gbox), 0, i+1, Qt::AlignHCenter);
380  for (int i=0; i<numOfParKindNames; i++)
381  grid->addWidget(new QLabel(parKindName[i], gbox), i+1, 0, Qt::AlignLeft | Qt::AlignVCenter);
382  //
383  QRadioButton *rbParameters[5];
384  //
385  // clocks:
386  bgClocks_ = new QButtonGroup(gbox);
387  for (int i=0; i<5; i++)
388  {
389  rbParameters[i] = new QRadioButton(gbox);
390  bgClocks_->addButton(rbParameters[i], i);
391  grid->addWidget(rbParameters[i], 1, 1+i, Qt::AlignHCenter);
392  };
393  stcParsButtons_ << rbParameters[4];
394  connect(bgClocks_, SIGNAL(buttonClicked(int)), SLOT(paramaters4ClocksModified(int)));
395 
396  // zenith delays:
397  bgZenith_ = new QButtonGroup(gbox);
398  for (int i=0; i<5; i++)
399  {
400  rbParameters[i] = new QRadioButton(gbox);
401  bgZenith_->addButton(rbParameters[i], i);
402  grid->addWidget(rbParameters[i], 2, 1+i, Qt::AlignHCenter);
403  };
404  stcParsButtons_ << rbParameters[4];
405  connect(bgZenith_, SIGNAL(buttonClicked(int)), SLOT(paramaters4ZenithModified(int)));
406 
407  // atmospheric gradients::
408  bgAtmGrads_ = new QButtonGroup(gbox);
409  for (int i=0; i<5; i++)
410  {
411  rbParameters[i] = new QRadioButton(gbox);
412  bgAtmGrads_->addButton(rbParameters[i], i);
413  grid->addWidget(rbParameters[i], 3, 1+i, Qt::AlignHCenter);
414  };
415  stcParsButtons_ << rbParameters[4];
416  connect(bgAtmGrads_, SIGNAL(buttonClicked(int)), SLOT(paramaters4AtmGrdModified(int)));
417 
418  // station coords:
419  bgStnCoord_ = new QButtonGroup(gbox);
420  for (int i=0; i<5; i++)
421  {
422  rbParameters[i] = new QRadioButton(gbox);
423  bgStnCoord_->addButton(rbParameters[i], i);
424  grid->addWidget(rbParameters[i], 4, 1+i, Qt::AlignHCenter);
425  };
426  stcParsButtons_ << rbParameters[4];
427  connect(bgStnCoord_, SIGNAL(buttonClicked(int)), SLOT(paramaters4StnPosModified(int)));
428 
429  // axis offset:
430  bgAxsOffset_ = new QButtonGroup(gbox);
431  for (int i=0; i<5; i++)
432  {
433  rbParameters[i] = new QRadioButton(gbox);
434  bgAxsOffset_->addButton(rbParameters[i], i);
435  grid->addWidget(rbParameters[i], 5, 1+i, Qt::AlignHCenter);
436  };
437  stcParsButtons_ << rbParameters[4];
438  connect(bgAxsOffset_, SIGNAL(buttonClicked(int)), SLOT(paramaters4AxsOfsModified(int)));
439 
440  // source coords:
441  bgSrcCoord_ = new QButtonGroup(gbox);
442  for (int i=0; i<5; i++)
443  {
444  rbParameters[i] = new QRadioButton(gbox);
445  bgSrcCoord_->addButton(rbParameters[i], i);
446  grid->addWidget(rbParameters[i], 6, 1+i, Qt::AlignHCenter);
447  };
448  stcParsButtons_ << rbParameters[4];
449  connect(bgSrcCoord_, SIGNAL(buttonClicked(int)), SLOT(paramaters4SrcPosModified(int)));
450 
451  // source structure model:
452  bgSrcSsm_ = new QButtonGroup(gbox);
453  for (int i=0; i<5; i++)
454  {
455  rbParameters[i] = new QRadioButton(gbox);
456  bgSrcSsm_->addButton(rbParameters[i], i);
457  grid->addWidget(rbParameters[i], 7, 1+i, Qt::AlignHCenter);
458  };
459  stcParsButtons_ << rbParameters[4];
460  connect(bgSrcSsm_, SIGNAL(buttonClicked(int)), SLOT(paramaters4SrcSsmModified(int)));
461 
462  // Polar Motion:
463  bgEopPm_ = new QButtonGroup(gbox);
464  for (int i=0; i<5; i++)
465  {
466  rbParameters[i] = new QRadioButton(gbox);
467  bgEopPm_->addButton(rbParameters[i], i);
468  grid->addWidget(rbParameters[i], 8, 1+i, Qt::AlignHCenter);
469  };
470  stcParsButtons_ << rbParameters[4];
471  connect(bgEopPm_, SIGNAL(buttonClicked(int)), SLOT(paramaters4EopPolarMotionModified(int)));
472 
473  // Polar Motion Rate:
474  bgEopPmRate_ = new QButtonGroup(gbox);
475  for (int i=0; i<5; i++)
476  {
477  rbParameters[i] = new QRadioButton(gbox);
478  bgEopPmRate_->addButton(rbParameters[i], i);
479  grid->addWidget(rbParameters[i], 9, 1+i, Qt::AlignHCenter);
480  };
481  stcParsButtons_ << rbParameters[4];
482  connect(bgEopPmRate_, SIGNAL(buttonClicked(int)), SLOT(paramaters4EopPolarMotionRateModified(int)));
483 
484  // Earth rotation:
485  bgEopUt_ = new QButtonGroup(gbox);
486  for (int i=0; i<5; i++)
487  {
488  rbParameters[i] = new QRadioButton(gbox);
489  bgEopUt_->addButton(rbParameters[i], i);
490  grid->addWidget(rbParameters[i], 10, 1+i, Qt::AlignHCenter);
491  };
492  stcParsButtons_ << rbParameters[4];
493  connect(bgEopUt_, SIGNAL(buttonClicked(int)), SLOT(paramaters4EopUt1Modified(int)));
494 
495  // Earth rotation rate:
496  bgEopUtRate_ = new QButtonGroup(gbox);
497  for (int i=0; i<5; i++)
498  {
499  rbParameters[i] = new QRadioButton(gbox);
500  bgEopUtRate_->addButton(rbParameters[i], i);
501  grid->addWidget(rbParameters[i], 11, 1+i, Qt::AlignHCenter);
502  };
503  stcParsButtons_ << rbParameters[4];
504  connect(bgEopUtRate_, SIGNAL(buttonClicked(int)), SLOT(paramaters4EopUt1RateModified(int)));
505 
506  // Nutation angles:
507  bgEopNut_ = new QButtonGroup(gbox);
508  for (int i=0; i<5; i++)
509  {
510  rbParameters[i] = new QRadioButton(gbox);
511  bgEopNut_->addButton(rbParameters[i], i);
512  grid->addWidget(rbParameters[i], 12, 1+i, Qt::AlignHCenter);
513  };
514  stcParsButtons_ << rbParameters[4];
515  connect(bgEopNut_, SIGNAL(buttonClicked(int)), SLOT(paramaters4EopNutationModified(int)));
516 
517  // Baseline clock offsets:
518  bgBlnClock_ = new QButtonGroup(gbox);
519  for (int i=0; i<5; i++)
520  {
521  rbParameters[i] = new QRadioButton(gbox);
522  bgBlnClock_->addButton(rbParameters[i], i);
523  grid->addWidget(rbParameters[i], 13, 1+i, Qt::AlignHCenter);
524  };
525  stcParsButtons_ << rbParameters[4];
526  connect(bgBlnClock_, SIGNAL(buttonClicked(int)), SLOT(paramaters4BlnClockModified(int)));
527 
528  // Baseline vector:
529  bgBlnVector_ = new QButtonGroup(gbox);
530  for (int i=0; i<5; i++)
531  {
532  rbParameters[i] = new QRadioButton(gbox);
533  bgBlnVector_->addButton(rbParameters[i], i);
534  grid->addWidget(rbParameters[i], 14, 1+i, Qt::AlignHCenter);
535  };
536  stcParsButtons_ << rbParameters[4];
537  connect(bgBlnVector_, SIGNAL(buttonClicked(int)), SLOT(paramaters4BlnLengthModified(int)));
538 
539  // Test purposes:
540  bgTest_ = new QButtonGroup(gbox);
541  for (int i=0; i<5; i++)
542  {
543  rbParameters[i] = new QRadioButton(gbox);
544  bgTest_->addButton(rbParameters[i], i);
545  grid->addWidget(rbParameters[i], 15, 1+i, Qt::AlignHCenter);
546  };
547  stcParsButtons_ << rbParameters[4];
548  connect(bgTest_, SIGNAL(buttonClicked(int)), SLOT(paramaters4TestModified(int)));
549  //
550  //
551  // end of initializations, display the parameterization:
553  //
554  for (int i=0; i<stcParsButtons_.size(); i++)
555  connect(stcParsButtons_.at(i), SIGNAL(toggled(bool)), SLOT(checkStcParChackBoxesStatus(bool)));
556  //
557  //
558  QPushButton *pushButton;
559  int l;
560  // clocks:
561  pushButton = new QPushButton("Edit", gbox);
562  pushButton->setFixedWidth((l=3*pushButton->fontMetrics().width("Edit")));
563  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4Clocks()));
564  grid->addWidget(pushButton, 1, 6, Qt::AlignHCenter);
565  // zenith delay:
566  pushButton = new QPushButton("Edit", gbox);
567  pushButton->setFixedWidth(l);
568  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4Zenith()));
569  grid->addWidget(pushButton, 2, 6, Qt::AlignHCenter);
570  // atm grads:
571  pushButton = new QPushButton("Edit", gbox);
572  pushButton->setFixedWidth(l);
573  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4AtmGrd()));
574  grid->addWidget(pushButton, 3, 6, Qt::AlignHCenter);
575  // stations positions:
576  pushButton = new QPushButton("Edit", gbox);
577  pushButton->setFixedWidth(l);
578  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4StnPos()));
579  grid->addWidget(pushButton, 4, 6, Qt::AlignHCenter);
580  // axis offset:
581  pushButton = new QPushButton("Edit", gbox);
582  pushButton->setFixedWidth(l);
583  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4AxsOfs()));
584  grid->addWidget(pushButton, 5, 6, Qt::AlignHCenter);
585  // sources positions:
586  pushButton = new QPushButton("Edit", gbox);
587  pushButton->setFixedWidth(l);
588  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4SrcPos()));
589  grid->addWidget(pushButton, 6, 6, Qt::AlignHCenter);
590  // sources structure model:
591  pushButton = new QPushButton("Edit", gbox);
592  pushButton->setFixedWidth(l);
593  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4SrcSsm()));
594  grid->addWidget(pushButton, 7, 6, Qt::AlignHCenter);
595  // EOP, polar motion:
596  pushButton = new QPushButton("Edit", gbox);
597  pushButton->setFixedWidth(l);
598  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4EopPolar()));
599  grid->addWidget(pushButton, 8, 6, Qt::AlignHCenter);
600  // EOP, polar motion rates:
601  pushButton = new QPushButton("Edit", gbox);
602  pushButton->setFixedWidth(l);
603  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4EopPolarRate()));
604  grid->addWidget(pushButton, 9, 6, Qt::AlignHCenter);
605  // EOP, Earth rotation:
606  pushButton = new QPushButton("Edit", gbox);
607  pushButton->setFixedWidth(l);
608  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4EopUt1()));
609  grid->addWidget(pushButton,10, 6, Qt::AlignHCenter);
610  // EOP, Earth rotation rate:
611  pushButton = new QPushButton("Edit", gbox);
612  pushButton->setFixedWidth(l);
613  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4EopUt1Rate()));
614  grid->addWidget(pushButton,11, 6, Qt::AlignHCenter);
615  // EOP, nutation angles:
616  pushButton = new QPushButton("Edit", gbox);
617  pushButton->setFixedWidth(l);
618  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4EopNutation()));
619  grid->addWidget(pushButton,12, 6, Qt::AlignHCenter);
620  // Baselines, clock offsets:
621  pushButton = new QPushButton("Edit", gbox);
622  pushButton->setFixedWidth(l);
623  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4BlnClock()));
624  grid->addWidget(pushButton,13, 6, Qt::AlignHCenter);
625  // Baselines, vector of the baseline:
626  pushButton = new QPushButton("Edit", gbox);
627  pushButton->setFixedWidth(l);
628  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4BlnLength()));
629  grid->addWidget(pushButton,14, 6, Qt::AlignHCenter);
630  // Test purposes:
631  pushButton = new QPushButton("Edit", gbox);
632  pushButton->setFixedWidth(l);
633  connect(pushButton, SIGNAL(clicked()), SLOT(editParameterCfg4Test()));
634  grid->addWidget(pushButton,15, 6, Qt::AlignHCenter);
635  //
636  // end of buttons
637  //
638  layout->addWidget(gbox); // end of parameter selecion
639  //
640  //
641  // PWL modes:
642  QRadioButton *rbPwlMode[numOfEstimatorPwlModes];
643  gbox = new QGroupBox("Piecewise parameter model:", w);
644  aLayout = new QVBoxLayout(gbox);
645  bgPwlModes_ = new QButtonGroup(gbox);
646  for (int i=0; i<numOfEstimatorPwlModes; i++)
647  {
648  rbPwlMode[i] = new QRadioButton(estimatorPwlModeNames[i], gbox);
649  rbPwlMode[i]-> setMinimumSize(rbPwlMode[i]->sizeHint());
650  bgPwlModes_->addButton(rbPwlMode[i], i);
651  aLayout->addWidget(rbPwlMode[i]);
652  };
653  rbPwlMode[config_->getPwlMode()]->setChecked(true);
654  connect(bgPwlModes_, SIGNAL(buttonClicked(int)), SLOT(modifyEstimatorPwlMode(int)));
655  layout->addWidget(gbox);
656  //
657  cbDoDownWeight_ = new QCheckBox("Downweight delays by 1.D9", gbox);
658  cbDoDownWeight_->setCheckState(config_->getDoDownWeight()?Qt::Checked:Qt::Unchecked);
659  layout->addWidget(cbDoDownWeight_);
660  connect(cbDoDownWeight_, SIGNAL(stateChanged(int)), SLOT(changeDoDownWeight(int)));
661 
662  layout->addStretch(1);
663  //
664  //
665  // right part:
666  //
667  layout = new QVBoxLayout;
668  mainLayout->addLayout(layout);
669  //
670  // Outliers Processing:
671  QGroupBox *gboxOP=new QGroupBox("Outliers Processing", w);
672  QBoxLayout *layoutOP=new QVBoxLayout(gboxOP);
673  QBoxLayout *layoutOPAM;
674  layoutOPAM = new QHBoxLayout;
675  /*
676  if (session_)
677  layoutOPAM = new QHBoxLayout;
678  else
679  layoutOPAM = new QVBoxLayout;
680  */
681  layoutOP->addLayout(layoutOPAM);
682  // Action to do:
683  QRadioButton *rbOPAction[numOfOutliersProcessingActions];
684  QGroupBox *gboxOPA=new QGroupBox("Outliers Action:", gboxOP);
685  bgOPActions_ = new QButtonGroup(gboxOPA);
686  aLayout = new QVBoxLayout(gboxOPA);
687  for (int i=0; i<numOfOutliersProcessingActions; i++)
688  {
689  rbOPAction[i] = new QRadioButton(outliersProcessingActionNames[i], gboxOPA);
690  rbOPAction[i]-> setMinimumSize(rbOPAction[i]->sizeHint());
691  bgOPActions_->addButton(rbOPAction[i], i);
692  aLayout->addWidget(rbOPAction[i]);
693  };
694  rbOPAction[config_->getOpAction()]->setChecked(true);
695  connect(bgOPActions_, SIGNAL(buttonClicked(int)), SLOT(outliersProcessingActionModified(int)));
696  layoutOPAM->addWidget(gboxOPA);
697  // Mode of the action:
698  QRadioButton *rbOPMode[numOfOutliersProcessingModes];
699  gbox = new QGroupBox("Processing Mode:", gboxOP);
700  bgOPModes_ = new QButtonGroup(gbox);
701  aLayout = new QVBoxLayout(gbox);
702  for (int i=0; i<numOfOutliersProcessingModes; i++)
703  {
704  rbOPMode[i] = new QRadioButton(outliersProcessingModeNames[i], gbox);
705  rbOPMode[i]-> setMinimumSize(rbOPMode[i]->sizeHint());
706  bgOPModes_->addButton(rbOPMode[i], i);
707  aLayout->addWidget(rbOPMode[i]);
708  };
709  rbOPMode[config_->getOpMode()]->setChecked(true);
710  connect(bgOPModes_, SIGNAL(buttonClicked(int)), SLOT(outliersProcessingModeModified(int)));
711  layoutOPAM->addWidget(gbox);
712  // Threshold for outliers:
713  aLayout = new QHBoxLayout;
714  layoutOP->addLayout(aLayout);
715  aLayout->addWidget(new QLabel("Threshold for outliers (in sigmas):", gboxOP));
716  leOPThreshold_ = new QLineEdit(gboxOP);
717  QDoubleValidator *val=new QDoubleValidator(leOPThreshold_);
718  val->setBottom(0.0);
719  leOPThreshold_->setValidator(val);
720  leOPThreshold_->setText(QString("").sprintf("%.2f", config_->getOpThreshold()));
721  leOPThreshold_->setFixedWidth((l=leOPThreshold_->fontMetrics().width("WW.WW")));
722  connect(leOPThreshold_, SIGNAL(textChanged(const QString &)),
723  SLOT(outliersProcessingThresholdModified(const QString&)));
724  aLayout->addStretch(1);
725  aLayout->addWidget(leOPThreshold_);
726  // Limit for iterations:
727  aLayout = new QHBoxLayout;
728  layoutOP->addLayout(aLayout);
729  aLayout->addWidget(new QLabel("Number of iterations limit:", gboxOP));
730  leOPIterationsLimit_ = new QLineEdit(gboxOP);
731  QIntValidator *intVal=new QIntValidator(leOPIterationsLimit_);
732  intVal->setBottom(1);
733  leOPIterationsLimit_->setValidator(intVal);
734  leOPIterationsLimit_->setText(QString("").sprintf("%d", config_->getOpIterationsLimit()));
735  leOPIterationsLimit_->setFixedWidth(l);
736  connect(leOPIterationsLimit_, SIGNAL(textChanged(const QString &)),
737  SLOT(outliersProcessingIterationsLimitModified(const QString&)));
738  aLayout->addStretch(1);
739  aLayout->addWidget(leOPIterationsLimit_);
740  // Suppresing weight correction in iterations:
741  cbSuppressWCinOP_ = new QCheckBox("Do not reweight while process outliers", gboxOP);
742  cbSuppressWCinOP_->setCheckState(
743  config_->getOpHave2SuppressWeightCorrection()?Qt::Checked:Qt::Unchecked);
744  layoutOP->addWidget(cbSuppressWCinOP_);
745  connect(cbSuppressWCinOP_, SIGNAL(stateChanged(int)), SLOT(changeOP_WcSuppresion(int)));
746  //
747  // Process outliers in SOLVE compatible mode:
748  cbOPSolveCompatible_ = new QCheckBox("Use SOLVE compatible mode", gboxOP);
749  cbOPSolveCompatible_->setCheckState(config_->getOpIsSolveCompatible()?Qt::Checked:Qt::Unchecked);
750  layoutOP->addWidget(cbOPSolveCompatible_);
751  connect(cbOPSolveCompatible_, SIGNAL(stateChanged(int)), SLOT(changeOP_IsSolveCompatible(int)));
752  //
753  // Do not normalize residuals:
754  cbOPDoNotNormalize_ = new QCheckBox("Do not normalize residuals", gboxOP);
755  cbOPDoNotNormalize_->setCheckState(config_->getOpHave2NormalizeResiduals()?Qt::Unchecked:Qt::Checked);
756  layoutOP->addWidget(cbOPDoNotNormalize_);
757  connect(cbOPDoNotNormalize_, SIGNAL(stateChanged(int)), SLOT(changeOP_DoNotNormalize(int)));
758  //
759  layout->addWidget(gboxOP);
760  // end of Outliers Processing.
761  //
762  //
763  // Reweighting:
764  //
765  QGroupBox *gboxRW=new QGroupBox("Reweighting", w);
766  QVBoxLayout *layoutRW=new QVBoxLayout(gboxRW);
767  gbox = new QGroupBox("Reweighting Action:", gboxRW);
768  aLayout = new QVBoxLayout(gbox);
769  // do action:
770  cbDoReweighting_ = new QCheckBox("Evaluate weight correction", gbox);
771  cbDoReweighting_->setCheckState(config_->getDoWeightCorrection()?Qt::Checked:Qt::Unchecked);
772  aLayout->addWidget(cbDoReweighting_);
773  connect(cbDoReweighting_, SIGNAL(stateChanged(int)), SLOT(changeRTA_WeightCorrection(int)));
774  // use action:
775  cbUseExtWeights_ = new QCheckBox("Use external weights", gbox);
776  cbUseExtWeights_->setCheckState(config_->getUseExternalWeights()?Qt::Checked:Qt::Unchecked);
777  aLayout->addWidget(cbUseExtWeights_);
778  connect(cbUseExtWeights_, SIGNAL(stateChanged(int)), SLOT(changeRTA_UseExternalWeights(int)));
779  //
780  QBoxLayout *bLayout;
781  bLayout = new QHBoxLayout;
782  /*
783  if (session_)
784  bLayout = new QHBoxLayout;
785  else
786  bLayout = new QVBoxLayout;
787  */
788  layoutRW->addLayout(bLayout);
789  bLayout->addWidget(gbox);
790  //
791  // Reweighting modes:
792  QRadioButton *rbRWMode[numOfReweightingModes];
793  gbox = new QGroupBox("Reweighting mode:", gboxRW);
794  aLayout = new QVBoxLayout(gbox);
795  bgRWModes_ = new QButtonGroup(gbox);
796  for (int i=0; i<numOfReweightingModes; i++)
797  {
798  rbRWMode[i] = new QRadioButton(reweightingModeNames[i], gbox);
799  rbRWMode[i]-> setMinimumSize(rbRWMode[i]->sizeHint());
800  bgRWModes_->addButton(rbRWMode[i], i);
801  aLayout->addWidget(rbRWMode[i]);
802  };
803  rbRWMode[config_->getWcMode()]->setChecked(true);
804  connect(bgRWModes_, SIGNAL(buttonClicked(int)), SLOT(modifyReweightingMode(int)));
805  bLayout->addWidget(gbox);
806  //
807  grid = new QGridLayout();
808  layoutRW->addLayout(grid);
809  grid->addWidget(new QLabel("External weights file name:", gboxRW), 0, 0);
810  leUseExtWeights_ = new QLineEdit(gboxRW);
812  connect(leUseExtWeights_, SIGNAL(textChanged(const QString &)),
813  SLOT(changeEF_WeightsFileName(const QString&)));
815  grid->addWidget(leUseExtWeights_, 0, 1);
816  //
817  // initial aux sigmas:
818  grid->addWidget(new QLabel("Initial aux sigmas for delays (ps):", gboxRW), 1, 0);
819  leIniSigma4Del_ = new QLineEdit(gboxRW);
820  leIniSigma4Del_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Delay()*1.0e12));
821  leIniSigma4Del_->setMinimumWidth(leIniSigma4Del_->fontMetrics().width("100.0") + 10);
822  connect(leIniSigma4Del_, SIGNAL(textChanged(const QString &)), SLOT(changeAS_ini4del(const QString&)));
823  grid->addWidget(leIniSigma4Del_, 1, 1);
824  //
825  grid->addWidget(new QLabel("Initial aux sigmas for rates (fs/s):", gboxRW), 2, 0);
826  leIniSigma4Rat_ = new QLineEdit(gboxRW);
827  leIniSigma4Rat_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Rate()*1.0e15));
828  leIniSigma4Rat_->setMinimumWidth(leIniSigma4Rat_->fontMetrics().width("100.0") + 10);
829  connect(leIniSigma4Rat_, SIGNAL(textChanged(const QString &)), SLOT(changeAS_ini4rat(const QString&)));
830  grid->addWidget(leIniSigma4Rat_, 2, 1);
831  // minimal aux sigmas:
832  grid->addWidget(new QLabel("Minimal aux sigmas for delays (ps):", gboxRW), 3, 0);
833  leMinSigma4Del_ = new QLineEdit(gboxRW);
834  leMinSigma4Del_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Delay()*1.0e12));
835  leMinSigma4Del_->setMinimumWidth(leMinSigma4Del_->fontMetrics().width("100.0") + 10);
836  connect(leMinSigma4Del_, SIGNAL(textChanged(const QString &)), SLOT(changeAS_min4del(const QString&)));
837  grid->addWidget(leMinSigma4Del_, 3, 1);
838  //
839  grid->addWidget(new QLabel("Minimal aux sigmas for rates (fs/s):", gboxRW), 4, 0);
840  leMinSigma4Rat_ = new QLineEdit(gboxRW);
841  leMinSigma4Rat_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Rate()*1.0e15));
842  leMinSigma4Rat_->setMinimumWidth(leMinSigma4Rat_->fontMetrics().width("100.0") + 10);
843  connect(leMinSigma4Rat_, SIGNAL(textChanged(const QString &)), SLOT(changeAS_min4rat(const QString&)));
844  grid->addWidget(leMinSigma4Rat_, 4, 1);
845  grid->setColumnStretch(2, 1);
846  //
847  layout->addWidget(gboxRW);
848  layout->addStretch(1);
849  //
850  return w;
851 };
852 
853 
854 
855 //
857 {
858  static const QString flybyRefrMapFNames[] =
859  { QString("None"),
860  QString("NMF, Niell"),
861  QString("MTT, Herring") };
862  static const int numOfFlybyRefrMapFs = sizeof(flybyRefrMapFNames)/sizeof(QString);
863  //
864  //
865  QWidget *w=new QWidget(this);
866  QBoxLayout *mainLayout=new QHBoxLayout(w);
867  QBoxLayout *layoutA=new QVBoxLayout;
868  QBoxLayout *layoutB=new QVBoxLayout;
869  mainLayout->addLayout(layoutA);
870  mainLayout->addLayout(layoutB);
871 
872  QGridLayout *grid;
873 
874  //
875  // external files with a priori information:
876  QGroupBox *gboxEF=new QGroupBox("Use external files with a priori info", w);
877  grid = new QGridLayout(gboxEF);
878  //
879  // sites positions:
880  cbExtAPrioriSitesPositions_ = new QCheckBox("Sites positions:", gboxEF);
881  grid->addWidget(cbExtAPrioriSitesPositions_, 0, 0);
882  connect(cbExtAPrioriSitesPositions_, SIGNAL(stateChanged(int)), SLOT(changeEF_SitePositions(int)));
883  //
884  leExtAPrioriSitesPositions_ = new QLineEdit(gboxEF);
886  connect(leExtAPrioriSitesPositions_, SIGNAL(textChanged(const QString &)),
887  SLOT(changeEF_SitePositionsFileName(const QString&)));
888  leExtAPrioriSitesPositions_->setMinimumWidth(6*leExtAPrioriSitesPositions_->fontMetrics().width("WWW"));
889  grid->addWidget(leExtAPrioriSitesPositions_, 0, 1);
890  //
891  // sites velocities:
892  cbExtAPrioriSitesVelocities_ = new QCheckBox("Sites velocities:", gboxEF);
893  grid->addWidget(cbExtAPrioriSitesVelocities_, 1, 0);
894  connect(cbExtAPrioriSitesVelocities_, SIGNAL(stateChanged(int)), SLOT(changeEF_SiteVelocities(int)));
895  //
896  leExtAPrioriSitesVelocities_ = new QLineEdit(gboxEF);
898  connect(leExtAPrioriSitesVelocities_, SIGNAL(textChanged(const QString &)),
899  SLOT(changeEF_SiteVelocitiesFileName(const QString&)));
900  leExtAPrioriSitesVelocities_->setMinimumWidth(6*leExtAPrioriSitesVelocities_->fontMetrics().width("WWW"));
901  grid->addWidget(leExtAPrioriSitesVelocities_, 1, 1);
902  //
903  // sources positions:
904  cbExtAPrioriSourcesPositions_ = new QCheckBox("Sources positions:", gboxEF);
905  cbExtAPrioriSourcesPositions_->setToolTip("The Sky Is a Neighborhood");
906  grid->addWidget(cbExtAPrioriSourcesPositions_, 2, 0);
907  connect(cbExtAPrioriSourcesPositions_, SIGNAL(stateChanged(int)),
908  SLOT(changeEF_SourcePositions(int)));
909  //
910  leExtAPrioriSourcesPositions_ = new QLineEdit(gboxEF);
912  connect(leExtAPrioriSourcesPositions_, SIGNAL(textChanged(const QString &)),
913  SLOT(changeEF_SourcePositionsFileName(const QString&)));
914  leExtAPrioriSourcesPositions_->setMinimumWidth(6*leExtAPrioriSourcesPositions_->fontMetrics().width("WWW"));
915  grid->addWidget(leExtAPrioriSourcesPositions_, 2, 1);
916  //
917  // sources SM:
918  cbExtAPrioriSourcesSsm_ = new QCheckBox("Source structure model:", gboxEF);
919  cbExtAPrioriSourcesSsm_->setToolTip("So keep it down");
920  grid->addWidget(cbExtAPrioriSourcesSsm_, 3, 0);
921  connect(cbExtAPrioriSourcesSsm_, SIGNAL(stateChanged(int)),
922  SLOT(changeEF_SourceSsm(int)));
923  //
924  leExtAPrioriSourcesSsm_ = new QLineEdit(gboxEF);
926  connect(leExtAPrioriSourcesSsm_, SIGNAL(textChanged(const QString &)),
927  SLOT(changeEF_SourceSsmFileName(const QString&)));
928  leExtAPrioriSourcesSsm_->setMinimumWidth(6*leExtAPrioriSourcesSsm_->fontMetrics().width("WWW"));
929  grid->addWidget(leExtAPrioriSourcesSsm_, 3, 1);
930  //
931  // EOP:
932  cbExtAPrioriErp_ = new QCheckBox("Earth rotation parameters:", gboxEF);
933  grid->addWidget(cbExtAPrioriErp_, 4, 0);
934  connect(cbExtAPrioriErp_, SIGNAL(stateChanged(int)), SLOT(changeEF_Eop(int)));
935  //
936  leExtAPrioriErp_ = new QLineEdit(gboxEF);
938  connect(leExtAPrioriErp_, SIGNAL(textChanged(const QString &)),
939  SLOT(changeEF_EopFileName(const QString&)));
940  leExtAPrioriErp_->setMinimumWidth(6*leExtAPrioriErp_->fontMetrics().width("WWW"));
941  grid->addWidget(leExtAPrioriErp_, 4, 1);
942  //
943  // new column:
944  // axis offsets:
945  cbExtAPrioriAxisOffsets_ = new QCheckBox("Axis offsets:", gboxEF);
946  grid->addWidget(cbExtAPrioriAxisOffsets_, 5, 0);
947  connect(cbExtAPrioriAxisOffsets_, SIGNAL(stateChanged(int)), SLOT(changeEF_AxisOffset(int)));
948  //
949  leExtAPrioriAxisOffsets_ = new QLineEdit(gboxEF);
951  connect(leExtAPrioriAxisOffsets_, SIGNAL(textChanged(const QString &)),
952  SLOT(changeEF_AxisOffsetFileName(const QString&)));
953  leExtAPrioriAxisOffsets_->setMinimumWidth(6*leExtAPrioriAxisOffsets_->fontMetrics().width("WWW"));
954  grid->addWidget(leExtAPrioriAxisOffsets_, 5, 1);
955  //
956  // mean site gradients:
957  cbExtAPrioriMeanGradients_ = new QCheckBox("Mean site gradients:", gboxEF);
958  grid->addWidget(cbExtAPrioriMeanGradients_, 6, 0);
959  connect(cbExtAPrioriMeanGradients_, SIGNAL(stateChanged(int)), SLOT(changeEF_MeanGradients(int)));
960  //
961  leExtAPrioriMeanGradients_ = new QLineEdit(gboxEF);
963  connect(leExtAPrioriMeanGradients_, SIGNAL(textChanged(const QString &)),
964  SLOT(changeEF_MeanGradientsFileName(const QString&)));
965  leExtAPrioriMeanGradients_->setMinimumWidth(6*leExtAPrioriMeanGradients_->fontMetrics().width("WWW"));
966  grid->addWidget(leExtAPrioriMeanGradients_, 6, 1);
967  //
968  // high frequency ERP:
971  cbExtAPrioriHiFyEop_ = new QCheckBox("External model of subdiurnal ERP variations:", gboxEF);
972  grid->addWidget(cbExtAPrioriHiFyEop_, 7, 0);
973  connect(cbExtAPrioriHiFyEop_, SIGNAL(stateChanged(int)), SLOT(changeEF_HiFyEop(int)));
974  //
975  leExtAPrioriHiFyEop_ = new QLineEdit(gboxEF);
977  connect(leExtAPrioriHiFyEop_, SIGNAL(textChanged(const QString &)),
978  SLOT(changeEF_HiFyEopFileName(const QString&)));
979  leExtAPrioriHiFyEop_->setMinimumWidth(6*leExtAPrioriHiFyEop_->fontMetrics().width("WWW"));
980  grid->addWidget(leExtAPrioriHiFyEop_, 7, 1);
981  //
982  // eccentricities:
983  grid->addWidget(new QLabel("Eccentricities file name:", gboxEF), 8, 0);
984  //
985  leEccentricities_ = new QLineEdit(gboxEF);
987  connect(leEccentricities_, SIGNAL(textChanged(const QString &)),
988  SLOT(changeEF_EccentricitiesFileName(const QString&)));
989  leEccentricities_->setMinimumWidth(6*leEccentricities_->fontMetrics().width("WWW"));
990  grid->addWidget(leEccentricities_, 8, 1);
991  //
992 
993  // attach the widget:
994  layoutA->addWidget(gboxEF);
995  layoutA->addStretch(1);
996  //
997  // contributions from CALC:
998  int rIdx, cIdx;
999  QGroupBox *gboxODC=new QGroupBox("Apply the following contributions", w);
1000  grid = new QGridLayout(gboxODC);
1001  rIdx = 0;
1002  cIdx = 0;
1003  //
1004  // have2ApplyPxContrib_ && have2ApplyPyContrib_:
1005  cbH2AppPolarMotion_ = new QCheckBox("Polar motion (x,y)", gboxODC);
1006  grid->addWidget(cbH2AppPolarMotion_, rIdx++, cIdx);
1007  if (session_==NULL ||
1009  {
1010  cbH2AppPolarMotion_->setCheckState(config_->getHave2ApplyPxContrib()? Qt::Checked:Qt::Unchecked);
1011  connect(cbH2AppPolarMotion_, SIGNAL(stateChanged(int)), SLOT(changeODC_PolarMotion(int)));
1012  }
1013  else
1014  cbH2AppPolarMotion_->setEnabled(false);
1015  //
1016  // tides:
1017  // have2ApplyEarthTideContrib_:
1018  cbH2AppEarthTide_ = new QCheckBox("Solid Earth tides", gboxODC);
1019  grid->addWidget(cbH2AppEarthTide_, rIdx++, cIdx);
1020  if (session_==NULL ||
1022  {
1023  cbH2AppEarthTide_->setCheckState(config_->getHave2ApplyEarthTideContrib()? Qt::Checked:Qt::Unchecked);
1024  connect(cbH2AppEarthTide_, SIGNAL(stateChanged(int)), SLOT(changeODC_SolidEarthTide(int)));
1025  }
1026  else
1027  cbH2AppEarthTide_->setEnabled(false);
1028  // have2ApplyOceanTideContrib_:
1029  cbH2AppOceanTide_ = new QCheckBox("Ocean tides loading", gboxODC);
1030  grid->addWidget(cbH2AppOceanTide_, rIdx++, cIdx);
1031  if (session_==NULL ||
1033  {
1034  cbH2AppOceanTide_->setCheckState(config_->getHave2ApplyOceanTideContrib()? Qt::Checked:Qt::Unchecked);
1035  connect(cbH2AppOceanTide_, SIGNAL(stateChanged(int)), SLOT(changeODC_OceanTide(int)));
1036  }
1037  else
1038  cbH2AppOceanTide_->setEnabled(false);
1039  //
1040  // have2ApplyPoleTideContrib_:
1041  cbH2AppPoleTide_ = new QCheckBox("Pole tide deformations", gboxODC);
1042  grid->addWidget(cbH2AppPoleTide_, rIdx++, cIdx);
1043  if (session_==NULL ||
1045  {
1046  cbH2AppPoleTide_->setCheckState(config_->getHave2ApplyPoleTideContrib()? Qt::Checked:Qt::Unchecked);
1047  connect(cbH2AppPoleTide_, SIGNAL(stateChanged(int)), SLOT(changeODC_PoleTide(int)));
1048  }
1049  else
1050  cbH2AppPoleTide_->setEnabled(false);
1051  //
1052  // have2ApplyOceanPoleTideContrib_:
1053  cbH2AppOceanPoleTideLd_ = new QCheckBox("Ocean Pole Tide Loading", gboxODC);
1054  grid->addWidget(cbH2AppOceanPoleTideLd_, rIdx++, cIdx);
1055  if (session_==NULL ||
1057  {
1059  Qt::Checked:Qt::Unchecked);
1060  connect(cbH2AppOceanPoleTideLd_, SIGNAL(stateChanged(int)), SLOT(changeODC_OceanPoleTide(int)));
1061  }
1062  else
1063  cbH2AppOceanPoleTideLd_->setEnabled(false);
1064  // have2ApplyGpsIonoContrib_:
1065  cbH2AppGpsIono_ = new QCheckBox("GPS Ionosphere corrections", gboxODC);
1066  grid->addWidget(cbH2AppGpsIono_, rIdx++, cIdx);
1067  if (session_==NULL ||
1069  {
1070  cbH2AppGpsIono_->setCheckState(config_->getHave2ApplyGpsIonoContrib()? Qt::Checked:Qt::Unchecked);
1071  connect(cbH2AppGpsIono_, SIGNAL(stateChanged(int)), SLOT(changeODC_GpsIono(int)));
1072  }
1073  else
1074  cbH2AppGpsIono_->setEnabled(false);
1075  //
1076  // have2ApplyNdryContrib_:
1077  cbH2AppNdryContrib_ = new QCheckBox("Refraction: hydrostatic troposphere", gboxODC);
1078  grid->addWidget(cbH2AppNdryContrib_, rIdx++, cIdx);
1079  if (session_==NULL ||
1081  {
1082  cbH2AppNdryContrib_->setCheckState(config_->getHave2ApplyNdryContrib()?Qt::Checked:Qt::Unchecked);
1083  connect(cbH2AppNdryContrib_, SIGNAL(stateChanged(int)), SLOT(changeODC_TropRefractionDry(int)));
1084  }
1085  else
1086  cbH2AppNdryContrib_->setEnabled(false);
1087 
1088  // have2ApplyNwetContrib_:
1089  cbH2AppNwetContrib_ = new QCheckBox("Refraction: wet troposphere", gboxODC);
1090  grid->addWidget(cbH2AppNwetContrib_, rIdx++, cIdx);
1091  if (session_==NULL ||
1093  {
1094  cbH2AppNwetContrib_->setCheckState(config_->getHave2ApplyNwetContrib()?Qt::Checked:Qt::Unchecked);
1095  connect(cbH2AppNwetContrib_, SIGNAL(stateChanged(int)), SLOT(changeODC_TropRefractionWet(int)));
1096  }
1097  else
1098  cbH2AppNwetContrib_->setEnabled(false);
1099  //
1100  // have2ApplyFeedCorrContrib_:
1101  cbH2AppFeedCorr_ = new QCheckBox("Feed horn rotation", gboxODC);
1102  grid->addWidget(cbH2AppFeedCorr_, rIdx++, cIdx);
1103  if (session_==NULL ||
1105  {
1106  cbH2AppFeedCorr_->setCheckState(config_->getHave2ApplyFeedCorrContrib()?Qt::Checked:Qt::Unchecked);
1107  connect(cbH2AppFeedCorr_, SIGNAL(stateChanged(int)), SLOT(changeODC_FeedCorr(int)));
1108  }
1109  else
1110  cbH2AppFeedCorr_->setEnabled(false);
1111  //
1112  // new column:
1113  //
1114  rIdx = 0;
1115  cIdx = 1;
1116  //
1117  //
1118  //
1119  // have2ApplyPxyOceanTideHFContrib_:
1120  cbH2AppHfTidalPxy_ = new QCheckBox("Subdiurnal tidal polar motion", gboxODC);
1121  grid->addWidget(cbH2AppHfTidalPxy_, rIdx++, cIdx);
1122  if (session_==NULL ||
1124  {
1125  connect(cbH2AppHfTidalPxy_, SIGNAL(stateChanged(int)), SLOT(changeODC_HiFqTidalPxy(int)));
1127  Qt::Checked:Qt::Unchecked);
1128  }
1129  else
1130  cbH2AppHfTidalPxy_->setEnabled(false);
1131  //
1132  // have2ApplyUt1OceanTideHFContrib_:
1133  cbH2AppHfTidalUt1_ = new QCheckBox("Subdiurnal tidal UT1", gboxODC);
1134  grid->addWidget(cbH2AppHfTidalUt1_, rIdx++, cIdx);
1135  if (session_==NULL ||
1137  {
1138  connect(cbH2AppHfTidalUt1_, SIGNAL(stateChanged(int)), SLOT(changeODC_HiFqTidalUt1(int)));
1140  Qt::Checked:Qt::Unchecked);
1141  }
1142  else
1143  cbH2AppHfTidalUt1_->setEnabled(false);
1144  //
1145  if (session_==NULL || (session_ && session_->calcInfo().getDversion()>=11.0))
1146  {
1147  // have2ApplyPxyLibrationContrib_:
1148  cbH2AppHfLibrationPxy_ = new QCheckBox("Libration in polar motion", gboxODC);
1149  grid->addWidget(cbH2AppHfLibrationPxy_, rIdx++, cIdx);
1150  if (session_==NULL ||
1152  {
1153  connect(cbH2AppHfLibrationPxy_, SIGNAL(stateChanged(int)), SLOT(changeODC_HiFqLibrationPxy(int)));
1155  Qt::Checked:Qt::Unchecked);
1156  }
1157  else
1158  cbH2AppHfLibrationPxy_->setEnabled(false);
1159  //
1160  // have2ApplyUt1LibrationContrib_:
1161  cbH2AppHfLibrationUt1_ = new QCheckBox("Libration in UT1", gboxODC);
1162  grid->addWidget(cbH2AppHfLibrationUt1_, rIdx++, cIdx);
1163  if (session_==NULL ||
1165  {
1166  connect(cbH2AppHfLibrationUt1_, SIGNAL(stateChanged(int)), SLOT(changeODC_HiFqLibrationUt1(int)));
1168  Qt::Checked:Qt::Unchecked);
1169  }
1170  else
1171  cbH2AppHfLibrationUt1_->setEnabled(false);
1172  cbH2AppHfNutation_ = NULL;
1173  }
1174  else
1175  {
1176  // have2ApplyNutationHFContrib_:
1177  cbH2AppHfNutation_ = new QCheckBox("Subdiurnal nutation in ERP", gboxODC);
1178  grid->addWidget(cbH2AppHfNutation_, rIdx++, cIdx);
1179  if (session_==NULL ||
1181  {
1182  connect(cbH2AppHfNutation_, SIGNAL(stateChanged(int)), SLOT(changeODC_HiFqNutation(int)));
1184  Qt::Checked:Qt::Unchecked);
1185  }
1186  else
1187  cbH2AppHfNutation_->setEnabled(false);
1188  cbH2AppHfLibrationPxy_ = NULL;
1189  cbH2AppHfLibrationUt1_ = NULL;
1190  };
1191  //
1192  // have2ApplyAxisOffsetContrib_:
1193  cbH2AppAxisOffsetContrib_ = new QCheckBox("Axis offset", gboxODC);
1194  grid->addWidget(cbH2AppAxisOffsetContrib_, rIdx++, cIdx);
1196  Qt::Checked:Qt::Unchecked);
1197  connect(cbH2AppAxisOffsetContrib_, SIGNAL(stateChanged(int)), SLOT(changeODC_AxisOffset(int)));
1198  //
1199  //
1200  cbH2AppTiltRmvr_ = new QCheckBox("Axis Tilt Remover", gboxODC);
1201  grid->addWidget(cbH2AppTiltRmvr_, rIdx++, cIdx);
1202  if (session_==NULL ||
1204  {
1205  cbH2AppTiltRmvr_->setCheckState(config_->getHave2ApplyTiltRemvrContrib()?Qt::Checked:Qt::Unchecked);
1206  connect(cbH2AppTiltRmvr_, SIGNAL(stateChanged(int)), SLOT(changeODC_TiltRmvr(int)));
1207  }
1208  else
1209  cbH2AppTiltRmvr_->setEnabled(false);
1210  //
1211  // have2ApplyOldOceanTideContrib_:
1212  cbH2AppOldOceanTide_ = new QCheckBox("Old ocean tides loading", gboxODC);
1213  grid->addWidget(cbH2AppOldOceanTide_, rIdx++, cIdx);
1214  if (session_==NULL ||
1216  {
1218  Qt::Checked:Qt::Unchecked);
1219  connect(cbH2AppOldOceanTide_, SIGNAL(stateChanged(int)), SLOT(changeODC_OldOceanTide(int)));
1220  }
1221  else
1222  cbH2AppOldOceanTide_->setEnabled(false);
1223  //
1224  // have2ApplyOldPoleTideContrib_:
1225  cbH2AppOldPoleTide_ = new QCheckBox("Old pole tide deformations", gboxODC);
1226  grid->addWidget(cbH2AppOldPoleTide_, rIdx++, cIdx);
1227  if (session_==NULL ||
1229  {
1231  Qt::Checked:Qt::Unchecked);
1232  connect(cbH2AppOldPoleTide_, SIGNAL(stateChanged(int)), SLOT(changeODC_OldPoleTide(int)));
1233  }
1234  else
1235  cbH2AppOldPoleTide_->setEnabled(false);
1236  //
1237  QBoxLayout *hLayout=new QHBoxLayout;
1238 
1239  layoutA->addLayout(hLayout);
1240  hLayout->addWidget(gboxODC);
1241  layoutA->addStretch(1);
1242 
1243  //
1244  //
1245  QGroupBox *gboxFBM=new QGroupBox("Apply the following fly-bye models", w);
1246 
1247  // Refraction, hydrostatic:
1248  QRadioButton *rbRefrMapF[numOfFlybyRefrMapFs];
1249  QGroupBox *gbox=new QGroupBox("Refraction: zenith delay mapping function", gboxFBM);
1250  bgFlybyRefrMapF_ = new QButtonGroup(gbox);
1251  QVBoxLayout *aLayout=new QVBoxLayout(gbox);
1252  for (int i=0; i<numOfFlybyRefrMapFs; i++)
1253  {
1254  rbRefrMapF[i] = new QRadioButton(flybyRefrMapFNames[i], gbox);
1255  rbRefrMapF[i]-> setMinimumSize(rbRefrMapF[i]->sizeHint());
1256  bgFlybyRefrMapF_->addButton(rbRefrMapF[i], i);
1257  aLayout->addWidget(rbRefrMapF[i]);
1258  };
1259  rbRefrMapF[config_->getFlybyTropZenithMap()]->setChecked(true);
1260  connect(bgFlybyRefrMapF_, SIGNAL(buttonClicked(int)), SLOT(flybyRefrMapFModified(int)));
1261 
1262  QVBoxLayout *layout=new QVBoxLayout(gboxFBM);
1263  layout->addWidget(gbox);
1264 
1265 // rIdx = 0;
1266 // cIdx = 0;
1267  //
1268  cbH2AppSourceSsm_ = new QCheckBox("Apply source structure model", gboxFBM);
1269 // grid->addWidget(cbH2AppSourceSsm_, rIdx++, cIdx);
1270  layout->addWidget(cbH2AppSourceSsm_);
1271  cbH2AppSourceSsm_->setCheckState(config_->getHave2ApplySourceSsm()? Qt::Checked:Qt::Unchecked);
1272  connect(cbH2AppSourceSsm_, SIGNAL(stateChanged(int)), SLOT(changeODC_SourceSsm(int)));
1273  //
1274  if (session_ )
1275  {
1276  bool /*hasFslg, */hasCdma, hasPcmt;
1277  /*hasFslg = */hasCdma = hasPcmt = false;
1278  for (QMap<QString, SgVlbiStationInfo*>::iterator it=session_->stationsByName().begin();
1279  it!=session_->stationsByName().end(); ++it)
1280  {
1281  SgVlbiStationInfo *si=it.value();
1282 /*
1283  if (si->isAttr(SgVlbiStationInfo::Attr_HAS_CCC_FSLG))
1284  hasFslg = true;
1285 */
1287  hasCdma = true;
1289  hasPcmt = true;
1290  };
1291  if (hasCdma || hasPcmt)
1292  {
1293  // source of cable calibration corrections:
1294  QRadioButton *rbCccSource[4];
1295  QGroupBox *gbox=new QGroupBox("Chose a source of cable calibration correction:",
1296  gboxFBM);
1297  bgFlybySrcCcc_ = new QButtonGroup(gbox);
1298  QVBoxLayout *aLayout=new QVBoxLayout(gbox);
1299  aLayout->setSpacing(aLayout->spacing()/2);
1300  for (int i=0; i<4; i++)
1301  {
1302  rbCccSource[i] = new QRadioButton("Use cable calibration correction from: " +
1303  sCableCalSourceNames[i], gbox);
1304  rbCccSource[i]->setMinimumSize(rbCccSource[i]->sizeHint());
1305  bgFlybySrcCcc_->addButton(rbCccSource[i], i);
1306  aLayout->addWidget(rbCccSource[i]);
1307  };
1308  rbCccSource[config_->getFlybyCableCalSource()]->setChecked(true);
1309  connect(bgFlybySrcCcc_, SIGNAL(buttonClicked(int)), SLOT(flybySourceCccFModified(int)));
1310  layout->addWidget(gbox);
1311  };
1312  };
1313  //
1314  layout->addStretch(1);
1315  //
1316  // end of fly by models...
1317  hLayout->addWidget(gboxFBM);
1318  //
1319  //
1320  //
1321  // right column:
1322  if (session_ && session_->getUserCorrectionsName().size()) // can be NULL:
1323  {
1324  //
1325  // external files with a priori information:
1326  QGroupBox *gboxUC=new QGroupBox("Apply user provided corrections", w);
1327  QBoxLayout *layout=new QVBoxLayout(gboxUC);
1328  //
1329  // attach the widget:
1330  layoutB->addWidget(gboxUC);
1331 
1332  QStringList headerLabels;
1333  headerLabels << "User correction" << "Apply?";
1334  //
1336  tweUserCorrections_->setColumnCount(headerLabels.count());
1337  tweUserCorrections_->setHeaderLabels(headerLabels);
1338  for (int i=0; i<session_->getUserCorrectionsName().size(); i++)
1339  {
1342  item->setText(0, session_->getUserCorrectionsName().at(i));
1343  item->setData(0, Qt::TextAlignmentRole, Qt::AlignLeft);
1344  item->setText(1, session_->getUserCorrectionsUse().at(i)?"Y":"");
1345  item->setData(1, Qt::TextAlignmentRole, Qt::AlignCenter);
1346  };
1347  tweUserCorrections_->header()->resizeSections(QHeaderView::ResizeToContents);
1348  tweUserCorrections_->header()->setSectionResizeMode(QHeaderView::Interactive);
1349  tweUserCorrections_->header()->setStretchLastSection(false);
1350  tweUserCorrections_->setSortingEnabled(true);
1351  tweUserCorrections_->setUniformRowHeights(true);
1352  tweUserCorrections_->sortByColumn(1, Qt::AscendingOrder);
1353  tweUserCorrections_->setFocus();
1354  tweUserCorrections_->setItemsExpandable(false);
1355  tweUserCorrections_->setAllColumnsShowFocus(true);
1356 
1357  layout->addWidget(tweUserCorrections_);
1358 
1359  connect(tweUserCorrections_,
1360  SIGNAL(moveUponItem(QTreeWidgetItem*, int, Qt::MouseButton, Qt::KeyboardModifiers)),
1361  SLOT (toggleEntryMoveEnable(QTreeWidgetItem*, int, Qt::MouseButton, Qt::KeyboardModifiers)));
1362  };
1363  //
1364  //
1365  //
1366  // set check states after creation of QLineEditors and other objects:
1367  cbExtAPrioriSitesPositions_->setCheckState(
1368  config_->getUseExtAPrioriSitesPositions()?Qt::Checked:Qt::Unchecked);
1369  cbExtAPrioriSitesVelocities_->setCheckState(
1370  config_->getUseExtAPrioriSitesVelocities()?Qt::Checked:Qt::Unchecked);
1371  cbExtAPrioriSourcesPositions_->setCheckState(
1372  config_->getUseExtAPrioriSourcesPositions()?Qt::Checked:Qt::Unchecked);
1373  cbExtAPrioriSourcesSsm_->setCheckState(config_->getUseExtAPrioriSourceSsm()?Qt::Checked:Qt::Unchecked);
1374  cbExtAPrioriErp_->setCheckState(config_->getUseExtAPrioriErp()? Qt::Checked:Qt::Unchecked);
1375  cbExtAPrioriAxisOffsets_->setCheckState(
1376  config_->getUseExtAPrioriAxisOffsets()?Qt::Checked:Qt::Unchecked);
1377  cbExtAPrioriHiFyEop_->setCheckState(config_->getUseExtAPrioriHiFyErp()?Qt::Checked:Qt::Unchecked);
1378  cbExtAPrioriMeanGradients_->setCheckState(
1379  config_->getUseExtAPrioriMeanGradients()?Qt::Checked:Qt::Unchecked);
1388  //
1389  //
1390  //
1391  if (cbH2AppNdryContrib_->checkState() == Qt::Checked ||
1392  cbH2AppNwetContrib_->checkState() == Qt::Checked )
1393  for (int i=0; i<bgFlybyRefrMapF_->buttons().size(); i++)
1394  bgFlybyRefrMapF_->buttons()[i]->setEnabled(false);
1395  //
1396  if (bgFlybyRefrMapF_->checkedId() != 0)
1397  {
1398  cbH2AppNdryContrib_->setEnabled(false);
1399  cbH2AppNwetContrib_->setEnabled(false);
1400  };
1401  //
1402  //
1403 //-->> mainLayout->addStretch(1);
1404 
1405  return w;
1406 };
1407 
1408 
1409 
1410 //
1412 {
1413  static const QString automaticFinalSolutionName[] =
1414  { QString("Baselines"),
1415  QString("dUT1") };
1416  static const int numOfAutomaticFinalSolutionNames = sizeof(automaticFinalSolutionName)/sizeof(QString);
1417  //
1418  QWidget *w=new QWidget(this);
1419  QBoxLayout *mainLayout=new QVBoxLayout(w);
1420  QBoxLayout *layout;
1421  QLabel *label;
1422 
1423  // Automatic actions setup:
1424  //
1425  label = new QLabel("Set up for network ID:", w);
1426  label->setMinimumSize(label->sizeHint());
1427  layout = new QHBoxLayout;
1428  mainLayout->addLayout(layout);
1429  layout->addWidget(label);
1430  //
1431  cbNetID_ = new QComboBox(w);
1432  cbNetID_->setMinimumSize(cbNetID_->sizeHint());
1433  layout->addStretch(1);
1434  layout->addWidget(cbNetID_);
1435  //
1436  gbAutoAction_ = new QGroupBox("Actions to perform:", w);
1437  mainLayout->addWidget(gbAutoAction_);
1438  layout = new QVBoxLayout(gbAutoAction_);
1439  //
1440  cbApDoSessionSetup_ = new QCheckBox("Perform set up of the session (reference clock station, etc.)",
1441  gbAutoAction_);
1442  layout->addWidget(cbApDoSessionSetup_);
1443  connect(cbApDoSessionSetup_, SIGNAL(stateChanged(int)), SLOT(changeAA_SessionSetup(int)));
1444  //
1445  cbApDoIonoCorrection4SBD_ = new QCheckBox("Evaluate ionospheric correction for single band delay",
1446  gbAutoAction_);
1447  layout->addWidget(cbApDoIonoCorrection4SBD_);
1448  connect(cbApDoIonoCorrection4SBD_, SIGNAL(stateChanged(int)), SLOT(changeAA_Iono4SBD(int)));
1449  //
1450  cbApDoAmbigResolution_ = new QCheckBox("Resolve group delay ambiguities", gbAutoAction_);
1451  layout->addWidget(cbApDoAmbigResolution_);
1452  connect(cbApDoAmbigResolution_, SIGNAL(stateChanged(int)), SLOT(changeAA_Ambigs(int)));
1453  //
1454  cbApDoClockBreaksDetection_ = new QCheckBox("Detect clock breaks", gbAutoAction_);
1455  layout->addWidget(cbApDoClockBreaksDetection_);
1456  connect(cbApDoClockBreaksDetection_, SIGNAL(stateChanged(int)), SLOT(changeAA_ClockBreaks(int)));
1457  //
1458  cbApDoIonoCorrection4All_ = new QCheckBox("Evaluate ionospheric correction for all observables",
1459  gbAutoAction_);
1460  layout->addWidget(cbApDoIonoCorrection4All_);
1461  connect(cbApDoIonoCorrection4All_, SIGNAL(stateChanged(int)), SLOT(changeAA_Iono4All(int)));
1462  //
1463  cbApDoOutliers_ = new QCheckBox("Process outliers", gbAutoAction_);
1464  layout->addWidget(cbApDoOutliers_);
1465  connect(cbApDoOutliers_, SIGNAL(stateChanged(int)), SLOT(changeAA_Outliers(int)));
1466  //
1467  cbApDoWeights_ = new QCheckBox("Perform weight corrections", gbAutoAction_);
1468  layout->addWidget(cbApDoWeights_);
1469  connect(cbApDoWeights_, SIGNAL(stateChanged(int)), SLOT(changeAA_Reweighting(int)));
1470  //
1471  cbApDoReportNotUsedData_ = new QCheckBox("Print a list of not used observations in a file",
1472  gbAutoAction_);
1473  layout->addWidget(cbApDoReportNotUsedData_);
1474  connect(cbApDoReportNotUsedData_, SIGNAL(stateChanged(int)), SLOT(changeAA_ReportNotUsed(int)));
1475  //
1476  // options:
1477  QRadioButton *rbFinSolTypes[numOfAutomaticFinalSolutionNames];
1478  gbApFinalSolution_ = new QGroupBox("Make Final Solution:", this);
1479  layout = new QVBoxLayout(gbApFinalSolution_);
1480  bgApFinalSolution_ = new QButtonGroup(gbApFinalSolution_);
1481  for (int i=0; i<numOfAutomaticFinalSolutionNames; i++)
1482  {
1483  rbFinSolTypes[i] = new QRadioButton(automaticFinalSolutionName[i], gbApFinalSolution_);
1484  rbFinSolTypes[i]-> setMinimumSize(rbFinSolTypes[i]->sizeHint());
1485  bgApFinalSolution_->addButton(rbFinSolTypes[i], i);
1486  layout->addWidget(rbFinSolTypes[i]);
1487  };
1488  connect(bgApFinalSolution_, SIGNAL(buttonClicked(int)), SLOT(changeAA_FinalSolution(int)));
1489  mainLayout->addWidget(gbApFinalSolution_);
1490  //
1491  //
1492  layout = new QHBoxLayout;
1493  mainLayout->addLayout(layout);
1494  pbApCreate_ = new QPushButton("Create", w);
1495  layout->addStretch(1);
1496  layout->addWidget(pbApCreate_);
1497  connect(pbApCreate_, SIGNAL(clicked()), SLOT(createAutomaticProcessing4NetId()));
1498  //
1499  pbApDestroy_ = new QPushButton("Destroy", w);
1500  layout->addWidget(pbApDestroy_);
1501  connect(pbApDestroy_, SIGNAL(clicked()), SLOT(destroyAutomaticProcessing4NetId()));
1502  //
1503  //
1504  // feed data into the ComboBox, all the checkboxes have to exist at this stage:
1505  bool isTmp(false);
1506  cbNetID_->setInsertPolicy(QComboBox::InsertAlphabetically);
1507  for (int i=0; i<networks.size(); i++)
1508  cbNetID_->addItem(networks.at(i).getName());
1509  connect(cbNetID_,
1510  SIGNAL(currentIndexChanged(const QString&)), SLOT(netIdCurrentIndexChanged(const QString&)));
1511 
1512  for (int i=0; i<networks.size(); i++)
1513  {
1514  if (networks.at(i).getName() == config_->getLastModifiedNetId())
1515  {
1516  cbNetID_->setCurrentIndex(i);
1517  if (i==0)
1519  isTmp = true;
1520  };
1521  };
1522  if (!isTmp)
1523  for (int i=0; i<networks.size(); i++)
1524  {
1525  if (networks.at(i).getName() == defaultNetIdName)
1526  cbNetID_->setCurrentIndex(i);
1527  };
1528  // end of automatic procession setup:
1529  mainLayout->addStretch(1);
1530 
1531  return w;
1532 };
1533 
1534 
1535 
1536 //
1538 {
1539  QMap<SgParameterCfg::PMode, int> idxByMode;
1540  idxByMode[SgParameterCfg::PM_NONE] = 0;
1541  idxByMode[SgParameterCfg::PM_GLB] = 1;
1542  idxByMode[SgParameterCfg::PM_LOC] = 1;
1543  idxByMode[SgParameterCfg::PM_ARC] = 2;
1544  idxByMode[SgParameterCfg::PM_PWL] = 3;
1545  idxByMode[SgParameterCfg::PM_STC] = 4;
1546 
1547  bgClocks_ ->button(idxByMode[parametersDescriptor_->getClock0() .getPMode()])->setChecked(true);
1548  bgZenith_ ->button(idxByMode[parametersDescriptor_->getZenith() .getPMode()])->setChecked(true);
1549  bgAtmGrads_ ->button(idxByMode[parametersDescriptor_->getAtmGrad() .getPMode()])->setChecked(true);
1550  bgStnCoord_ ->button(idxByMode[parametersDescriptor_->getStnCoo() .getPMode()])->setChecked(true);
1551  bgAxsOffset_->button(idxByMode[parametersDescriptor_->getAxisOffset() .getPMode()])->setChecked(true);
1552  bgSrcCoord_ ->button(idxByMode[parametersDescriptor_->getSrcCoo() .getPMode()])->setChecked(true);
1553  bgSrcSsm_ ->button(idxByMode[parametersDescriptor_->getSrcSsm() .getPMode()])->setChecked(true);
1554  bgEopPm_ ->button(idxByMode[parametersDescriptor_->getPolusXY() .getPMode()])->setChecked(true);
1555  bgEopPmRate_->button(idxByMode[parametersDescriptor_->getPolusXYRate().getPMode()])->setChecked(true);
1556  bgEopUt_ ->button(idxByMode[parametersDescriptor_->getPolusUT1() .getPMode()])->setChecked(true);
1557  bgEopUtRate_->button(idxByMode[parametersDescriptor_->getPolusUT1Rate().getPMode()])->setChecked(true);
1558  bgEopNut_ ->button(idxByMode[parametersDescriptor_->getPolusNut() .getPMode()])->setChecked(true);
1559  bgBlnClock_ ->button(idxByMode[parametersDescriptor_->getBlClock() .getPMode()])->setChecked(true);
1560  bgBlnVector_->button(idxByMode[parametersDescriptor_->getBlLength() .getPMode()])->setChecked(true);
1561  bgTest_ ->button(idxByMode[parametersDescriptor_->getTest() .getPMode()])->setChecked(true);
1562 };
1563 
1564 
1565 
1566 //
1568 {
1569  if (session_==NULL)
1570  return;
1571 
1572  QAbstractButton *b=NULL;
1573 
1574  // page one (general):
1575  b = bgDelTypes_->button(config_->getUseDelayType());
1576  if (b)
1577  {
1578  b->setChecked(true);
1580  };
1581  b = bgRatTypes_->button(config_->getUseRateType());
1582  if (b)
1583  {
1584  b->setChecked(true);
1586  };
1587  b = bgBands_->button(config_->getActiveBandIdx());
1588  if (b)
1589  {
1590  b->setChecked(true);
1592  };
1593 
1595  setCheckState(config_->getIsActiveBandFollowsTab()?Qt::Checked:Qt::Unchecked);
1597  setCheckState(config_->getIsObservableFollowsPlot()?Qt::Checked:Qt::Unchecked);
1599  //
1600  cbUseQualityCodeG_->setCheckState(config_->getUseQualityCodeG()?Qt::Checked:Qt::Unchecked);
1601  cbUseQualityCodeH_->setCheckState(config_->getUseQualityCodeH()?Qt::Checked:Qt::Unchecked);
1602  cbIsSolveCompatible_->setCheckState(config_->getIsSolveCompatible()?Qt::Checked:Qt::Unchecked);
1603  cbUseDynamicClockBreaks_->setCheckState(config_->getUseDynamicClockBreaks()?Qt::Checked:Qt::Unchecked);
1605  setCheckState(config_->getUseSolveObsSuppresionFlags()?Qt::Checked:Qt::Unchecked);
1607  setCheckState(config_->getUseGoodQualityCodeAtStartup()?Qt::Checked:Qt::Unchecked);
1609  cbIsNoviceUser_->setCheckState(config_->getIsNoviceUser()?Qt::Checked:Qt::Unchecked);
1611  Qt::Checked:Qt::Unchecked);
1612  cbIsTesting_->setCheckState(config_->getIsTesting()?Qt::Checked:Qt::Unchecked);
1613  //
1614  // page two (operations), except estimated parameters:
1615  b = bgPwlModes_->button(config_->getPwlMode());
1616  if (b)
1617  b->setChecked(true);
1618  b = bgOPActions_->button(config_->getOpAction());
1619  if (b)
1620  b->setChecked(true);
1621  b = bgOPModes_->button(config_->getOpMode());
1622  if (b)
1623  b->setChecked(true);
1624 
1625  leOPThreshold_->setText(QString("").sprintf("%.2f", config_->getOpThreshold()));
1626  leOPIterationsLimit_->setText(QString("").sprintf("%d", config_->getOpIterationsLimit()));
1628  setCheckState(config_->getOpHave2SuppressWeightCorrection()?Qt::Checked:Qt::Unchecked);
1629  cbOPSolveCompatible_->setCheckState(config_->getOpIsSolveCompatible()?Qt::Checked:Qt::Unchecked);
1630  cbOPDoNotNormalize_->setCheckState(config_->getOpHave2NormalizeResiduals()?Qt::Unchecked:Qt::Checked);
1631  cbDoReweighting_->setCheckState(config_->getDoWeightCorrection()?Qt::Checked:Qt::Unchecked);
1632  cbUseExtWeights_->setCheckState(config_->getUseExternalWeights()?Qt::Checked:Qt::Unchecked);
1633  b = bgRWModes_->button(config_->getWcMode());
1634  if (b)
1635  b->setChecked(true);
1638  leIniSigma4Del_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Delay()*1.0e12));
1639  leIniSigma4Rat_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Rate()*1.0e15));
1640  leMinSigma4Del_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Delay()*1.0e12));
1641  leMinSigma4Rat_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Rate()*1.0e15));
1642  //
1643  // page three (models):
1651 
1656 
1657  if (cbH2AppSourceSsm_->isEnabled())
1658  cbH2AppSourceSsm_->setCheckState(config_->getHave2ApplySourceSsm()?Qt::Checked:Qt::Unchecked);
1659 
1660  if (cbH2AppPolarMotion_->isEnabled())
1661  cbH2AppPolarMotion_->setCheckState(config_->getHave2ApplyPxContrib()?Qt::Checked:Qt::Unchecked);
1662  if (cbH2AppEarthTide_->isEnabled())
1663  cbH2AppEarthTide_->setCheckState(config_->getHave2ApplyEarthTideContrib()?Qt::Checked:Qt::Unchecked);
1664  if (cbH2AppOceanTide_->isEnabled())
1665  cbH2AppOceanTide_->setCheckState(config_->getHave2ApplyOceanTideContrib()?Qt::Checked:Qt::Unchecked);
1666  if (cbH2AppPoleTide_->isEnabled())
1667  cbH2AppPoleTide_->setCheckState(config_->getHave2ApplyPoleTideContrib()?Qt::Checked:Qt::Unchecked);
1668  if (cbH2AppOceanPoleTideLd_->isEnabled())
1670  setCheckState(config_->getHave2ApplyOceanPoleTideContrib()?Qt::Checked:Qt::Unchecked);
1671  if (cbH2AppGpsIono_->isEnabled())
1672  cbH2AppGpsIono_->
1673  setCheckState(config_->getHave2ApplyGpsIonoContrib()?Qt::Checked:Qt::Unchecked);
1674  if (cbH2AppOldOceanTide_->isEnabled())
1676  setCheckState(config_->getHave2ApplyOldOceanTideContrib()?Qt::Checked:Qt::Unchecked);
1677  if (cbH2AppOldPoleTide_->isEnabled())
1679  setCheckState(config_->getHave2ApplyOldPoleTideContrib()?Qt::Checked:Qt::Unchecked);
1680  if (cbH2AppHfTidalPxy_->isEnabled())
1682  setCheckState(config_->getHave2ApplyPxyOceanTideHFContrib()?Qt::Checked:Qt::Unchecked);
1683  if (cbH2AppHfTidalUt1_->isEnabled())
1685  setCheckState(config_->getHave2ApplyUt1OceanTideHFContrib()?Qt::Checked:Qt::Unchecked);
1686  if (cbH2AppHfLibrationPxy_ && cbH2AppHfLibrationPxy_->isEnabled())
1688  setCheckState(config_->getHave2ApplyPxyLibrationContrib()?Qt::Checked:Qt::Unchecked);
1689  if (cbH2AppHfLibrationUt1_ && cbH2AppHfLibrationUt1_->isEnabled())
1690  cbH2AppHfLibrationUt1_->setCheckState(
1691  config_->getHave2ApplyUt1LibrationContrib()?Qt::Checked:Qt::Unchecked);
1692  if (cbH2AppHfNutation_ && cbH2AppHfNutation_->isEnabled())
1694  setCheckState(config_->getHave2ApplyNutationHFContrib()?Qt::Checked:Qt::Unchecked);
1696  setCheckState(config_->getHave2ApplyAxisOffsetContrib()?Qt::Checked:Qt::Unchecked);
1698  setCheckState(config_->getHave2ApplyNdryContrib()?Qt::Checked:Qt::Unchecked);
1700  setCheckState(config_->getHave2ApplyNwetContrib()?Qt::Checked:Qt::Unchecked);
1701 
1702  if (cbH2AppFeedCorr_->isEnabled())
1703  cbH2AppFeedCorr_->setCheckState(config_->getHave2ApplyFeedCorrContrib()?Qt::Checked:Qt::Unchecked);
1704  if (cbH2AppTiltRmvr_->isEnabled())
1705  cbH2AppTiltRmvr_->setCheckState(config_->getHave2ApplyTiltRemvrContrib()?Qt::Checked:Qt::Unchecked);
1706  //
1708  setCheckState(config_->getUseExtAPrioriSitesPositions()?Qt::Checked:Qt::Unchecked);
1710  setCheckState(config_->getUseExtAPrioriSitesVelocities()?Qt::Checked:Qt::Unchecked);
1712  setCheckState(config_->getUseExtAPrioriSourcesPositions()?Qt::Checked:Qt::Unchecked);
1714  setCheckState(config_->getUseExtAPrioriSourceSsm()?Qt::Checked:Qt::Unchecked);
1715  cbExtAPrioriErp_->setCheckState(config_->getUseExtAPrioriErp()? Qt::Checked:Qt::Unchecked);
1717  setCheckState(config_->getUseExtAPrioriAxisOffsets()?Qt::Checked:Qt::Unchecked);
1718  cbExtAPrioriHiFyEop_->setCheckState(config_->getUseExtAPrioriHiFyErp()?Qt::Checked:Qt::Unchecked);
1720  setCheckState(config_->getUseExtAPrioriMeanGradients()?Qt::Checked:Qt::Unchecked);
1721  //
1730 };
1731 
1732 
1733 
1734 //
1736 {
1738  if (config_->apByNetId().contains(str))
1739  {
1740  ap = config_->apByNetId().value(str);
1741  gbAutoAction_->setEnabled(true);
1742  gbApFinalSolution_->setEnabled(true);
1743  pbApCreate_->setEnabled(false);
1744  pbApDestroy_->setEnabled(str!=defaultNetIdName);
1746  }
1747  else
1748  {
1749  gbAutoAction_->setEnabled(false);
1750  gbApFinalSolution_->setEnabled(false);
1751  pbApCreate_->setEnabled(true);
1752  pbApDestroy_->setEnabled(false);
1753  };
1754  cbApDoSessionSetup_->setCheckState(ap.doSessionSetup_?Qt::Checked:Qt::Unchecked);
1755  cbApDoIonoCorrection4SBD_->setCheckState(ap.doIonoCorrection4SBD_?Qt::Checked:Qt::Unchecked);
1756  cbApDoAmbigResolution_->setCheckState(ap.doAmbigResolution_?Qt::Checked:Qt::Unchecked);
1757  cbApDoClockBreaksDetection_->setCheckState(ap.doClockBreaksDetection_?Qt::Checked:Qt::Unchecked);
1758  cbApDoIonoCorrection4All_->setCheckState(ap.doIonoCorrection4All_?Qt::Checked:Qt::Unchecked);
1759  cbApDoOutliers_->setCheckState(ap.doOutliers_?Qt::Checked:Qt::Unchecked);
1760  cbApDoWeights_->setCheckState(ap.doWeights_?Qt::Checked:Qt::Unchecked);
1761  cbApDoReportNotUsedData_->setCheckState(ap.doReportNotUsedData_?Qt::Checked:Qt::Unchecked);
1762  bgApFinalSolution_->button(ap.finalSolution_)->setChecked(true);
1763 };
1764 
1765 
1766 
1767 //
1769 {
1770  QString str=cbNetID_->currentText();
1771  if (config_->apByNetId().contains(str))
1772  config_->apByNetId()[str].doSessionSetup_ = state==Qt::Checked;
1773 };
1774 
1775 
1776 
1777 //
1779 {
1780  QString str=cbNetID_->currentText();
1781  if (config_->apByNetId().contains(str))
1782  config_->apByNetId()[str].doIonoCorrection4SBD_ = state==Qt::Checked;
1783 };
1784 
1785 
1786 
1787 //
1789 {
1790  QString str=cbNetID_->currentText();
1791  if (config_->apByNetId().contains(str))
1792  config_->apByNetId()[str].doAmbigResolution_ = state==Qt::Checked;
1793 };
1794 
1795 
1796 
1797 //
1799 {
1800  QString str=cbNetID_->currentText();
1801  if (config_->apByNetId().contains(str))
1802  config_->apByNetId()[str].doClockBreaksDetection_ = state==Qt::Checked;
1803 };
1804 
1805 
1806 
1807 //
1809 {
1810  QString str=cbNetID_->currentText();
1811  if (config_->apByNetId().contains(str))
1812  config_->apByNetId()[str].doIonoCorrection4All_ = state==Qt::Checked;
1813 };
1814 
1815 
1816 
1817 //
1819 {
1820  QString str=cbNetID_->currentText();
1821  if (config_->apByNetId().contains(str))
1822  config_->apByNetId()[str].doOutliers_ = state==Qt::Checked;
1823 };
1824 
1825 
1826 
1827 //
1829 {
1830  QString str=cbNetID_->currentText();
1831  if (config_->apByNetId().contains(str))
1832  config_->apByNetId()[str].doWeights_ = state==Qt::Checked;
1833 };
1834 
1835 
1836 
1837 //
1839 {
1840  QString str=cbNetID_->currentText();
1841  if (config_->apByNetId().contains(str))
1842  config_->apByNetId()[str].doReportNotUsedData_ = state==Qt::Checked;
1843 };
1844 
1845 
1846 
1847 //
1849 {
1850  QString str=cbNetID_->currentText();
1851  if (!config_->apByNetId().contains(str))
1852  return;
1853  switch (n)
1854  {
1855  default:
1856  case 0:
1858  break;
1859  case 1:
1861  break;
1862  };
1863 };
1864 
1865 
1866 
1867 //
1869 {
1870  QString str=cbNetID_->currentText();
1871  if (!config_->apByNetId().contains(str))
1872  {
1874  config_->apByNetId()[str] = ap;
1875  gbAutoAction_->setEnabled(true);
1876  gbApFinalSolution_->setEnabled(true);
1877  pbApCreate_->setEnabled(false);
1878  pbApDestroy_->setEnabled(true);
1879  cbApDoSessionSetup_->setCheckState(ap.doSessionSetup_?Qt::Checked:Qt::Unchecked);
1880  cbApDoIonoCorrection4SBD_->setCheckState(ap.doIonoCorrection4SBD_?Qt::Checked:Qt::Unchecked);
1881  cbApDoAmbigResolution_->setCheckState(ap.doAmbigResolution_?Qt::Checked:Qt::Unchecked);
1882  cbApDoClockBreaksDetection_->setCheckState(ap.doClockBreaksDetection_?Qt::Checked:Qt::Unchecked);
1883  cbApDoIonoCorrection4All_->setCheckState(ap.doIonoCorrection4All_?Qt::Checked:Qt::Unchecked);
1884  cbApDoOutliers_->setCheckState(ap.doOutliers_?Qt::Checked:Qt::Unchecked);
1885  cbApDoWeights_->setCheckState(ap.doWeights_?Qt::Checked:Qt::Unchecked);
1886  cbApDoReportNotUsedData_->setCheckState(ap.doReportNotUsedData_?Qt::Checked:Qt::Unchecked);
1887  bgApFinalSolution_->button(ap.finalSolution_)->setChecked(true);
1889  };
1890 };
1891 
1892 
1893 
1894 //
1896 {
1897  QString str=cbNetID_->currentText();
1898  if (config_->apByNetId().contains(str))
1899  {
1901  cbApDoSessionSetup_->setCheckState(ap.doSessionSetup_?Qt::Checked:Qt::Unchecked);
1902  cbApDoIonoCorrection4SBD_->setCheckState(ap.doIonoCorrection4SBD_?Qt::Checked:Qt::Unchecked);
1903  cbApDoAmbigResolution_->setCheckState(ap.doAmbigResolution_?Qt::Checked:Qt::Unchecked);
1904  cbApDoClockBreaksDetection_->setCheckState(ap.doClockBreaksDetection_?Qt::Checked:Qt::Unchecked);
1905  cbApDoIonoCorrection4All_->setCheckState(ap.doIonoCorrection4All_?Qt::Checked:Qt::Unchecked);
1906  cbApDoOutliers_->setCheckState(ap.doOutliers_?Qt::Checked:Qt::Unchecked);
1907  cbApDoWeights_->setCheckState(ap.doWeights_?Qt::Checked:Qt::Unchecked);
1908  cbApDoReportNotUsedData_->setCheckState(ap.doReportNotUsedData_?Qt::Checked:Qt::Unchecked);
1909  bgApFinalSolution_->button(ap.finalSolution_)->setChecked(true);
1910  config_->apByNetId().remove(str);
1911  gbAutoAction_->setEnabled(false);
1912  gbApFinalSolution_->setEnabled(false);
1913  pbApCreate_->setEnabled(true);
1914  pbApDestroy_->setEnabled(false);
1916  };
1917 };
1918 
1919 
1920 
1921 //
1923 {
1927  e->show();
1928 };
1929 
1930 
1931 
1932 //
1934 {
1938  e->show();
1939 };
1940 
1941 
1942 
1943 //
1945 {
1949  e->show();
1950 };
1951 
1952 
1953 
1954 //
1956 {
1960  e->show();
1961 };
1962 
1963 
1964 
1965 //
1967 {
1971  e->show();
1972 };
1973 
1974 
1975 
1976 //
1978 {
1982  e->show();
1983 };
1984 
1985 
1986 
1987 //
1989 {
1993  e->show();
1994 };
1995 
1996 
1997 
1998 //
2000 {
2004  e->show();
2005 };
2006 
2007 
2008 
2009 //
2011 {
2015  e->show();
2016 };
2017 
2018 
2019 
2020 //
2022 {
2026  e->show();
2027 };
2028 
2029 
2030 
2031 //
2033 {
2037  e->show();
2038 };
2039 
2040 
2041 
2042 //
2044 {
2048  e->show();
2049 };
2050 
2051 
2052 
2053 //
2055 {
2059  e->show();
2060 };
2061 
2062 
2063 
2064 //
2066 {
2070  e->show();
2071 };
2072 
2073 
2074 
2075 //
2077 {
2081  e->show();
2082 };
2083 
2084 
2085 
2086 //
2088 {
2092  e->show();
2093 };
2094 
2095 
2096 
2097 //
2099 {
2101  switch (n)
2102  {
2103  default:
2104  case 0:
2105  dType = SgTaskConfig::VD_NONE;
2106  break;
2107  case 1:
2108  dType = SgTaskConfig::VD_SB_DELAY;
2109  break;
2110  case 2:
2112  break;
2113  case 3:
2115  break;
2116  };
2117  config_->setUseDelayType(dType);
2118  emit delayTypeModified(dType);
2119 };
2120 
2121 
2122 
2123 //
2125 {
2127  switch (n)
2128  {
2129  default:
2130  case 0:
2131  rType = SgTaskConfig::VR_NONE;
2132  for (int i=0; i<stcParsButtons_.size(); i++)
2133  stcParsButtons_.at(i)->setEnabled(true);
2134  break;
2135  case 1:
2136  rType = SgTaskConfig::VR_PHS_RATE;
2137  for (int i=0; i<stcParsButtons_.size(); i++)
2138  stcParsButtons_.at(i)->setEnabled(false);
2139  break;
2140  };
2141  config_->setUseRateType(rType);
2142  emit rateTypeModified(rType);
2143 };
2144 
2145 
2146 
2147 //
2149 {
2150  switch (n)
2151  {
2152  default:
2153  case 0:
2155  break;
2156  case 1:
2158  break;
2159  };
2160 };
2161 
2162 
2163 
2164 //
2166 {
2167  switch (n)
2168  {
2169  default:
2170  case 0:
2172  break;
2173  case 1:
2175  break;
2176  case 2:
2178  break;
2179  };
2180 };
2181 
2182 
2183 
2184 //
2186 {
2187  switch (n)
2188  {
2189  default:
2190  case 0:
2192  break;
2193  case 1:
2195  break;
2196  };
2197 };
2198 
2199 
2200 
2201 //
2203 {
2204  switch (n)
2205  {
2206  default:
2207  case 0:
2209  break;
2210  case 1:
2212  break;
2213  };
2214 };
2215 
2216 
2217 
2218 //
2220 {
2221  bool isOK;
2222  double d;
2223  d = str.toDouble(&isOK);
2224  if (isOK && d!=config_->getOpThreshold())
2225  {
2226  config_->setOpThreshold(d);
2228  };
2229 };
2230 
2231 
2232 
2233 //
2235 {
2236  bool isOK;
2237  int n;
2238  n = str.toInt(&isOK);
2239  if (isOK && n!=config_->getOpIterationsLimit())
2241 };
2242 
2243 
2244 
2245 //
2247 {
2249 };
2250 
2251 
2252 
2253 //
2255 {
2257 };
2258 
2259 
2260 
2261 //
2263 {
2264  QAbstractButton *b=bgDelTypes_->button(n);
2265  if (b)
2266  b->setChecked(true);
2267  //
2268  if (false && !isOutliersProcessingThresholdModified_) // if user changed it once, do not interfere!
2269  {
2270  double d(5.0);
2272  d = 3.0;
2273  config_->setOpThreshold(d);
2274  leOPThreshold_->setText(QString("").sprintf("%.2f", config_->getOpThreshold()));
2275  };
2276 };
2277 
2278 
2279 
2280 //
2282 {
2283  QAbstractButton *b=bgRatTypes_->button(n);
2284  if (b)
2285  b->setChecked(true);
2286 };
2287 
2288 
2289 
2290 //
2292 {
2295  emit activeBandModified(n);
2296 };
2297 
2298 
2299 
2300 //
2302 {
2303  QAbstractButton *b = bgBands_->button(n);
2304  if (b)
2305  b->setChecked(true);
2306 };
2307 
2308 
2309 
2310 //
2312 {
2313  switch (n)
2314  {
2315  default:
2316  case 0:
2322  break;
2323  case 1:
2329  break;
2330  case 2:
2336  break;
2337  case 3:
2343  break;
2344  case 4:
2350  break;
2351  };
2352 };
2353 
2354 
2355 
2356 //
2358 {
2359  switch (n)
2360  {
2361  default:
2362  case 0:
2365  break;
2366  case 1:
2369  break;
2370  case 2:
2373  break;
2374  case 3:
2377  break;
2378  case 4:
2381  break;
2382  };
2383 };
2384 
2385 
2386 
2387 //
2389 {
2390  switch (n)
2391  {
2392  default:
2393  case 0:
2395  break;
2396  case 1:
2398  break;
2399  case 2:
2401  break;
2402  case 3:
2404  break;
2405  case 4:
2407  break;
2408  };
2409 };
2410 
2411 
2412 
2413 //
2415 {
2416  switch (n)
2417  {
2418  default:
2419  case 0:
2421  break;
2422  case 1:
2424  break;
2425  case 2:
2427  break;
2428  case 3:
2430  break;
2431  case 4:
2433  break;
2434  };
2435 };
2436 
2437 
2438 
2439 //
2441 {
2442  switch (n)
2443  {
2444  default:
2445  case 0:
2447  break;
2448  case 1:
2450  break;
2451  case 2:
2453  break;
2454  case 3:
2456  break;
2457  case 4:
2459  break;
2460  };
2461 };
2462 
2463 
2464 
2465 //
2467 {
2468  switch (n)
2469  {
2470  default:
2471  case 0:
2473  break;
2474  case 1:
2476  break;
2477  case 2:
2479  break;
2480  case 3:
2482  break;
2483  case 4:
2485  break;
2486  };
2487 };
2488 
2489 
2490 
2491 //
2493 {
2494  switch (n)
2495  {
2496  default:
2497  case 0:
2499  break;
2500  case 1:
2502  break;
2503  case 2:
2505  break;
2506  case 3:
2508  break;
2509  case 4:
2511  break;
2512  };
2513 };
2514 
2515 
2516 
2517 //
2519 {
2520  switch (n)
2521  {
2522  default:
2523  case 0:
2525  break;
2526  case 1:
2528  break;
2529  case 2:
2531  break;
2532  case 3:
2534  break;
2535  case 4:
2537  break;
2538  };
2539 };
2540 
2541 
2542 
2543 //
2545 {
2546  switch (n)
2547  {
2548  default:
2549  case 0:
2551  break;
2552  case 1:
2554  break;
2555  case 2:
2557  break;
2558  case 3:
2560  break;
2561  case 4:
2563  break;
2564  };
2565 };
2566 
2567 
2568 
2569 //
2571 {
2572  switch (n)
2573  {
2574  default:
2575  case 0:
2577  break;
2578  case 1:
2580  break;
2581  case 2:
2583  break;
2584  case 3:
2586  break;
2587  case 4:
2589  break;
2590  };
2591 };
2592 
2593 
2594 
2595 //
2597 {
2598  switch (n)
2599  {
2600  default:
2601  case 0:
2603  break;
2604  case 1:
2606  break;
2607  case 2:
2609  break;
2610  case 3:
2612  break;
2613  case 4:
2615  break;
2616  };
2617 };
2618 
2619 
2620 
2621 //
2623 {
2624  switch (n)
2625  {
2626  default:
2627  case 0:
2629  break;
2630  case 1:
2632  break;
2633  case 2:
2635  break;
2636  case 3:
2638  break;
2639  case 4:
2641  break;
2642  };
2643 };
2644 
2645 
2646 
2647 //
2649 {
2650  switch (n)
2651  {
2652  default:
2653  case 0:
2655  break;
2656  case 1:
2658  break;
2659  case 2:
2661  break;
2662  case 3:
2664  break;
2665  case 4:
2667  break;
2668  };
2669 };
2670 
2671 
2672 
2673 //
2675 {
2676  switch (n)
2677  {
2678  default:
2679  case 0:
2681  break;
2682  case 1:
2684  break;
2685  case 2:
2687  break;
2688  case 3:
2690  break;
2691  case 4:
2693  break;
2694  };
2695 };
2696 
2697 
2698 
2699 //
2701 {
2702  switch (n)
2703  {
2704  default:
2705  case 0:
2707  break;
2708  case 1:
2710  break;
2711  case 2:
2713  break;
2714  case 3:
2716  break;
2717  case 4:
2719  break;
2720  };
2721 };
2722 
2723 
2724 
2725 //
2727 {
2728  switch (n)
2729  {
2730  default:
2731  case 0:
2733  break;
2734  case 1:
2736  break;
2737  case 2:
2739  break;
2740  case 3:
2742  break;
2743  case 4:
2745  break;
2746  };
2747 };
2748 
2749 
2750 //
2752 {
2753  if (isChecked && cbDoReweighting_->isEnabled())
2754  {
2755  cbDoReweighting_->setEnabled(false);
2756  for (int i=0; i<ratTypeButtons_.size(); i++)
2757  ratTypeButtons_.at(i)->setEnabled(false);
2758  }
2759  else
2760  {
2761  bool canBeEnabled(true);
2762  for (int i=0; i<stcParsButtons_.size(); i++)
2763  if (stcParsButtons_.at(i)->isChecked())
2764  canBeEnabled = false;
2765  if (canBeEnabled)
2766  {
2767  cbDoReweighting_->setEnabled(true);
2768  for (int i=0; i<ratTypeButtons_.size(); i++)
2769  ratTypeButtons_.at(i)->setEnabled(true);
2770  };
2771  };
2772 };
2773 
2774 
2775 
2776 //
2778 {
2779  config_->setDoIonoCorrection4SBD(chkState==Qt::Checked);
2780 };
2781 
2782 
2783 
2784 //
2786 {
2787  config_->setDoClockBreakDetectionMode1(chkState==Qt::Checked);
2788 };
2789 
2790 
2791 
2792 //
2794 {
2795  config_->setDoOutliersEliminationMode1(chkState==Qt::Checked);
2796 };
2797 
2798 
2799 
2800 //
2802 {
2803  config_->setIsActiveBandFollowsTab(chkState==Qt::Checked);
2804 };
2805 
2806 
2807 
2808 //
2810 {
2811  config_->setIsObservableFollowsPlot(chkState==Qt::Checked);
2812 };
2813 
2814 
2815 
2816 //
2818 {
2819  config_->setIsNoviceUser(chkState==Qt::Checked);
2820 };
2821 
2822 
2823 
2824 //
2826 {
2827  config_->setHave2outputCovarMatrix(chkState==Qt::Checked);
2828 };
2829 
2830 
2831 
2832 //
2834 {
2835  config_->setIsTesting(chkState==Qt::Checked);
2836 };
2837 
2838 
2839 
2840 //
2842 {
2843  config_->setUseQualityCodeG(chkState==Qt::Checked);
2844 };
2845 
2846 
2847 
2848 //
2850 {
2851  config_->setUseQualityCodeH(chkState==Qt::Checked);
2852 };
2853 
2854 
2855 
2856 //
2858 {
2859  config_->setIsSolveCompatible(chkState==Qt::Checked);
2860 };
2861 
2862 
2863 
2864 //
2866 {
2867  config_->setUseDynamicClockBreaks(chkState==Qt::Checked);
2868 };
2869 
2870 
2871 
2872 //
2874 {
2875  config_->setUseGoodQualityCodeAtStartup(chkState==Qt::Checked);
2876 };
2877 
2878 
2879 
2880 //
2882 {
2883  config_->setUseSolveObsSuppresionFlags(chkState==Qt::Checked);
2884 };
2885 
2886 
2887 
2888 //
2890 {
2891  bool have2=chkState==Qt::Checked;
2893  for (int i=0; i<stcParsButtons_.size(); i++)
2894  stcParsButtons_.at(i)->setEnabled(!have2 && config_->getUseRateType()==SgTaskConfig::VR_NONE);
2895  cbUseExtWeights_->setEnabled(!have2);
2896 };
2897 
2898 
2899 
2900 //
2902 {
2903  bool have2=chkState==Qt::Checked;
2905  cbDoReweighting_->setEnabled(!have2);
2906  leUseExtWeights_->setEnabled(have2);
2907 };
2908 
2909 
2910 
2911 //
2913 {
2915 };
2916 
2917 
2918 
2919 //
2920 void SgGuiTaskConfig::changeAS_ini4del(const QString& str)
2921 {
2922  bool isOk;
2923  double s;
2924  s = str.toDouble(&isOk);
2925  if (isOk)
2926  config_->setInitAuxSigma4Delay(s*1.0e-12);
2927  else
2928  leIniSigma4Del_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Delay()*1.0e12));
2929 };
2930 
2931 
2932 
2933 //
2934 void SgGuiTaskConfig::changeAS_ini4rat(const QString& str)
2935 {
2936  bool isOk;
2937  double s;
2938  s = str.toDouble(&isOk);
2939  if (isOk)
2940  config_->setInitAuxSigma4Rate(s*1.0e-15);
2941  else
2942  leIniSigma4Rat_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Rate()*1.0e15));
2943 };
2944 
2945 
2946 
2947 //
2948 void SgGuiTaskConfig::changeAS_min4del(const QString& str)
2949 {
2950  bool isOk;
2951  double s;
2952  s = str.toDouble(&isOk);
2953  if (isOk)
2954  config_->setMinAuxSigma4Delay(s*1.0e-12);
2955  else
2956  leMinSigma4Del_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Delay()*1.0e12));
2957 };
2958 
2959 
2960 
2961 void SgGuiTaskConfig::changeAS_min4rat(const QString& str)
2962 {
2963  bool isOk;
2964  double s;
2965  s = str.toDouble(&isOk);
2966  if (isOk)
2967  config_->setMinAuxSigma4Rate(s*1.0e-15);
2968  else
2969  leMinSigma4Rat_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Rate()*1.0e15));
2970 };
2971 
2972 
2973 
2974 //
2976 {
2977  config_->setOpHave2SuppressWeightCorrection(chkState==Qt::Checked);
2978 };
2979 
2980 
2981 
2982 //
2984 {
2985  config_->setOpIsSolveCompatible(chkState==Qt::Checked);
2986 };
2987 
2988 
2989 
2990 //
2992 {
2993  config_->setOpHave2NormalizeResiduals(chkState==Qt::Unchecked);
2994 };
2995 
2996 
2997 
2998 //
3000 {
3001  bool have2=chkState==Qt::Checked;
3003  leExtAPrioriSitesPositions_->setEnabled(have2);
3004 };
3005 
3006 
3007 
3008 //
3010 {
3012 };
3013 
3014 
3015 
3016 //
3018 {
3019  bool have2=chkState==Qt::Checked;
3021  leExtAPrioriSitesVelocities_->setEnabled(have2);
3022 };
3023 
3024 
3025 
3026 //
3028 {
3030 };
3031 
3032 
3033 
3034 //
3036 {
3037  bool have2=chkState==Qt::Checked;
3039  leExtAPrioriSourcesPositions_->setEnabled(have2);
3040 };
3041 
3042 
3043 
3044 //
3046 {
3048 };
3049 
3050 
3051 
3052 //
3054 {
3055  bool have2=chkState==Qt::Checked;
3057  leExtAPrioriSourcesSsm_->setEnabled(have2);
3058 };
3059 
3060 
3061 
3062 //
3064 {
3066 };
3067 
3068 
3069 
3070 //
3072 {
3073  bool have2=chkState==Qt::Checked;
3074  config_->setUseExtAPrioriErp(have2);
3075  leExtAPrioriErp_->setEnabled(have2);
3076 };
3077 
3078 
3079 
3080 //
3082 {
3084 };
3085 
3086 
3087 
3088 //
3090 {
3091  bool have2=chkState==Qt::Checked;
3093  leExtAPrioriAxisOffsets_->setEnabled(have2);
3094 };
3095 
3096 
3097 
3098 //
3100 {
3102 };
3103 
3104 
3105 
3106 //
3108 {
3109  bool have2=chkState==Qt::Checked;
3111  leExtAPrioriHiFyEop_->setEnabled(have2);
3112  cbH2AppHfTidalPxy_->setEnabled(!have2);
3113  cbH2AppHfTidalUt1_->setEnabled(!have2);
3114 };
3115 
3116 
3117 
3118 //
3120 {
3122 };
3123 
3124 
3125 
3126 //
3128 {
3129  bool have2=chkState==Qt::Checked;
3131  leExtAPrioriMeanGradients_->setEnabled(have2);
3132 };
3133 
3134 
3135 
3136 //
3138 {
3140 };
3141 
3142 
3143 
3144 //
3146 {
3148 };
3149 
3150 
3151 
3152 
3153 //
3155 {
3156  config_->setHave2ApplySourceSsm(chkState==Qt::Checked);
3157 };
3158 
3159 
3160 
3161 //
3163 {
3164  switch (n)
3165  {
3166  default:
3167  case 0:
3169  cbH2AppNdryContrib_->setEnabled(true);
3170  cbH2AppNwetContrib_->setEnabled(true);
3171  break;
3172  case 1:
3174  cbH2AppNdryContrib_->setEnabled(false);
3175  cbH2AppNwetContrib_->setEnabled(false);
3176  break;
3177  case 2:
3179  cbH2AppNdryContrib_->setEnabled(false);
3180  cbH2AppNwetContrib_->setEnabled(false);
3181  break;
3182  };
3183 };
3184 
3185 
3186 
3187 //
3189 {
3190  switch (n)
3191  {
3192  default:
3193  case 0:
3195  break;
3196  case 1:
3198  break;
3199  case 2:
3201  break;
3202  case 3:
3204  break;
3205  };
3206 };
3207 
3208 
3209 
3210 //
3212 {
3213  bool have=chkState==Qt::Checked;
3216 };
3217 
3218 
3219 
3220 //
3222 {
3223  config_->setHave2ApplyEarthTideContrib(chkState==Qt::Checked);
3224 };
3225 
3226 
3227 
3228 //
3230 {
3231  config_->setHave2ApplyOceanTideContrib(chkState==Qt::Checked);
3232 };
3233 
3234 
3235 
3236 //
3238 {
3239  config_->setHave2ApplyPoleTideContrib(chkState==Qt::Checked);
3240 };
3241 
3242 
3243 
3244 //
3246 {
3247  bool have2=chkState==Qt::Checked;
3249  cbExtAPrioriHiFyEop_->setEnabled(!have2);
3250 };
3251 
3252 
3253 
3254 //
3256 {
3257  bool have2=chkState==Qt::Checked;
3259  cbExtAPrioriHiFyEop_->setEnabled(!have2);
3260 };
3261 
3262 
3263 
3264 //
3266 {
3267  bool have2=chkState==Qt::Checked;
3269 };
3270 
3271 
3272 
3273 //
3275 {
3276  config_->setHave2ApplyUt1LibrationContrib(chkState==Qt::Checked);
3277 };
3278 
3279 
3280 
3281 //
3283 {
3284  config_->setHave2ApplyNutationHFContrib(chkState==Qt::Checked);
3285 };
3286 
3287 
3288 
3289 //
3291 {
3292  config_->setHave2ApplyOceanPoleTideContrib(chkState==Qt::Checked);
3293 };
3294 
3295 
3296 
3297 //
3299 {
3300  config_->setHave2ApplyGpsIonoContrib(chkState==Qt::Checked);
3301 };
3302 
3303 
3304 
3305 //
3307 {
3308  config_->setHave2ApplyFeedCorrContrib(chkState==Qt::Checked);
3309 };
3310 
3311 
3312 
3313 //
3315 {
3316  config_->setHave2ApplyTiltRemvrContrib(chkState==Qt::Checked);
3317 };
3318 
3319 
3320 
3321 //
3323 {
3324  config_->setHave2ApplyOldOceanTideContrib(chkState==Qt::Checked);
3325 };
3326 
3327 
3328 
3329 //
3331 {
3332  config_->setHave2ApplyOldPoleTideContrib(chkState==Qt::Checked);
3333 };
3334 
3335 
3336 
3337 //
3339 {
3340  config_->setHave2ApplyAxisOffsetContrib(chkState==Qt::Checked);
3341 };
3342 
3343 
3344 
3345 //
3347 {
3348  bool isOn=chkState==Qt::Checked;
3350  isOn = isOn || config_->getHave2ApplyNwetContrib();
3351  for (int i=0; i<bgFlybyRefrMapF_->buttons().size(); i++)
3352  bgFlybyRefrMapF_->buttons()[i]->setEnabled(!isOn);
3353 };
3354 
3355 
3356 
3357 //
3359 {
3360  bool isOn=chkState==Qt::Checked;
3362  isOn = isOn || config_->getHave2ApplyNdryContrib();
3363  for (int i=0; i<bgFlybyRefrMapF_->buttons().size(); i++)
3364  bgFlybyRefrMapF_->buttons()[i]->setEnabled(!isOn);
3365 };
3366 
3367 
3368 
3369 //
3371 {
3372  config_->setDoDownWeight(chkState==Qt::Checked);
3373 };
3374 
3375 
3376 
3377 //
3378 //
3380  Qt::MouseButton /* mouseButtonState */, Qt::KeyboardModifiers /* modifiers */)
3381 {
3382  if (!item) // may be NULL
3383  return;
3384 
3385  int idx=((SgGuiTcUserCorrectionItem*)item)->getIdx();
3386  QString str("");
3387  switch (n)
3388  {
3389  case 0:
3390  break;
3391  case 1:
3393  item->setText(1, session_->getUserCorrectionsUse().at(idx)?"Y":"");
3394  break;
3395  default:
3396  //std::cout << "default, n=" << n << "\n";
3397  break;
3398  };
3399 };
3400 /*=====================================================================================================*/
3401 
3402 
3403 
3404 
3405 /*=======================================================================================================
3406 *
3407 * SgGuiTaskConfigDialog's METHODS:
3408 *
3409 *======================================================================================================*/
3410 //
3412  SgVlbiSession* session, QWidget *parent, Qt::WindowFlags f)
3413  : QDialog(parent, f)
3414 {
3415  config_ = config;
3416  parametersDescriptor_ = parDescriptor;
3417  session_ = session;
3418 
3419  QPushButton *button;
3420  QBoxLayout *layout, *subLayout;
3421  QFrame *bar;
3422 
3423  layout = new QVBoxLayout(this);
3425  layout->addWidget(configWidget_);
3426 
3427  bar = new QFrame(this);
3428  bar->setFrameStyle(QFrame::HLine | QFrame::Sunken);
3429  layout->addWidget(bar);
3430 
3431  subLayout = new QHBoxLayout();
3432  layout->addLayout(subLayout);
3433  subLayout->addStretch(1);
3434 
3435  subLayout->addWidget(button=new QPushButton("Close", this));
3436  button->setMinimumSize(button->sizeHint());
3437  connect(button, SIGNAL(clicked()), SLOT(accept()));
3438 
3439  setWindowTitle("General Configure Editor");
3440 };
3441 
3442 
3443 
3444 //
3446 {
3447  delete configWidget_;
3448  configWidget_ = NULL;
3449  config_ = NULL;
3450  parametersDescriptor_ = NULL;
3451  session_ = NULL;
3452  emit windowClosed();
3453 };
3454 
3455 
3456 
3457 //
3459 {
3460  QDialog::accept();
3461  deleteLater();
3462 };
3463 /*=====================================================================================================*/
const QString sCableCalSourceNames[4]
QList< SgVlbiNetworkId > networks
const QString defaultNetIdName
bool isAttr(uint a) const
Definition: SgAttribute.h:226
SgTaskConfig * config_
SgGuiTaskConfigDialog(SgTaskConfig *, SgParametersDescriptor *, SgVlbiSession *, QWidget *=NULL, Qt::WindowFlags=0)
SgGuiTaskConfig * configWidget_
SgVlbiSession * session_
SgParametersDescriptor * parametersDescriptor_
void changeAA_FinalSolution(int)
QLineEdit * leOPThreshold_
void changeODC_HiFqTidalUt1(int)
void changeEF_SourceSsm(int)
QCheckBox * cbExtAPrioriSitesVelocities_
QCheckBox * cbExtAPrioriSourcesPositions_
void changeAS_ini4del(const QString &)
QWidget * makeTab4models()
QList< QRadioButton * > stcParsButtons_
void changeODC_HiFqLibrationPxy(int)
void updateRateTypeSelection(int)
QButtonGroup * bgBlnClock_
void changeODC_TropRefractionDry(int)
QCheckBox * cbUseSolveObsSuppresionFlags_
QButtonGroup * bgZenith_
void changeAA_ReportNotUsed(int)
QCheckBox * cbIsNoviceUser_
QCheckBox * cbH2AppNwetContrib_
void netIdCurrentIndexChanged(const QString &)
QLineEdit * leMinSigma4Del_
QCheckBox * cbApDoIonoCorrection4SBD_
void changeOP_IsSolveCompatible(int)
void changeEF_SiteVelocitiesFileName(const QString &)
void editParameterCfg4BlnLength()
void changeOP_DoNotNormalize(int)
void editParameterCfg4EopNutationRate()
QCheckBox * cbH2AppOceanTide_
void modifyEstimatorPwlMode(int)
QCheckBox * cbH2AppNdryContrib_
QLineEdit * leExtAPrioriSitesPositions_
bool isOutliersProcessingThresholdModified_
SgVlbiSession * session_
void paramaters4BlnLengthModified(int)
QPushButton * pbApDestroy_
void changeODC_HiFqLibrationUt1(int)
QButtonGroup * bgPwlModes_
void paramaters4EopNutationModified(int)
void changeEF_MeanGradientsFileName(const QString &)
void changeODC_OceanPoleTide(int)
void changeEF_SiteVelocities(int)
QButtonGroup * bgDelTypes_
QSpinBox * sbQualityCodeThreshold_
QLineEdit * leEccentricities_
void changeODC_HiFqTidalPxy(int)
QCheckBox * cbH2AppAxisOffsetContrib_
QLineEdit * leExtAPrioriHiFyEop_
void checkStcParChackBoxesStatus(bool)
void changeODC_TiltRmvr(int)
QCheckBox * cbH2AppTiltRmvr_
QWidget * makeTab4Operations()
void createAutomaticProcessing4NetId()
QLineEdit * leExtAPrioriSitesVelocities_
QCheckBox * cbH2AppOceanPoleTideLd_
QButtonGroup * bgEopUtRate_
void changeEF_HiFyEop(int)
void paramaters4BlnClockModified(int)
QLineEdit * leIniSigma4Rat_
QCheckBox * cbH2AppHfNutation_
QCheckBox * cbH2AppOldPoleTide_
QCheckBox * cbSuppressWCinOP_
void changeCompat_UseSolveElimFlags(int)
QGroupBox * gbAutoAction_
void flybyRefrMapFModified(int n)
QButtonGroup * bgApFinalSolution_
void changeODC_OceanTide(int)
void changeAA_Outliers(int)
QWidget * makeTab4GeneralOptions()
QCheckBox * cbApDoWeights_
void paramaters4EopUt1RateModified(int)
QButtonGroup * bgAxsOffset_
void updateDelayTypeSelection(int)
QCheckBox * cbUseExtWeights_
QCheckBox * cbHave2outputCovarMatrix_
void destroyAutomaticProcessing4NetId()
SgGuiQTreeWidgetExt * tweUserCorrections_
void editParameterCfg4EopUt1Rate()
void outliersProcessingModeModified(int)
void displayParametersDesriptor()
void changeODC_GpsIono(int)
QButtonGroup * bgStnCoord_
void editParameterCfg4EopPolarRate()
QLineEdit * leOPIterationsLimit_
void changeGUI_activeBand(int)
void flybySourceCccFModified(int n)
void changeEF_MeanGradients(int)
QCheckBox * cbH2AppGpsIono_
void changeAA_Reweighting(int)
QCheckBox * cbH2AppHfTidalPxy_
void changeAS_min4del(const QString &)
SgParametersDescriptor * parametersDescriptor_
void paramaters4EopUt1Modified(int)
void outliersProcessingActionModified(int)
void paramaters4EopPolarMotionModified(int)
QCheckBox * cbDoReweighting_
void changePRA_Iono4SBD(int)
void changeEF_SourceSsmFileName(const QString &)
QButtonGroup * bgSrcSsm_
void changeODC_TropRefractionWet(int)
void changeEF_SitePositions(int)
QButtonGroup * bgRWModes_
QCheckBox * cbUseQualityCodeG_
QLineEdit * leMinSigma4Rat_
QCheckBox * cbH2AppPoleTide_
void changeODC_AxisOffset(int)
void changeODC_SolidEarthTide(int)
QButtonGroup * bgClocks_
QWidget * tabModels_
void changeEF_AxisOffsetFileName(const QString &)
void changeUseQualityCodeH(int)
void paramaters4TestModified(int)
QCheckBox * cbH2AppOldOceanTide_
void changeAA_Iono4SBD(int)
QWidget * tabGeneralOptions_
QLineEdit * leExtAPrioriAxisOffsets_
void changeEF_EopFileName(const QString &)
void changeEF_SitePositionsFileName(const QString &)
QButtonGroup * bgTest_
QButtonGroup * bgFlybyRefrMapF_
void changeHave2outputCovarMatrix(int)
void paramaters4StnPosModified(int)
QCheckBox * cbApDoSessionSetup_
QButtonGroup * bgSrcCoord_
void changeODC_FeedCorr(int)
void paramaters4SrcSsmModified(int)
void modifyReweightingMode(int)
QCheckBox * cbApDoClockBreaksDetection_
void changePRA_OutliersEliminationMode1(int)
void changeODC_OldOceanTide(int)
void changeODC_HiFqNutation(int)
void delayTypeModified(SgTaskConfig::VlbiDelayType)
QCheckBox * cbIsTesting_
void changeAA_ClockBreaks(int)
void changeODC_PoleTide(int)
QCheckBox * cbApDoOutliers_
QCheckBox * cbUseQualityCodeH_
void qualityCodeThresholdModified(int)
QCheckBox * cbH2AppHfTidalUt1_
QButtonGroup * bgOPActions_
QCheckBox * cbOPSolveCompatible_
QCheckBox * cbIsActiveBandFollowsTab_
QCheckBox * cbH2AppHfLibrationUt1_
void changeAS_ini4rat(const QString &)
void paramaters4AxsOfsModified(int)
void paramaters4AtmGrdModified(int)
QCheckBox * cbExtAPrioriErp_
void goodQualityCodeAtStartupModified(int)
void changeEF_SourcePositions(int)
void changeDoDownWeight(int)
void toggleEntryMoveEnable(QTreeWidgetItem *, int, Qt::MouseButton, Qt::KeyboardModifiers)
QButtonGroup * bgOPModes_
void changeEF_HiFyEopFileName(const QString &)
QCheckBox * cbH2AppEarthTide_
void changePRA_CBDetectionMode1(int)
void changeUseQualityCodeG(int)
SgTaskConfig * config_
void paramaters4ClocksModified(int)
void changeEF_WeightsFileName(const QString &)
QGroupBox * gbApFinalSolution_
QButtonGroup * bgEopUt_
SgGuiTaskConfig(SgTaskConfig *, SgParametersDescriptor *, SgVlbiSession *, QWidget *, Qt::WindowFlags=Qt::Widget)
void changeAA_Iono4All(int)
QLineEdit * leExtAPrioriSourcesPositions_
void paramaters4EopPolarMotionRateModified(int)
void changeOP_WcSuppresion(int)
void clocksModelChanged(SgParameterCfg::PMode)
QButtonGroup * bgBands_
QCheckBox * cbIsObservableFollowsPlot_
QCheckBox * cbApDoReportNotUsedData_
void changeRTA_WeightCorrection(int)
void changeEF_AxisOffset(int)
QLineEdit * leIniSigma4Del_
QCheckBox * cbUseDynamicClockBreaks_
void changeODC_PolarMotion(int)
QCheckBox * cbExtAPrioriSitesPositions_
QCheckBox * cbUseGoodQualityCodeAtStartup_
QButtonGroup * bgEopNut_
void paramaters4SrcPosModified(int)
QCheckBox * cbDoDownWeight_
QLineEdit * leExtAPrioriSourcesSsm_
QButtonGroup * bgEopPmRate_
QCheckBox * cbH2AppFeedCorr_
void editParameterCfg4EopPolar()
QCheckBox * cbExtAPrioriAxisOffsets_
QCheckBox * cbH2AppHfLibrationPxy_
void updateActiveBandSelection(int)
QLineEdit * leExtAPrioriMeanGradients_
void editParameterCfg4BlnClock()
void changeCompatibility(int)
QCheckBox * cbIsSolveCompatible_
QPushButton * pbApCreate_
void outliersProcessingIterationsLimitModified(const QString &)
QCheckBox * cbH2AppPolarMotion_
QCheckBox * cbH2AppSourceSsm_
void changeGUI_observable(int)
void changeEF_EccentricitiesFileName(const QString &)
void editParameterCfg4EopNutation()
void paramaters4EopNutationRateModified(int)
QButtonGroup * bgEopPm_
QCheckBox * cbOPDoNotNormalize_
void changeEF_SourcePositionsFileName(const QString &)
QSpinBox * sbGoodQualityCodeAtStartup_
QCheckBox * cbExtAPrioriHiFyEop_
QCheckBox * cbApDoIonoCorrection4All_
QCheckBox * cbExtAPrioriSourcesSsm_
void band2UseModified(int)
void changeODC_OldPoleTide(int)
void paramaters4ZenithModified(int)
QButtonGroup * bgRatTypes_
void outliersProcessingThresholdModified(const QString &)
QList< QRadioButton * > ratTypeButtons_
QLineEdit * leUseExtWeights_
void changeRTA_UseExternalWeights(int)
void changeODC_SourceSsm(int)
QCheckBox * cbExtAPrioriMeanGradients_
QWidget * tabOperations_
QLineEdit * leExtAPrioriErp_
void rateTypeModified(SgTaskConfig::VlbiRateType)
void changeAS_min4rat(const QString &)
void changeAA_SessionSetup(int)
QCheckBox * cbApDoAmbigResolution_
void zenithModelChanged(SgParameterCfg::PMode)
QWidget * makeTab4pia()
QComboBox * cbNetID_
void changeIsNoviceUser(int)
QButtonGroup * bgBlnVector_
QButtonGroup * bgFlybySrcCcc_
void changeDynamicClockBreaks(int)
void changeUseGoodQualityCodeAtStartup(int)
QButtonGroup * bgAtmGrads_
double getDversion() const
Definition: SgModelsInfo.h:114
PMode getPMode() const
const SgParameterCfg & getBlClock() const
const SgParameterCfg & getZenith() const
void setSrcSsmMode(SgParameterCfg::PMode mode)
const SgParameterCfg & getAxisOffset() const
const SgParameterCfg & getPolusUT1Rate() const
const SgParameterCfg & getSrcSsm() const
const SgParameterCfg & getSrcCoo() const
void setAtmGradMode(SgParameterCfg::PMode mode)
void setPolusUT1RateMode(SgParameterCfg::PMode mode)
void setClock1Mode(SgParameterCfg::PMode mode)
const SgParameterCfg & getBlLength() const
const SgParameterCfg & getAtmGrad() const
void setClock0Mode(SgParameterCfg::PMode mode)
const SgParameterCfg & getPolusUT1() const
void setAxisOffsetMode(SgParameterCfg::PMode mode)
const SgParameterCfg & getPolusXY() const
void setBlLengthMode(SgParameterCfg::PMode mode)
void setSrcCooMode(SgParameterCfg::PMode mode)
void setPolusUT1Mode(SgParameterCfg::PMode mode)
const SgParameterCfg & getPolusNut() const
void setStnCooMode(SgParameterCfg::PMode mode)
const SgParameterCfg & getClock0() const
SgParameterCfg & parameter(ParIdx i)
void setTestMode(SgParameterCfg::PMode mode)
void setPolusXYMode(SgParameterCfg::PMode mode)
void setBlClockMode(SgParameterCfg::PMode mode)
const SgParameterCfg & getPolusXYRate() const
void setClock2Mode(SgParameterCfg::PMode mode)
void setPolusNutMode(SgParameterCfg::PMode mode)
const SgParameterCfg & getTest() const
void setPolusNutRateMode(SgParameterCfg::PMode mode)
const SgParameterCfg & getStnCoo() const
@ Idx_SRCCOO
index for source coordinates
@ Idx_POLUSXY
index for EOP: polar motion
@ Idx_POLUSXYR
index for EOP: polar motion
@ Idx_STNCOO
index for station coordinates
@ Idx_POLUSUT1R
index for EOP: d(UT1-UTC) Rate
@ Idx_ATMGRAD
index for atmospheric gradients
@ Idx_POLUSNUT
index for EOP: nutation angles
@ Idx_POLUSUT1
index for EOP: d(UT1-UTC)
@ Idx_POLUSNUTR
index for EOP: nutation angles
@ Idx_TEST
index for test purposes
@ Idx_BL_CLK
index for baseline clocks
@ Idx_SRCSSM
index for source SSM
@ Idx_BL_LENGTH
index for baseline length
@ Idx_ZENITH
index for wet zenith delay
@ Idx_CLOCK_0
index for clocks (order #0)
@ Idx_AXISOFFSET
index for axis offset
void setPolusXYRateMode(SgParameterCfg::PMode mode)
void setClock3Mode(SgParameterCfg::PMode mode)
void setZenithMode(SgParameterCfg::PMode mode)
void setUseExtAPrioriHiFyErp(bool)
const QString & getEccentricitiesFileName() const
void setHave2ApplyUt1OceanTideHFContrib(bool b)
Definition: SgTaskConfig.h:616
bool getUseQualityCodeH() const
Definition: SgTaskConfig.h:849
bool getHave2ApplyNutationHFContrib() const
Definition: SgTaskConfig.h:386
bool getIsTesting() const
const QString & getExtAPrioriSitesVelocitiesFileName() const
bool getIsObservableFollowsPlot() const
const QString & getExtWeightsFileName() const
Definition: SgTaskConfig.h:969
bool getUseExtAPrioriSitesVelocities() const
void setUseGoodQualityCodeAtStartup(bool)
void setHave2ApplyGpsIonoContrib(bool b)
Definition: SgTaskConfig.h:614
bool getHave2ApplyOldPoleTideContrib() const
Definition: SgTaskConfig.h:393
void setHave2ApplySourceSsm(bool b)
Definition: SgTaskConfig.h:615
void setExtAPrioriMeanGradientsFileName(const QString &)
void setInitAuxSigma4Rate(double s)
Definition: SgTaskConfig.h:481
void setUseExtAPrioriSitesVelocities(bool)
void setDoIonoCorrection4SBD(bool)
void setUseExtAPrioriAxisOffsets(bool)
void setDoWeightCorrection(bool)
bool getUseExtAPrioriSourceSsm() const
void setExtAPrioriHiFyErpFileName(const QString &)
void setUseQualityCodeG(bool)
OutliersProcessingMode getOpMode() const
Definition: SgTaskConfig.h:977
bool getUseExtAPrioriHiFyErp() const
double getMinAuxSigma4Rate() const
Definition: SgTaskConfig.h:242
void setUseExternalWeights(bool)
void setHave2ApplyEarthTideContrib(bool b)
Definition: SgTaskConfig.h:611
bool getUseExtAPrioriSitesPositions() const
bool getUseExtAPrioriErp() const
bool getOpIsSolveCompatible() const
void setUseRateType(VlbiRateType)
void setWcMode(WeightCorrectionMode)
bool getIsSolveCompatible() const
Definition: SgTaskConfig.h:913
void setIsObservableFollowsPlot(bool)
void setHave2ApplyOceanPoleTideContrib(bool b)
Definition: SgTaskConfig.h:621
void setHave2ApplyTiltRemvrContrib(bool b)
Definition: SgTaskConfig.h:623
bool getDoDownWeight() const
Definition: SgTaskConfig.h:961
VlbiDelayType getUseDelayType() const
Definition: SgTaskConfig.h:873
bool getDoWeightCorrection() const
Definition: SgTaskConfig.h:905
bool getUseExtAPrioriMeanGradients() const
void setFlybyCableCalSource(CableCalSource c)
Definition: SgTaskConfig.h:633
void setExtWeightsFileName(const QString &)
CableCalSource getFlybyCableCalSource() const
Definition: SgTaskConfig.h:401
bool getHave2ApplyEarthTideContrib() const
Definition: SgTaskConfig.h:379
EstimatorPwlMode getPwlMode() const
Definition: SgTaskConfig.h:953
void setDoClockBreakDetectionMode1(bool)
void setDoDownWeight(bool)
WeightCorrectionMode getWcMode() const
Definition: SgTaskConfig.h:945
void setOpThreshold(double)
void setIsNoviceUser(bool is)
Definition: SgTaskConfig.h:527
int getGoodQualityCodeAtStartup() const
Definition: SgTaskConfig.h:857
void setGoodQualityCodeAtStartup(int)
const QString & getExtAPrioriSitesPositionsFileName() const
void setDoOutliersEliminationMode1(bool)
const QString & getExtAPrioriHiFyErpFileName() const
void setExtAPrioriSourcesPositionsFileName(const QString &)
QMap< QString, AutomaticProcessing > & apByNetId()
Definition: SgTaskConfig.h:637
void setFlybyTropZenithMap(TropZenithMap m)
Definition: SgTaskConfig.h:632
bool getUseExternalWeights() const
Definition: SgTaskConfig.h:937
void setInitAuxSigma4Delay(double s)
Definition: SgTaskConfig.h:480
bool getHave2ApplyOceanTideContrib() const
Definition: SgTaskConfig.h:380
void setActiveBandIdx(int)
int getQualityCodeThreshold() const
Definition: SgTaskConfig.h:833
bool getUseExtAPrioriSourcesPositions() const
void setEccentricitiesFileName(const QString &)
double getMinAuxSigma4Delay() const
Definition: SgTaskConfig.h:241
void setIsActiveBandFollowsTab(bool)
double getInitAuxSigma4Delay() const
Definition: SgTaskConfig.h:243
void setIsSolveCompatible(bool)
bool getHave2ApplyNdryContrib() const
Definition: SgTaskConfig.h:397
VlbiRateType getUseRateType() const
Definition: SgTaskConfig.h:881
void setUseExtAPrioriMeanGradients(bool)
bool getHave2ApplyUt1OceanTideHFContrib() const
Definition: SgTaskConfig.h:384
bool getIsNoviceUser() const
Definition: SgTaskConfig.h:294
bool getUseQualityCodeG() const
Definition: SgTaskConfig.h:841
void setUseQualityCodeH(bool)
bool getHave2ApplyPxyOceanTideHFContrib() const
Definition: SgTaskConfig.h:385
void setUseExtAPrioriSourceSsm(bool)
void setPwlMode(EstimatorPwlMode)
const QString & getLastModifiedNetId() const
Definition: SgTaskConfig.h:403
void setHave2ApplyOceanTideContrib(bool b)
Definition: SgTaskConfig.h:612
bool getHave2ApplyOldOceanTideContrib() const
Definition: SgTaskConfig.h:392
void setUseSolveObsSuppresionFlags(bool)
void setOpIsSolveCompatible(bool)
void setExtAPrioriSourceSsmFileName(const QString &)
bool getHave2ApplyPoleTideContrib() const
Definition: SgTaskConfig.h:381
bool getUseExtAPrioriAxisOffsets() const
void setHave2ApplyPoleTideContrib(bool b)
Definition: SgTaskConfig.h:613
void setExtAPrioriSitesVelocitiesFileName(const QString &)
bool getHave2ApplyGpsIonoContrib() const
Definition: SgTaskConfig.h:382
void setHave2ApplyOldPoleTideContrib(bool b)
Definition: SgTaskConfig.h:625
bool getIsActiveBandFollowsTab() const
void setOpHave2SuppressWeightCorrection(bool)
bool getHave2ApplyPxyLibrationContrib() const
Definition: SgTaskConfig.h:388
void setHave2outputCovarMatrix(bool have2)
Definition: SgTaskConfig.h:529
void setHave2ApplyNdryContrib(bool b)
Definition: SgTaskConfig.h:629
void setHave2ApplyPxyOceanTideHFContrib(bool b)
Definition: SgTaskConfig.h:617
bool getUseSolveObsSuppresionFlags() const
Definition: SgTaskConfig.h:929
bool getHave2ApplyTiltRemvrContrib() const
Definition: SgTaskConfig.h:391
TropZenithMap getFlybyTropZenithMap() const
Definition: SgTaskConfig.h:400
bool getUseDynamicClockBreaks() const
Definition: SgTaskConfig.h:921
void setMinAuxSigma4Rate(double s)
Definition: SgTaskConfig.h:479
void setOpMode(OutliersProcessingMode)
int getOpIterationsLimit() const
void setUseExtAPrioriErp(bool)
bool getOpHave2NormalizeResiduals() const
void setOpIterationsLimit(int)
void setExtAPrioriErpFileName(const QString &)
void setUseExtAPrioriSourcesPositions(bool)
void setExtAPrioriAxisOffsetsFileName(const QString &)
const QString & getExtAPrioriMeanGradientsFileName() const
void setHave2ApplyNwetContrib(bool b)
Definition: SgTaskConfig.h:630
void setQualityCodeThreshold(int)
void setOpHave2NormalizeResiduals(bool)
void setHave2ApplyOldOceanTideContrib(bool b)
Definition: SgTaskConfig.h:624
const QString & getExtAPrioriSourcesPositionsFileName() const
bool getHave2ApplySourceSsm() const
Definition: SgTaskConfig.h:383
bool getHave2ApplyPxContrib() const
Definition: SgTaskConfig.h:377
bool getHave2ApplyOceanPoleTideContrib() const
Definition: SgTaskConfig.h:389
double getOpThreshold() const
Definition: SgTaskConfig.h:993
void setHave2ApplyPxyLibrationContrib(bool b)
Definition: SgTaskConfig.h:620
void setMinAuxSigma4Delay(double s)
Definition: SgTaskConfig.h:478
void setUseDelayType(VlbiDelayType)
void setIsTesting(bool)
void setHave2ApplyPyContrib(bool b)
Definition: SgTaskConfig.h:610
bool getHave2outputCovarMatrix() const
Definition: SgTaskConfig.h:296
bool getUseGoodQualityCodeAtStartup() const
Definition: SgTaskConfig.h:865
double getInitAuxSigma4Rate() const
Definition: SgTaskConfig.h:244
void setHave2ApplyPxContrib(bool b)
Definition: SgTaskConfig.h:609
void setHave2ApplyFeedCorrContrib(bool b)
Definition: SgTaskConfig.h:622
const QString & getExtAPrioriAxisOffsetsFileName() const
void setUseDynamicClockBreaks(bool)
void setHave2ApplyNutationHFContrib(bool b)
Definition: SgTaskConfig.h:618
void setHave2ApplyUt1LibrationContrib(bool b)
Definition: SgTaskConfig.h:619
void setHave2ApplyAxisOffsetContrib(bool b)
Definition: SgTaskConfig.h:627
void setUseExtAPrioriSitesPositions(bool)
int getActiveBandIdx() const
Definition: SgTaskConfig.h:889
bool getHave2ApplyFeedCorrContrib() const
Definition: SgTaskConfig.h:390
bool getHave2ApplyNwetContrib() const
Definition: SgTaskConfig.h:398
bool getOpHave2SuppressWeightCorrection() const
const QString & getExtAPrioriErpFileName() const
void setLastModifiedNetId(const QString &netId)
Definition: SgTaskConfig.h:635
bool getHave2ApplyUt1LibrationContrib() const
Definition: SgTaskConfig.h:387
void setOpAction(OutliersProcessingAction)
void setExtAPrioriSitesPositionsFileName(const QString &)
OutliersProcessingAction getOpAction() const
Definition: SgTaskConfig.h:985
bool getHave2ApplyAxisOffsetContrib() const
Definition: SgTaskConfig.h:395
const QString & getExtAPrioriSourceSsmFileName() const
SgModelsInfo & calcInfo()
QList< SgVlbiBand * > & bands()
const QVector< QString > & getUserCorrectionsName() const
bool hasPxyLibrationContrib() const
const QVector< bool > & getUserCorrectionsUse() const
bool hasOceanPoleTideContrib() const
QMap< QString, SgVlbiStationInfo * > & stationsByName()
bool hasWobblePyContrib() const
bool hasGpsIonoContrib() const
bool hasOceanTideOldContrib() const
bool hasNdryContrib() const
bool hasUt1LibrationContrib() const
bool hasWobbleHighFreqContrib() const
bool hasUt1HighFreqContrib() const
bool hasFeedCorrContrib() const
bool hasEarthTideContrib() const
bool hasWobbleNutContrib() const
bool hasPoleTideContrib() const
bool hasWobblePxContrib() const
bool hasTiltRemvrContrib() const
bool hasOceanTideContrib() const
bool hasNwetContrib() const
QVector< bool > & userCorrectionsUse()
bool hasPoleTideOldContrib() const
@ Attr_HAS_CCC_CDMS
a station has cable calibrations from CDMS
@ Attr_HAS_CCC_PCMT
a station has cable calibrations from PCMT
SgTaskConfig config
Definition: nuSolve.cpp:59
SgParametersDescriptor parametersDescriptor
Definition: nuSolve.cpp:60