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  layout->addStretch(1);
1275  //
1276  // end of fly by models...
1277  hLayout->addWidget(gboxFBM);
1278  //
1279  //
1280  //
1281  // right column:
1282  if (session_ && session_->getUserCorrectionsName().size()) // can be NULL:
1283  {
1284  //
1285  // external files with a priori information:
1286  QGroupBox *gboxUC=new QGroupBox("Apply user provided corrections", w);
1287  QBoxLayout *layout=new QVBoxLayout(gboxUC);
1288  //
1289  // attach the widget:
1290  layoutB->addWidget(gboxUC);
1291 
1292  QStringList headerLabels;
1293  headerLabels << "User correction" << "Apply?";
1294  //
1296  tweUserCorrections_->setColumnCount(headerLabels.count());
1297  tweUserCorrections_->setHeaderLabels(headerLabels);
1298  for (int i=0; i<session_->getUserCorrectionsName().size(); i++)
1299  {
1302  item->setText(0, session_->getUserCorrectionsName().at(i));
1303  item->setData(0, Qt::TextAlignmentRole, Qt::AlignLeft);
1304  item->setText(1, session_->getUserCorrectionsUse().at(i)?"Y":"");
1305  item->setData(1, Qt::TextAlignmentRole, Qt::AlignCenter);
1306  };
1307  tweUserCorrections_->header()->resizeSections(QHeaderView::ResizeToContents);
1308  tweUserCorrections_->header()->setSectionResizeMode(QHeaderView::Interactive);
1309  tweUserCorrections_->header()->setStretchLastSection(false);
1310  tweUserCorrections_->setSortingEnabled(true);
1311  tweUserCorrections_->setUniformRowHeights(true);
1312  tweUserCorrections_->sortByColumn(1, Qt::AscendingOrder);
1313  tweUserCorrections_->setFocus();
1314  tweUserCorrections_->setItemsExpandable(false);
1315  tweUserCorrections_->setAllColumnsShowFocus(true);
1316 
1317  layout->addWidget(tweUserCorrections_);
1318 
1319  connect(tweUserCorrections_,
1320  SIGNAL(moveUponItem(QTreeWidgetItem*, int, Qt::MouseButton, Qt::KeyboardModifiers)),
1321  SLOT (toggleEntryMoveEnable(QTreeWidgetItem*, int, Qt::MouseButton, Qt::KeyboardModifiers)));
1322  };
1323  //
1324  //
1325  //
1326  // set check states after creation of QLineEditors and other objects:
1327  cbExtAPrioriSitesPositions_->setCheckState(
1328  config_->getUseExtAPrioriSitesPositions()?Qt::Checked:Qt::Unchecked);
1329  cbExtAPrioriSitesVelocities_->setCheckState(
1330  config_->getUseExtAPrioriSitesVelocities()?Qt::Checked:Qt::Unchecked);
1331  cbExtAPrioriSourcesPositions_->setCheckState(
1332  config_->getUseExtAPrioriSourcesPositions()?Qt::Checked:Qt::Unchecked);
1333  cbExtAPrioriSourcesSsm_->setCheckState(config_->getUseExtAPrioriSourceSsm()?Qt::Checked:Qt::Unchecked);
1334  cbExtAPrioriErp_->setCheckState(config_->getUseExtAPrioriErp()? Qt::Checked:Qt::Unchecked);
1335  cbExtAPrioriAxisOffsets_->setCheckState(
1336  config_->getUseExtAPrioriAxisOffsets()?Qt::Checked:Qt::Unchecked);
1337  cbExtAPrioriHiFyEop_->setCheckState(config_->getUseExtAPrioriHiFyErp()?Qt::Checked:Qt::Unchecked);
1338  cbExtAPrioriMeanGradients_->setCheckState(
1339  config_->getUseExtAPrioriMeanGradients()?Qt::Checked:Qt::Unchecked);
1348  //
1349  //
1350  //
1351  if (cbH2AppNdryContrib_->checkState() == Qt::Checked ||
1352  cbH2AppNwetContrib_->checkState() == Qt::Checked )
1353  for (int i=0; i<bgFlybyRefrMapF_->buttons().size(); i++)
1354  bgFlybyRefrMapF_->buttons()[i]->setEnabled(false);
1355 
1356  if (bgFlybyRefrMapF_->checkedId() != 0)
1357  {
1358  cbH2AppNdryContrib_->setEnabled(false);
1359  cbH2AppNwetContrib_->setEnabled(false);
1360  };
1361  //
1362 //-->> mainLayout->addStretch(1);
1363 
1364  return w;
1365 };
1366 
1367 
1368 
1369 //
1371 {
1372  static const QString automaticFinalSolutionName[] =
1373  { QString("Baselines"),
1374  QString("dUT1") };
1375  static const int numOfAutomaticFinalSolutionNames = sizeof(automaticFinalSolutionName)/sizeof(QString);
1376  //
1377  QWidget *w=new QWidget(this);
1378  QBoxLayout *mainLayout=new QVBoxLayout(w);
1379  QBoxLayout *layout;
1380  QLabel *label;
1381 
1382  // Automatic actions setup:
1383  //
1384  label = new QLabel("Set up for network ID:", w);
1385  label->setMinimumSize(label->sizeHint());
1386  layout = new QHBoxLayout;
1387  mainLayout->addLayout(layout);
1388  layout->addWidget(label);
1389  //
1390  cbNetID_ = new QComboBox(w);
1391  cbNetID_->setMinimumSize(cbNetID_->sizeHint());
1392  layout->addStretch(1);
1393  layout->addWidget(cbNetID_);
1394  //
1395  gbAutoAction_ = new QGroupBox("Actions to perform:", w);
1396  mainLayout->addWidget(gbAutoAction_);
1397  layout = new QVBoxLayout(gbAutoAction_);
1398  //
1399  cbApDoSessionSetup_ = new QCheckBox("Perform set up of the session (reference clock station, etc.)",
1400  gbAutoAction_);
1401  layout->addWidget(cbApDoSessionSetup_);
1402  connect(cbApDoSessionSetup_, SIGNAL(stateChanged(int)), SLOT(changeAA_SessionSetup(int)));
1403  //
1404  cbApDoIonoCorrection4SBD_ = new QCheckBox("Evaluate ionospheric correction for single band delay",
1405  gbAutoAction_);
1406  layout->addWidget(cbApDoIonoCorrection4SBD_);
1407  connect(cbApDoIonoCorrection4SBD_, SIGNAL(stateChanged(int)), SLOT(changeAA_Iono4SBD(int)));
1408  //
1409  cbApDoAmbigResolution_ = new QCheckBox("Resolve group delay ambiguities", gbAutoAction_);
1410  layout->addWidget(cbApDoAmbigResolution_);
1411  connect(cbApDoAmbigResolution_, SIGNAL(stateChanged(int)), SLOT(changeAA_Ambigs(int)));
1412  //
1413  cbApDoClockBreaksDetection_ = new QCheckBox("Detect clock breaks", gbAutoAction_);
1414  layout->addWidget(cbApDoClockBreaksDetection_);
1415  connect(cbApDoClockBreaksDetection_, SIGNAL(stateChanged(int)), SLOT(changeAA_ClockBreaks(int)));
1416  //
1417  cbApDoIonoCorrection4All_ = new QCheckBox("Evaluate ionospheric correction for all observables",
1418  gbAutoAction_);
1419  layout->addWidget(cbApDoIonoCorrection4All_);
1420  connect(cbApDoIonoCorrection4All_, SIGNAL(stateChanged(int)), SLOT(changeAA_Iono4All(int)));
1421  //
1422  cbApDoOutliers_ = new QCheckBox("Process outliers", gbAutoAction_);
1423  layout->addWidget(cbApDoOutliers_);
1424  connect(cbApDoOutliers_, SIGNAL(stateChanged(int)), SLOT(changeAA_Outliers(int)));
1425  //
1426  cbApDoWeights_ = new QCheckBox("Perform weight corrections", gbAutoAction_);
1427  layout->addWidget(cbApDoWeights_);
1428  connect(cbApDoWeights_, SIGNAL(stateChanged(int)), SLOT(changeAA_Reweighting(int)));
1429  //
1430  cbApDoReportNotUsedData_ = new QCheckBox("Print a list of not used observations in a file",
1431  gbAutoAction_);
1432  layout->addWidget(cbApDoReportNotUsedData_);
1433  connect(cbApDoReportNotUsedData_, SIGNAL(stateChanged(int)), SLOT(changeAA_ReportNotUsed(int)));
1434  //
1435  // options:
1436  QRadioButton *rbFinSolTypes[numOfAutomaticFinalSolutionNames];
1437  gbApFinalSolution_ = new QGroupBox("Make Final Solution:", this);
1438  layout = new QVBoxLayout(gbApFinalSolution_);
1439  bgApFinalSolution_ = new QButtonGroup(gbApFinalSolution_);
1440  for (int i=0; i<numOfAutomaticFinalSolutionNames; i++)
1441  {
1442  rbFinSolTypes[i] = new QRadioButton(automaticFinalSolutionName[i], gbApFinalSolution_);
1443  rbFinSolTypes[i]-> setMinimumSize(rbFinSolTypes[i]->sizeHint());
1444  bgApFinalSolution_->addButton(rbFinSolTypes[i], i);
1445  layout->addWidget(rbFinSolTypes[i]);
1446  };
1447  connect(bgApFinalSolution_, SIGNAL(buttonClicked(int)), SLOT(changeAA_FinalSolution(int)));
1448  mainLayout->addWidget(gbApFinalSolution_);
1449  //
1450  //
1451  layout = new QHBoxLayout;
1452  mainLayout->addLayout(layout);
1453  pbApCreate_ = new QPushButton("Create", w);
1454  layout->addStretch(1);
1455  layout->addWidget(pbApCreate_);
1456  connect(pbApCreate_, SIGNAL(clicked()), SLOT(createAutomaticProcessing4NetId()));
1457  //
1458  pbApDestroy_ = new QPushButton("Destroy", w);
1459  layout->addWidget(pbApDestroy_);
1460  connect(pbApDestroy_, SIGNAL(clicked()), SLOT(destroyAutomaticProcessing4NetId()));
1461  //
1462  //
1463  // feed data into the ComboBox, all the checkboxes have to exist at this stage:
1464  bool isTmp(false);
1465  cbNetID_->setInsertPolicy(QComboBox::InsertAlphabetically);
1466  for (int i=0; i<networks.size(); i++)
1467  cbNetID_->addItem(networks.at(i).getName());
1468  connect(cbNetID_,
1469  SIGNAL(currentIndexChanged(const QString&)), SLOT(netIdCurrentIndexChanged(const QString&)));
1470 
1471  for (int i=0; i<networks.size(); i++)
1472  {
1473  if (networks.at(i).getName() == config_->getLastModifiedNetId())
1474  {
1475  cbNetID_->setCurrentIndex(i);
1476  if (i==0)
1478  isTmp = true;
1479  };
1480  };
1481  if (!isTmp)
1482  for (int i=0; i<networks.size(); i++)
1483  {
1484  if (networks.at(i).getName() == defaultNetIdName)
1485  cbNetID_->setCurrentIndex(i);
1486  };
1487  // end of automatic procession setup:
1488  mainLayout->addStretch(1);
1489 
1490  return w;
1491 };
1492 
1493 
1494 
1495 //
1497 {
1498  QMap<SgParameterCfg::PMode, int> idxByMode;
1499  idxByMode[SgParameterCfg::PM_NONE] = 0;
1500  idxByMode[SgParameterCfg::PM_GLB] = 1;
1501  idxByMode[SgParameterCfg::PM_LOC] = 1;
1502  idxByMode[SgParameterCfg::PM_ARC] = 2;
1503  idxByMode[SgParameterCfg::PM_PWL] = 3;
1504  idxByMode[SgParameterCfg::PM_STC] = 4;
1505 
1506  bgClocks_ ->button(idxByMode[parametersDescriptor_->getClock0() .getPMode()])->setChecked(true);
1507  bgZenith_ ->button(idxByMode[parametersDescriptor_->getZenith() .getPMode()])->setChecked(true);
1508  bgAtmGrads_ ->button(idxByMode[parametersDescriptor_->getAtmGrad() .getPMode()])->setChecked(true);
1509  bgStnCoord_ ->button(idxByMode[parametersDescriptor_->getStnCoo() .getPMode()])->setChecked(true);
1510  bgAxsOffset_->button(idxByMode[parametersDescriptor_->getAxisOffset() .getPMode()])->setChecked(true);
1511  bgSrcCoord_ ->button(idxByMode[parametersDescriptor_->getSrcCoo() .getPMode()])->setChecked(true);
1512  bgSrcSsm_ ->button(idxByMode[parametersDescriptor_->getSrcSsm() .getPMode()])->setChecked(true);
1513  bgEopPm_ ->button(idxByMode[parametersDescriptor_->getPolusXY() .getPMode()])->setChecked(true);
1514  bgEopPmRate_->button(idxByMode[parametersDescriptor_->getPolusXYRate().getPMode()])->setChecked(true);
1515  bgEopUt_ ->button(idxByMode[parametersDescriptor_->getPolusUT1() .getPMode()])->setChecked(true);
1516  bgEopUtRate_->button(idxByMode[parametersDescriptor_->getPolusUT1Rate().getPMode()])->setChecked(true);
1517  bgEopNut_ ->button(idxByMode[parametersDescriptor_->getPolusNut() .getPMode()])->setChecked(true);
1518  bgBlnClock_ ->button(idxByMode[parametersDescriptor_->getBlClock() .getPMode()])->setChecked(true);
1519  bgBlnVector_->button(idxByMode[parametersDescriptor_->getBlLength() .getPMode()])->setChecked(true);
1520  bgTest_ ->button(idxByMode[parametersDescriptor_->getTest() .getPMode()])->setChecked(true);
1521 };
1522 
1523 
1524 
1525 //
1527 {
1528  if (session_==NULL)
1529  return;
1530 
1531  QAbstractButton *b=NULL;
1532 
1533  // page one (general):
1534  b = bgDelTypes_->button(config_->getUseDelayType());
1535  if (b)
1536  {
1537  b->setChecked(true);
1539  };
1540  b = bgRatTypes_->button(config_->getUseRateType());
1541  if (b)
1542  {
1543  b->setChecked(true);
1545  };
1546  b = bgBands_->button(config_->getActiveBandIdx());
1547  if (b)
1548  {
1549  b->setChecked(true);
1551  };
1552 
1554  setCheckState(config_->getIsActiveBandFollowsTab()?Qt::Checked:Qt::Unchecked);
1556  setCheckState(config_->getIsObservableFollowsPlot()?Qt::Checked:Qt::Unchecked);
1558  //
1559  cbUseQualityCodeG_->setCheckState(config_->getUseQualityCodeG()?Qt::Checked:Qt::Unchecked);
1560  cbUseQualityCodeH_->setCheckState(config_->getUseQualityCodeH()?Qt::Checked:Qt::Unchecked);
1561  cbIsSolveCompatible_->setCheckState(config_->getIsSolveCompatible()?Qt::Checked:Qt::Unchecked);
1562  cbUseDynamicClockBreaks_->setCheckState(config_->getUseDynamicClockBreaks()?Qt::Checked:Qt::Unchecked);
1564  setCheckState(config_->getUseSolveObsSuppresionFlags()?Qt::Checked:Qt::Unchecked);
1566  setCheckState(config_->getUseGoodQualityCodeAtStartup()?Qt::Checked:Qt::Unchecked);
1568  cbIsNoviceUser_->setCheckState(config_->getIsNoviceUser()?Qt::Checked:Qt::Unchecked);
1570  Qt::Checked:Qt::Unchecked);
1571  cbIsTesting_->setCheckState(config_->getIsTesting()?Qt::Checked:Qt::Unchecked);
1572  //
1573  // page two (operations), except estimated parameters:
1574  b = bgPwlModes_->button(config_->getPwlMode());
1575  if (b)
1576  b->setChecked(true);
1577  b = bgOPActions_->button(config_->getOpAction());
1578  if (b)
1579  b->setChecked(true);
1580  b = bgOPModes_->button(config_->getOpMode());
1581  if (b)
1582  b->setChecked(true);
1583 
1584  leOPThreshold_->setText(QString("").sprintf("%.2f", config_->getOpThreshold()));
1585  leOPIterationsLimit_->setText(QString("").sprintf("%d", config_->getOpIterationsLimit()));
1587  setCheckState(config_->getOpHave2SuppressWeightCorrection()?Qt::Checked:Qt::Unchecked);
1588  cbOPSolveCompatible_->setCheckState(config_->getOpIsSolveCompatible()?Qt::Checked:Qt::Unchecked);
1589  cbOPDoNotNormalize_->setCheckState(config_->getOpHave2NormalizeResiduals()?Qt::Unchecked:Qt::Checked);
1590  cbDoReweighting_->setCheckState(config_->getDoWeightCorrection()?Qt::Checked:Qt::Unchecked);
1591  cbUseExtWeights_->setCheckState(config_->getUseExternalWeights()?Qt::Checked:Qt::Unchecked);
1592  b = bgRWModes_->button(config_->getWcMode());
1593  if (b)
1594  b->setChecked(true);
1597  leIniSigma4Del_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Delay()*1.0e12));
1598  leIniSigma4Rat_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Rate()*1.0e15));
1599  leMinSigma4Del_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Delay()*1.0e12));
1600  leMinSigma4Rat_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Rate()*1.0e15));
1601  //
1602  // page three (models):
1610 
1615 
1616  if (cbH2AppSourceSsm_->isEnabled())
1617  cbH2AppSourceSsm_->setCheckState(config_->getHave2ApplySourceSsm()?Qt::Checked:Qt::Unchecked);
1618 
1619  if (cbH2AppPolarMotion_->isEnabled())
1620  cbH2AppPolarMotion_->setCheckState(config_->getHave2ApplyPxContrib()?Qt::Checked:Qt::Unchecked);
1621  if (cbH2AppEarthTide_->isEnabled())
1622  cbH2AppEarthTide_->setCheckState(config_->getHave2ApplyEarthTideContrib()?Qt::Checked:Qt::Unchecked);
1623  if (cbH2AppOceanTide_->isEnabled())
1624  cbH2AppOceanTide_->setCheckState(config_->getHave2ApplyOceanTideContrib()?Qt::Checked:Qt::Unchecked);
1625  if (cbH2AppPoleTide_->isEnabled())
1626  cbH2AppPoleTide_->setCheckState(config_->getHave2ApplyPoleTideContrib()?Qt::Checked:Qt::Unchecked);
1627  if (cbH2AppOceanPoleTideLd_->isEnabled())
1629  setCheckState(config_->getHave2ApplyOceanPoleTideContrib()?Qt::Checked:Qt::Unchecked);
1630  if (cbH2AppGpsIono_->isEnabled())
1631  cbH2AppGpsIono_->
1632  setCheckState(config_->getHave2ApplyGpsIonoContrib()?Qt::Checked:Qt::Unchecked);
1633  if (cbH2AppOldOceanTide_->isEnabled())
1635  setCheckState(config_->getHave2ApplyOldOceanTideContrib()?Qt::Checked:Qt::Unchecked);
1636  if (cbH2AppOldPoleTide_->isEnabled())
1638  setCheckState(config_->getHave2ApplyOldPoleTideContrib()?Qt::Checked:Qt::Unchecked);
1639  if (cbH2AppHfTidalPxy_->isEnabled())
1641  setCheckState(config_->getHave2ApplyPxyOceanTideHFContrib()?Qt::Checked:Qt::Unchecked);
1642  if (cbH2AppHfTidalUt1_->isEnabled())
1644  setCheckState(config_->getHave2ApplyUt1OceanTideHFContrib()?Qt::Checked:Qt::Unchecked);
1645  if (cbH2AppHfLibrationPxy_ && cbH2AppHfLibrationPxy_->isEnabled())
1647  setCheckState(config_->getHave2ApplyPxyLibrationContrib()?Qt::Checked:Qt::Unchecked);
1648  if (cbH2AppHfLibrationUt1_ && cbH2AppHfLibrationUt1_->isEnabled())
1649  cbH2AppHfLibrationUt1_->setCheckState(
1650  config_->getHave2ApplyUt1LibrationContrib()?Qt::Checked:Qt::Unchecked);
1651  if (cbH2AppHfNutation_ && cbH2AppHfNutation_->isEnabled())
1653  setCheckState(config_->getHave2ApplyNutationHFContrib()?Qt::Checked:Qt::Unchecked);
1655  setCheckState(config_->getHave2ApplyAxisOffsetContrib()?Qt::Checked:Qt::Unchecked);
1657  setCheckState(config_->getHave2ApplyNdryContrib()?Qt::Checked:Qt::Unchecked);
1659  setCheckState(config_->getHave2ApplyNwetContrib()?Qt::Checked:Qt::Unchecked);
1660 
1661  if (cbH2AppFeedCorr_->isEnabled())
1662  cbH2AppFeedCorr_->setCheckState(config_->getHave2ApplyFeedCorrContrib()?Qt::Checked:Qt::Unchecked);
1663  if (cbH2AppTiltRmvr_->isEnabled())
1664  cbH2AppTiltRmvr_->setCheckState(config_->getHave2ApplyTiltRemvrContrib()?Qt::Checked:Qt::Unchecked);
1665  //
1667  setCheckState(config_->getUseExtAPrioriSitesPositions()?Qt::Checked:Qt::Unchecked);
1669  setCheckState(config_->getUseExtAPrioriSitesVelocities()?Qt::Checked:Qt::Unchecked);
1671  setCheckState(config_->getUseExtAPrioriSourcesPositions()?Qt::Checked:Qt::Unchecked);
1673  setCheckState(config_->getUseExtAPrioriSourceSsm()?Qt::Checked:Qt::Unchecked);
1674  cbExtAPrioriErp_->setCheckState(config_->getUseExtAPrioriErp()? Qt::Checked:Qt::Unchecked);
1676  setCheckState(config_->getUseExtAPrioriAxisOffsets()?Qt::Checked:Qt::Unchecked);
1677  cbExtAPrioriHiFyEop_->setCheckState(config_->getUseExtAPrioriHiFyErp()?Qt::Checked:Qt::Unchecked);
1679  setCheckState(config_->getUseExtAPrioriMeanGradients()?Qt::Checked:Qt::Unchecked);
1680  //
1689 };
1690 
1691 
1692 
1693 //
1695 {
1697  if (config_->apByNetId().contains(str))
1698  {
1699  ap = config_->apByNetId().value(str);
1700  gbAutoAction_->setEnabled(true);
1701  gbApFinalSolution_->setEnabled(true);
1702  pbApCreate_->setEnabled(false);
1703  pbApDestroy_->setEnabled(str!=defaultNetIdName);
1705  }
1706  else
1707  {
1708  gbAutoAction_->setEnabled(false);
1709  gbApFinalSolution_->setEnabled(false);
1710  pbApCreate_->setEnabled(true);
1711  pbApDestroy_->setEnabled(false);
1712  };
1713  cbApDoSessionSetup_->setCheckState(ap.doSessionSetup_?Qt::Checked:Qt::Unchecked);
1714  cbApDoIonoCorrection4SBD_->setCheckState(ap.doIonoCorrection4SBD_?Qt::Checked:Qt::Unchecked);
1715  cbApDoAmbigResolution_->setCheckState(ap.doAmbigResolution_?Qt::Checked:Qt::Unchecked);
1716  cbApDoClockBreaksDetection_->setCheckState(ap.doClockBreaksDetection_?Qt::Checked:Qt::Unchecked);
1717  cbApDoIonoCorrection4All_->setCheckState(ap.doIonoCorrection4All_?Qt::Checked:Qt::Unchecked);
1718  cbApDoOutliers_->setCheckState(ap.doOutliers_?Qt::Checked:Qt::Unchecked);
1719  cbApDoWeights_->setCheckState(ap.doWeights_?Qt::Checked:Qt::Unchecked);
1720  cbApDoReportNotUsedData_->setCheckState(ap.doReportNotUsedData_?Qt::Checked:Qt::Unchecked);
1721  bgApFinalSolution_->button(ap.finalSolution_)->setChecked(true);
1722 };
1723 
1724 
1725 
1726 //
1728 {
1729  QString str=cbNetID_->currentText();
1730  if (config_->apByNetId().contains(str))
1731  config_->apByNetId()[str].doSessionSetup_ = state==Qt::Checked;
1732 };
1733 
1734 
1735 
1736 //
1738 {
1739  QString str=cbNetID_->currentText();
1740  if (config_->apByNetId().contains(str))
1741  config_->apByNetId()[str].doIonoCorrection4SBD_ = state==Qt::Checked;
1742 };
1743 
1744 
1745 
1746 //
1748 {
1749  QString str=cbNetID_->currentText();
1750  if (config_->apByNetId().contains(str))
1751  config_->apByNetId()[str].doAmbigResolution_ = state==Qt::Checked;
1752 };
1753 
1754 
1755 
1756 //
1758 {
1759  QString str=cbNetID_->currentText();
1760  if (config_->apByNetId().contains(str))
1761  config_->apByNetId()[str].doClockBreaksDetection_ = state==Qt::Checked;
1762 };
1763 
1764 
1765 
1766 //
1768 {
1769  QString str=cbNetID_->currentText();
1770  if (config_->apByNetId().contains(str))
1771  config_->apByNetId()[str].doIonoCorrection4All_ = state==Qt::Checked;
1772 };
1773 
1774 
1775 
1776 //
1778 {
1779  QString str=cbNetID_->currentText();
1780  if (config_->apByNetId().contains(str))
1781  config_->apByNetId()[str].doOutliers_ = state==Qt::Checked;
1782 };
1783 
1784 
1785 
1786 //
1788 {
1789  QString str=cbNetID_->currentText();
1790  if (config_->apByNetId().contains(str))
1791  config_->apByNetId()[str].doWeights_ = state==Qt::Checked;
1792 };
1793 
1794 
1795 
1796 //
1798 {
1799  QString str=cbNetID_->currentText();
1800  if (config_->apByNetId().contains(str))
1801  config_->apByNetId()[str].doReportNotUsedData_ = state==Qt::Checked;
1802 };
1803 
1804 
1805 
1806 //
1808 {
1809  QString str=cbNetID_->currentText();
1810  if (!config_->apByNetId().contains(str))
1811  return;
1812  switch (n)
1813  {
1814  default:
1815  case 0:
1817  break;
1818  case 1:
1820  break;
1821  };
1822 };
1823 
1824 
1825 
1826 //
1828 {
1829  QString str=cbNetID_->currentText();
1830  if (!config_->apByNetId().contains(str))
1831  {
1833  config_->apByNetId()[str] = ap;
1834  gbAutoAction_->setEnabled(true);
1835  gbApFinalSolution_->setEnabled(true);
1836  pbApCreate_->setEnabled(false);
1837  pbApDestroy_->setEnabled(true);
1838  cbApDoSessionSetup_->setCheckState(ap.doSessionSetup_?Qt::Checked:Qt::Unchecked);
1839  cbApDoIonoCorrection4SBD_->setCheckState(ap.doIonoCorrection4SBD_?Qt::Checked:Qt::Unchecked);
1840  cbApDoAmbigResolution_->setCheckState(ap.doAmbigResolution_?Qt::Checked:Qt::Unchecked);
1841  cbApDoClockBreaksDetection_->setCheckState(ap.doClockBreaksDetection_?Qt::Checked:Qt::Unchecked);
1842  cbApDoIonoCorrection4All_->setCheckState(ap.doIonoCorrection4All_?Qt::Checked:Qt::Unchecked);
1843  cbApDoOutliers_->setCheckState(ap.doOutliers_?Qt::Checked:Qt::Unchecked);
1844  cbApDoWeights_->setCheckState(ap.doWeights_?Qt::Checked:Qt::Unchecked);
1845  cbApDoReportNotUsedData_->setCheckState(ap.doReportNotUsedData_?Qt::Checked:Qt::Unchecked);
1846  bgApFinalSolution_->button(ap.finalSolution_)->setChecked(true);
1848  };
1849 };
1850 
1851 
1852 
1853 //
1855 {
1856  QString str=cbNetID_->currentText();
1857  if (config_->apByNetId().contains(str))
1858  {
1860  cbApDoSessionSetup_->setCheckState(ap.doSessionSetup_?Qt::Checked:Qt::Unchecked);
1861  cbApDoIonoCorrection4SBD_->setCheckState(ap.doIonoCorrection4SBD_?Qt::Checked:Qt::Unchecked);
1862  cbApDoAmbigResolution_->setCheckState(ap.doAmbigResolution_?Qt::Checked:Qt::Unchecked);
1863  cbApDoClockBreaksDetection_->setCheckState(ap.doClockBreaksDetection_?Qt::Checked:Qt::Unchecked);
1864  cbApDoIonoCorrection4All_->setCheckState(ap.doIonoCorrection4All_?Qt::Checked:Qt::Unchecked);
1865  cbApDoOutliers_->setCheckState(ap.doOutliers_?Qt::Checked:Qt::Unchecked);
1866  cbApDoWeights_->setCheckState(ap.doWeights_?Qt::Checked:Qt::Unchecked);
1867  cbApDoReportNotUsedData_->setCheckState(ap.doReportNotUsedData_?Qt::Checked:Qt::Unchecked);
1868  bgApFinalSolution_->button(ap.finalSolution_)->setChecked(true);
1869  config_->apByNetId().remove(str);
1870  gbAutoAction_->setEnabled(false);
1871  gbApFinalSolution_->setEnabled(false);
1872  pbApCreate_->setEnabled(true);
1873  pbApDestroy_->setEnabled(false);
1875  };
1876 };
1877 
1878 
1879 
1880 //
1882 {
1886  e->show();
1887 };
1888 
1889 
1890 
1891 //
1893 {
1897  e->show();
1898 };
1899 
1900 
1901 
1902 //
1904 {
1908  e->show();
1909 };
1910 
1911 
1912 
1913 //
1915 {
1919  e->show();
1920 };
1921 
1922 
1923 
1924 //
1926 {
1930  e->show();
1931 };
1932 
1933 
1934 
1935 //
1937 {
1941  e->show();
1942 };
1943 
1944 
1945 
1946 //
1948 {
1952  e->show();
1953 };
1954 
1955 
1956 
1957 //
1959 {
1963  e->show();
1964 };
1965 
1966 
1967 
1968 //
1970 {
1974  e->show();
1975 };
1976 
1977 
1978 
1979 //
1981 {
1985  e->show();
1986 };
1987 
1988 
1989 
1990 //
1992 {
1996  e->show();
1997 };
1998 
1999 
2000 
2001 //
2003 {
2007  e->show();
2008 };
2009 
2010 
2011 
2012 //
2014 {
2018  e->show();
2019 };
2020 
2021 
2022 
2023 //
2025 {
2029  e->show();
2030 };
2031 
2032 
2033 
2034 //
2036 {
2040  e->show();
2041 };
2042 
2043 
2044 
2045 //
2047 {
2051  e->show();
2052 };
2053 
2054 
2055 
2056 //
2058 {
2060  switch (n)
2061  {
2062  default:
2063  case 0:
2064  dType = SgTaskConfig::VD_NONE;
2065  break;
2066  case 1:
2067  dType = SgTaskConfig::VD_SB_DELAY;
2068  break;
2069  case 2:
2071  break;
2072  case 3:
2074  break;
2075  };
2076  config_->setUseDelayType(dType);
2077  emit delayTypeModified(dType);
2078 };
2079 
2080 
2081 
2082 //
2084 {
2086  switch (n)
2087  {
2088  default:
2089  case 0:
2090  rType = SgTaskConfig::VR_NONE;
2091  for (int i=0; i<stcParsButtons_.size(); i++)
2092  stcParsButtons_.at(i)->setEnabled(true);
2093  break;
2094  case 1:
2095  rType = SgTaskConfig::VR_PHS_RATE;
2096  for (int i=0; i<stcParsButtons_.size(); i++)
2097  stcParsButtons_.at(i)->setEnabled(false);
2098  break;
2099  };
2100  config_->setUseRateType(rType);
2101  emit rateTypeModified(rType);
2102 };
2103 
2104 
2105 
2106 //
2108 {
2109  switch (n)
2110  {
2111  default:
2112  case 0:
2114  break;
2115  case 1:
2117  break;
2118  };
2119 };
2120 
2121 
2122 
2123 //
2125 {
2126  switch (n)
2127  {
2128  default:
2129  case 0:
2131  break;
2132  case 1:
2134  break;
2135  case 2:
2137  break;
2138  };
2139 };
2140 
2141 
2142 
2143 //
2145 {
2146  switch (n)
2147  {
2148  default:
2149  case 0:
2151  break;
2152  case 1:
2154  break;
2155  };
2156 };
2157 
2158 
2159 
2160 //
2162 {
2163  switch (n)
2164  {
2165  default:
2166  case 0:
2168  break;
2169  case 1:
2171  break;
2172  };
2173 };
2174 
2175 
2176 
2177 //
2179 {
2180  bool isOK;
2181  double d;
2182  d = str.toDouble(&isOK);
2183  if (isOK && d!=config_->getOpThreshold())
2184  {
2185  config_->setOpThreshold(d);
2187  };
2188 };
2189 
2190 
2191 
2192 //
2194 {
2195  bool isOK;
2196  int n;
2197  n = str.toInt(&isOK);
2198  if (isOK && n!=config_->getOpIterationsLimit())
2200 };
2201 
2202 
2203 
2204 //
2206 {
2208 };
2209 
2210 
2211 
2212 //
2214 {
2216 };
2217 
2218 
2219 
2220 //
2222 {
2223  QAbstractButton *b=bgDelTypes_->button(n);
2224  if (b)
2225  b->setChecked(true);
2226  //
2227  if (false && !isOutliersProcessingThresholdModified_) // if user changed it once, do not interfere!
2228  {
2229  double d(5.0);
2231  d = 3.0;
2232  config_->setOpThreshold(d);
2233  leOPThreshold_->setText(QString("").sprintf("%.2f", config_->getOpThreshold()));
2234  };
2235 };
2236 
2237 
2238 
2239 //
2241 {
2242  QAbstractButton *b=bgRatTypes_->button(n);
2243  if (b)
2244  b->setChecked(true);
2245 };
2246 
2247 
2248 
2249 //
2251 {
2254  emit activeBandModified(n);
2255 };
2256 
2257 
2258 
2259 //
2261 {
2262  QAbstractButton *b = bgBands_->button(n);
2263  if (b)
2264  b->setChecked(true);
2265 };
2266 
2267 
2268 
2269 //
2271 {
2272  switch (n)
2273  {
2274  default:
2275  case 0:
2281  break;
2282  case 1:
2288  break;
2289  case 2:
2295  break;
2296  case 3:
2302  break;
2303  case 4:
2309  break;
2310  };
2311 };
2312 
2313 
2314 
2315 //
2317 {
2318  switch (n)
2319  {
2320  default:
2321  case 0:
2324  break;
2325  case 1:
2328  break;
2329  case 2:
2332  break;
2333  case 3:
2336  break;
2337  case 4:
2340  break;
2341  };
2342 };
2343 
2344 
2345 
2346 //
2348 {
2349  switch (n)
2350  {
2351  default:
2352  case 0:
2354  break;
2355  case 1:
2357  break;
2358  case 2:
2360  break;
2361  case 3:
2363  break;
2364  case 4:
2366  break;
2367  };
2368 };
2369 
2370 
2371 
2372 //
2374 {
2375  switch (n)
2376  {
2377  default:
2378  case 0:
2380  break;
2381  case 1:
2383  break;
2384  case 2:
2386  break;
2387  case 3:
2389  break;
2390  case 4:
2392  break;
2393  };
2394 };
2395 
2396 
2397 
2398 //
2400 {
2401  switch (n)
2402  {
2403  default:
2404  case 0:
2406  break;
2407  case 1:
2409  break;
2410  case 2:
2412  break;
2413  case 3:
2415  break;
2416  case 4:
2418  break;
2419  };
2420 };
2421 
2422 
2423 
2424 //
2426 {
2427  switch (n)
2428  {
2429  default:
2430  case 0:
2432  break;
2433  case 1:
2435  break;
2436  case 2:
2438  break;
2439  case 3:
2441  break;
2442  case 4:
2444  break;
2445  };
2446 };
2447 
2448 
2449 
2450 //
2452 {
2453  switch (n)
2454  {
2455  default:
2456  case 0:
2458  break;
2459  case 1:
2461  break;
2462  case 2:
2464  break;
2465  case 3:
2467  break;
2468  case 4:
2470  break;
2471  };
2472 };
2473 
2474 
2475 
2476 //
2478 {
2479  switch (n)
2480  {
2481  default:
2482  case 0:
2484  break;
2485  case 1:
2487  break;
2488  case 2:
2490  break;
2491  case 3:
2493  break;
2494  case 4:
2496  break;
2497  };
2498 };
2499 
2500 
2501 
2502 //
2504 {
2505  switch (n)
2506  {
2507  default:
2508  case 0:
2510  break;
2511  case 1:
2513  break;
2514  case 2:
2516  break;
2517  case 3:
2519  break;
2520  case 4:
2522  break;
2523  };
2524 };
2525 
2526 
2527 
2528 //
2530 {
2531  switch (n)
2532  {
2533  default:
2534  case 0:
2536  break;
2537  case 1:
2539  break;
2540  case 2:
2542  break;
2543  case 3:
2545  break;
2546  case 4:
2548  break;
2549  };
2550 };
2551 
2552 
2553 
2554 //
2556 {
2557  switch (n)
2558  {
2559  default:
2560  case 0:
2562  break;
2563  case 1:
2565  break;
2566  case 2:
2568  break;
2569  case 3:
2571  break;
2572  case 4:
2574  break;
2575  };
2576 };
2577 
2578 
2579 
2580 //
2582 {
2583  switch (n)
2584  {
2585  default:
2586  case 0:
2588  break;
2589  case 1:
2591  break;
2592  case 2:
2594  break;
2595  case 3:
2597  break;
2598  case 4:
2600  break;
2601  };
2602 };
2603 
2604 
2605 
2606 //
2608 {
2609  switch (n)
2610  {
2611  default:
2612  case 0:
2614  break;
2615  case 1:
2617  break;
2618  case 2:
2620  break;
2621  case 3:
2623  break;
2624  case 4:
2626  break;
2627  };
2628 };
2629 
2630 
2631 
2632 //
2634 {
2635  switch (n)
2636  {
2637  default:
2638  case 0:
2640  break;
2641  case 1:
2643  break;
2644  case 2:
2646  break;
2647  case 3:
2649  break;
2650  case 4:
2652  break;
2653  };
2654 };
2655 
2656 
2657 
2658 //
2660 {
2661  switch (n)
2662  {
2663  default:
2664  case 0:
2666  break;
2667  case 1:
2669  break;
2670  case 2:
2672  break;
2673  case 3:
2675  break;
2676  case 4:
2678  break;
2679  };
2680 };
2681 
2682 
2683 
2684 //
2686 {
2687  switch (n)
2688  {
2689  default:
2690  case 0:
2692  break;
2693  case 1:
2695  break;
2696  case 2:
2698  break;
2699  case 3:
2701  break;
2702  case 4:
2704  break;
2705  };
2706 };
2707 
2708 
2709 //
2711 {
2712  if (isChecked && cbDoReweighting_->isEnabled())
2713  {
2714  cbDoReweighting_->setEnabled(false);
2715  for (int i=0; i<ratTypeButtons_.size(); i++)
2716  ratTypeButtons_.at(i)->setEnabled(false);
2717  }
2718  else
2719  {
2720  bool canBeEnabled(true);
2721  for (int i=0; i<stcParsButtons_.size(); i++)
2722  if (stcParsButtons_.at(i)->isChecked())
2723  canBeEnabled = false;
2724  if (canBeEnabled)
2725  {
2726  cbDoReweighting_->setEnabled(true);
2727  for (int i=0; i<ratTypeButtons_.size(); i++)
2728  ratTypeButtons_.at(i)->setEnabled(true);
2729  };
2730  };
2731 };
2732 
2733 
2734 
2735 //
2737 {
2738  config_->setDoIonoCorrection4SBD(chkState==Qt::Checked);
2739 };
2740 
2741 
2742 
2743 //
2745 {
2746  config_->setDoClockBreakDetectionMode1(chkState==Qt::Checked);
2747 };
2748 
2749 
2750 
2751 //
2753 {
2754  config_->setDoOutliersEliminationMode1(chkState==Qt::Checked);
2755 };
2756 
2757 
2758 
2759 //
2761 {
2762  config_->setIsActiveBandFollowsTab(chkState==Qt::Checked);
2763 };
2764 
2765 
2766 
2767 //
2769 {
2770  config_->setIsObservableFollowsPlot(chkState==Qt::Checked);
2771 };
2772 
2773 
2774 
2775 //
2777 {
2778  config_->setIsNoviceUser(chkState==Qt::Checked);
2779 };
2780 
2781 
2782 
2783 //
2785 {
2786  config_->setHave2outputCovarMatrix(chkState==Qt::Checked);
2787 };
2788 
2789 
2790 
2791 //
2793 {
2794  config_->setIsTesting(chkState==Qt::Checked);
2795 };
2796 
2797 
2798 
2799 //
2801 {
2802  config_->setUseQualityCodeG(chkState==Qt::Checked);
2803 };
2804 
2805 
2806 
2807 //
2809 {
2810  config_->setUseQualityCodeH(chkState==Qt::Checked);
2811 };
2812 
2813 
2814 
2815 //
2817 {
2818  config_->setIsSolveCompatible(chkState==Qt::Checked);
2819 };
2820 
2821 
2822 
2823 //
2825 {
2826  config_->setUseDynamicClockBreaks(chkState==Qt::Checked);
2827 };
2828 
2829 
2830 
2831 //
2833 {
2834  config_->setUseGoodQualityCodeAtStartup(chkState==Qt::Checked);
2835 };
2836 
2837 
2838 
2839 //
2841 {
2842  config_->setUseSolveObsSuppresionFlags(chkState==Qt::Checked);
2843 };
2844 
2845 
2846 
2847 //
2849 {
2850  bool have2=chkState==Qt::Checked;
2852  for (int i=0; i<stcParsButtons_.size(); i++)
2853  stcParsButtons_.at(i)->setEnabled(!have2 && config_->getUseRateType()==SgTaskConfig::VR_NONE);
2854  cbUseExtWeights_->setEnabled(!have2);
2855 };
2856 
2857 
2858 
2859 //
2861 {
2862  bool have2=chkState==Qt::Checked;
2864  cbDoReweighting_->setEnabled(!have2);
2865  leUseExtWeights_->setEnabled(have2);
2866 };
2867 
2868 
2869 
2870 //
2872 {
2874 };
2875 
2876 
2877 
2878 //
2879 void SgGuiTaskConfig::changeAS_ini4del(const QString& str)
2880 {
2881  bool isOk;
2882  double s;
2883  s = str.toDouble(&isOk);
2884  if (isOk)
2885  config_->setInitAuxSigma4Delay(s*1.0e-12);
2886  else
2887  leIniSigma4Del_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Delay()*1.0e12));
2888 };
2889 
2890 
2891 
2892 //
2893 void SgGuiTaskConfig::changeAS_ini4rat(const QString& str)
2894 {
2895  bool isOk;
2896  double s;
2897  s = str.toDouble(&isOk);
2898  if (isOk)
2899  config_->setInitAuxSigma4Rate(s*1.0e-15);
2900  else
2901  leIniSigma4Rat_->setText(QString("").sprintf("%g", config_->getInitAuxSigma4Rate()*1.0e15));
2902 };
2903 
2904 
2905 
2906 //
2907 void SgGuiTaskConfig::changeAS_min4del(const QString& str)
2908 {
2909  bool isOk;
2910  double s;
2911  s = str.toDouble(&isOk);
2912  if (isOk)
2913  config_->setMinAuxSigma4Delay(s*1.0e-12);
2914  else
2915  leMinSigma4Del_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Delay()*1.0e12));
2916 };
2917 
2918 
2919 
2920 void SgGuiTaskConfig::changeAS_min4rat(const QString& str)
2921 {
2922  bool isOk;
2923  double s;
2924  s = str.toDouble(&isOk);
2925  if (isOk)
2926  config_->setMinAuxSigma4Rate(s*1.0e-15);
2927  else
2928  leMinSigma4Rat_->setText(QString("").sprintf("%g", config_->getMinAuxSigma4Rate()*1.0e15));
2929 };
2930 
2931 
2932 
2933 //
2935 {
2936  config_->setOpHave2SuppressWeightCorrection(chkState==Qt::Checked);
2937 };
2938 
2939 
2940 
2941 //
2943 {
2944  config_->setOpIsSolveCompatible(chkState==Qt::Checked);
2945 };
2946 
2947 
2948 
2949 //
2951 {
2952  config_->setOpHave2NormalizeResiduals(chkState==Qt::Unchecked);
2953 };
2954 
2955 
2956 
2957 //
2959 {
2960  bool have2=chkState==Qt::Checked;
2962  leExtAPrioriSitesPositions_->setEnabled(have2);
2963 };
2964 
2965 
2966 
2967 //
2969 {
2971 };
2972 
2973 
2974 
2975 //
2977 {
2978  bool have2=chkState==Qt::Checked;
2980  leExtAPrioriSitesVelocities_->setEnabled(have2);
2981 };
2982 
2983 
2984 
2985 //
2987 {
2989 };
2990 
2991 
2992 
2993 //
2995 {
2996  bool have2=chkState==Qt::Checked;
2998  leExtAPrioriSourcesPositions_->setEnabled(have2);
2999 };
3000 
3001 
3002 
3003 //
3005 {
3007 };
3008 
3009 
3010 
3011 //
3013 {
3014  bool have2=chkState==Qt::Checked;
3016  leExtAPrioriSourcesSsm_->setEnabled(have2);
3017 };
3018 
3019 
3020 
3021 //
3023 {
3025 };
3026 
3027 
3028 
3029 //
3031 {
3032  bool have2=chkState==Qt::Checked;
3033  config_->setUseExtAPrioriErp(have2);
3034  leExtAPrioriErp_->setEnabled(have2);
3035 };
3036 
3037 
3038 
3039 //
3041 {
3043 };
3044 
3045 
3046 
3047 //
3049 {
3050  bool have2=chkState==Qt::Checked;
3052  leExtAPrioriAxisOffsets_->setEnabled(have2);
3053 };
3054 
3055 
3056 
3057 //
3059 {
3061 };
3062 
3063 
3064 
3065 //
3067 {
3068  bool have2=chkState==Qt::Checked;
3070  leExtAPrioriHiFyEop_->setEnabled(have2);
3071  cbH2AppHfTidalPxy_->setEnabled(!have2);
3072  cbH2AppHfTidalUt1_->setEnabled(!have2);
3073 };
3074 
3075 
3076 
3077 //
3079 {
3081 };
3082 
3083 
3084 
3085 //
3087 {
3088  bool have2=chkState==Qt::Checked;
3090  leExtAPrioriMeanGradients_->setEnabled(have2);
3091 };
3092 
3093 
3094 
3095 //
3097 {
3099 };
3100 
3101 
3102 
3103 //
3105 {
3107 };
3108 
3109 
3110 
3111 
3112 //
3114 {
3115  config_->setHave2ApplySourceSsm(chkState==Qt::Checked);
3116 };
3117 
3118 
3119 
3120 //
3122 {
3123  switch (n)
3124  {
3125  default:
3126  case 0:
3128  cbH2AppNdryContrib_->setEnabled(true);
3129  cbH2AppNwetContrib_->setEnabled(true);
3130  break;
3131  case 1:
3133  cbH2AppNdryContrib_->setEnabled(false);
3134  cbH2AppNwetContrib_->setEnabled(false);
3135  break;
3136  case 2:
3138  cbH2AppNdryContrib_->setEnabled(false);
3139  cbH2AppNwetContrib_->setEnabled(false);
3140  break;
3141  };
3142 };
3143 
3144 
3145 
3146 //
3148 {
3149  bool have=chkState==Qt::Checked;
3152 };
3153 
3154 
3155 
3156 //
3158 {
3159  config_->setHave2ApplyEarthTideContrib(chkState==Qt::Checked);
3160 };
3161 
3162 
3163 
3164 //
3166 {
3167  config_->setHave2ApplyOceanTideContrib(chkState==Qt::Checked);
3168 };
3169 
3170 
3171 
3172 //
3174 {
3175  config_->setHave2ApplyPoleTideContrib(chkState==Qt::Checked);
3176 };
3177 
3178 
3179 
3180 //
3182 {
3183  bool have2=chkState==Qt::Checked;
3185  cbExtAPrioriHiFyEop_->setEnabled(!have2);
3186 };
3187 
3188 
3189 
3190 //
3192 {
3193  bool have2=chkState==Qt::Checked;
3195  cbExtAPrioriHiFyEop_->setEnabled(!have2);
3196 };
3197 
3198 
3199 
3200 //
3202 {
3203  bool have2=chkState==Qt::Checked;
3205 };
3206 
3207 
3208 
3209 //
3211 {
3212  config_->setHave2ApplyUt1LibrationContrib(chkState==Qt::Checked);
3213 };
3214 
3215 
3216 
3217 //
3219 {
3220  config_->setHave2ApplyNutationHFContrib(chkState==Qt::Checked);
3221 };
3222 
3223 
3224 
3225 //
3227 {
3228  config_->setHave2ApplyOceanPoleTideContrib(chkState==Qt::Checked);
3229 };
3230 
3231 
3232 
3233 //
3235 {
3236  config_->setHave2ApplyGpsIonoContrib(chkState==Qt::Checked);
3237 };
3238 
3239 
3240 
3241 //
3243 {
3244  config_->setHave2ApplyFeedCorrContrib(chkState==Qt::Checked);
3245 };
3246 
3247 
3248 
3249 //
3251 {
3252  config_->setHave2ApplyTiltRemvrContrib(chkState==Qt::Checked);
3253 };
3254 
3255 
3256 
3257 //
3259 {
3260  config_->setHave2ApplyOldOceanTideContrib(chkState==Qt::Checked);
3261 };
3262 
3263 
3264 
3265 //
3267 {
3268  config_->setHave2ApplyOldPoleTideContrib(chkState==Qt::Checked);
3269 };
3270 
3271 
3272 
3273 //
3275 {
3276  config_->setHave2ApplyAxisOffsetContrib(chkState==Qt::Checked);
3277 };
3278 
3279 
3280 
3281 //
3283 {
3284  bool isOn=chkState==Qt::Checked;
3286  isOn = isOn || config_->getHave2ApplyNwetContrib();
3287  for (int i=0; i<bgFlybyRefrMapF_->buttons().size(); i++)
3288  bgFlybyRefrMapF_->buttons()[i]->setEnabled(!isOn);
3289 };
3290 
3291 
3292 
3293 //
3295 {
3296  bool isOn=chkState==Qt::Checked;
3298  isOn = isOn || config_->getHave2ApplyNdryContrib();
3299  for (int i=0; i<bgFlybyRefrMapF_->buttons().size(); i++)
3300  bgFlybyRefrMapF_->buttons()[i]->setEnabled(!isOn);
3301 };
3302 
3303 
3304 
3305 //
3307 {
3308  config_->setDoDownWeight(chkState==Qt::Checked);
3309 };
3310 
3311 
3312 
3313 //
3314 //
3316  Qt::MouseButton /* mouseButtonState */, Qt::KeyboardModifiers /* modifiers */)
3317 {
3318  if (!item) // may be NULL
3319  return;
3320 
3321  int idx=((SgGuiTcUserCorrectionItem*)item)->getIdx();
3322  QString str("");
3323  switch (n)
3324  {
3325  case 0:
3326  break;
3327  case 1:
3329  item->setText(1, session_->getUserCorrectionsUse().at(idx)?"Y":"");
3330  break;
3331  default:
3332  //std::cout << "default, n=" << n << "\n";
3333  break;
3334  };
3335 };
3336 /*=====================================================================================================*/
3337 
3338 
3339 
3340 
3341 /*=======================================================================================================
3342 *
3343 * SgGuiTaskConfigDialog's METHODS:
3344 *
3345 *======================================================================================================*/
3346 //
3348  SgVlbiSession* session, QWidget *parent, Qt::WindowFlags f)
3349  : QDialog(parent, f)
3350 {
3351  config_ = config;
3352  parametersDescriptor_ = parDescriptor;
3353  session_ = session;
3354 
3355  QPushButton *button;
3356  QBoxLayout *layout, *subLayout;
3357  QFrame *bar;
3358 
3359  layout = new QVBoxLayout(this);
3361  layout->addWidget(configWidget_);
3362 
3363  bar = new QFrame(this);
3364  bar->setFrameStyle(QFrame::HLine | QFrame::Sunken);
3365  layout->addWidget(bar);
3366 
3367  subLayout = new QHBoxLayout();
3368  layout->addLayout(subLayout);
3369  subLayout->addStretch(1);
3370 
3371  subLayout->addWidget(button=new QPushButton("Close", this));
3372  button->setMinimumSize(button->sizeHint());
3373  connect(button, SIGNAL(clicked()), SLOT(accept()));
3374 
3375  setWindowTitle("General Configure Editor");
3376 };
3377 
3378 
3379 
3380 //
3382 {
3383  delete configWidget_;
3384  configWidget_ = NULL;
3385  config_ = NULL;
3386  parametersDescriptor_ = NULL;
3387  session_ = NULL;
3388  emit windowClosed();
3389 };
3390 
3391 
3392 
3393 //
3395 {
3396  QDialog::accept();
3397  deleteLater();
3398 };
3399 /*=====================================================================================================*/
QList< SgVlbiNetworkId > networks
const QString defaultNetIdName
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 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_
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:603
bool getUseQualityCodeH() const
Definition: SgTaskConfig.h:833
bool getHave2ApplyNutationHFContrib() const
Definition: SgTaskConfig.h:374
bool getIsTesting() const
const QString & getExtAPrioriSitesVelocitiesFileName() const
bool getIsObservableFollowsPlot() const
const QString & getExtWeightsFileName() const
Definition: SgTaskConfig.h:953
bool getUseExtAPrioriSitesVelocities() const
void setUseGoodQualityCodeAtStartup(bool)
void setHave2ApplyGpsIonoContrib(bool b)
Definition: SgTaskConfig.h:601
bool getHave2ApplyOldPoleTideContrib() const
Definition: SgTaskConfig.h:381
void setHave2ApplySourceSsm(bool b)
Definition: SgTaskConfig.h:602
void setExtAPrioriMeanGradientsFileName(const QString &)
void setInitAuxSigma4Rate(double s)
Definition: SgTaskConfig.h:468
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:961
bool getUseExtAPrioriHiFyErp() const
double getMinAuxSigma4Rate() const
Definition: SgTaskConfig.h:230
void setUseExternalWeights(bool)
void setHave2ApplyEarthTideContrib(bool b)
Definition: SgTaskConfig.h:598
bool getUseExtAPrioriSitesPositions() const
bool getUseExtAPrioriErp() const
bool getOpIsSolveCompatible() const
void setUseRateType(VlbiRateType)
void setWcMode(WeightCorrectionMode)
bool getIsSolveCompatible() const
Definition: SgTaskConfig.h:897
void setIsObservableFollowsPlot(bool)
void setHave2ApplyOceanPoleTideContrib(bool b)
Definition: SgTaskConfig.h:608
void setHave2ApplyTiltRemvrContrib(bool b)
Definition: SgTaskConfig.h:610
bool getDoDownWeight() const
Definition: SgTaskConfig.h:945
VlbiDelayType getUseDelayType() const
Definition: SgTaskConfig.h:857
bool getDoWeightCorrection() const
Definition: SgTaskConfig.h:889
bool getUseExtAPrioriMeanGradients() const
void setExtWeightsFileName(const QString &)
bool getHave2ApplyEarthTideContrib() const
Definition: SgTaskConfig.h:367
EstimatorPwlMode getPwlMode() const
Definition: SgTaskConfig.h:937
void setDoClockBreakDetectionMode1(bool)
void setDoDownWeight(bool)
WeightCorrectionMode getWcMode() const
Definition: SgTaskConfig.h:929
void setOpThreshold(double)
void setIsNoviceUser(bool is)
Definition: SgTaskConfig.h:514
int getGoodQualityCodeAtStartup() const
Definition: SgTaskConfig.h:841
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:623
void setFlybyTropZenithMap(TropZenithMap m)
Definition: SgTaskConfig.h:619
bool getUseExternalWeights() const
Definition: SgTaskConfig.h:921
void setInitAuxSigma4Delay(double s)
Definition: SgTaskConfig.h:467
bool getHave2ApplyOceanTideContrib() const
Definition: SgTaskConfig.h:368
void setActiveBandIdx(int)
int getQualityCodeThreshold() const
Definition: SgTaskConfig.h:817
bool getUseExtAPrioriSourcesPositions() const
void setEccentricitiesFileName(const QString &)
double getMinAuxSigma4Delay() const
Definition: SgTaskConfig.h:229
void setIsActiveBandFollowsTab(bool)
double getInitAuxSigma4Delay() const
Definition: SgTaskConfig.h:231
void setIsSolveCompatible(bool)
bool getHave2ApplyNdryContrib() const
Definition: SgTaskConfig.h:385
VlbiRateType getUseRateType() const
Definition: SgTaskConfig.h:865
void setUseExtAPrioriMeanGradients(bool)
bool getHave2ApplyUt1OceanTideHFContrib() const
Definition: SgTaskConfig.h:372
bool getIsNoviceUser() const
Definition: SgTaskConfig.h:282
bool getUseQualityCodeG() const
Definition: SgTaskConfig.h:825
void setUseQualityCodeH(bool)
bool getHave2ApplyPxyOceanTideHFContrib() const
Definition: SgTaskConfig.h:373
void setUseExtAPrioriSourceSsm(bool)
void setPwlMode(EstimatorPwlMode)
const QString & getLastModifiedNetId() const
Definition: SgTaskConfig.h:390
void setHave2ApplyOceanTideContrib(bool b)
Definition: SgTaskConfig.h:599
bool getHave2ApplyOldOceanTideContrib() const
Definition: SgTaskConfig.h:380
void setUseSolveObsSuppresionFlags(bool)
void setOpIsSolveCompatible(bool)
void setExtAPrioriSourceSsmFileName(const QString &)
bool getHave2ApplyPoleTideContrib() const
Definition: SgTaskConfig.h:369
bool getUseExtAPrioriAxisOffsets() const
void setHave2ApplyPoleTideContrib(bool b)
Definition: SgTaskConfig.h:600
void setExtAPrioriSitesVelocitiesFileName(const QString &)
bool getHave2ApplyGpsIonoContrib() const
Definition: SgTaskConfig.h:370
void setHave2ApplyOldPoleTideContrib(bool b)
Definition: SgTaskConfig.h:612
bool getIsActiveBandFollowsTab() const
void setOpHave2SuppressWeightCorrection(bool)
bool getHave2ApplyPxyLibrationContrib() const
Definition: SgTaskConfig.h:376
void setHave2outputCovarMatrix(bool have2)
Definition: SgTaskConfig.h:516
void setHave2ApplyNdryContrib(bool b)
Definition: SgTaskConfig.h:616
void setHave2ApplyPxyOceanTideHFContrib(bool b)
Definition: SgTaskConfig.h:604
bool getUseSolveObsSuppresionFlags() const
Definition: SgTaskConfig.h:913
bool getHave2ApplyTiltRemvrContrib() const
Definition: SgTaskConfig.h:379
TropZenithMap getFlybyTropZenithMap() const
Definition: SgTaskConfig.h:388
bool getUseDynamicClockBreaks() const
Definition: SgTaskConfig.h:905
void setMinAuxSigma4Rate(double s)
Definition: SgTaskConfig.h:466
void setOpMode(OutliersProcessingMode)
int getOpIterationsLimit() const
Definition: SgTaskConfig.h:985
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:617
void setQualityCodeThreshold(int)
void setOpHave2NormalizeResiduals(bool)
void setHave2ApplyOldOceanTideContrib(bool b)
Definition: SgTaskConfig.h:611
const QString & getExtAPrioriSourcesPositionsFileName() const
bool getHave2ApplySourceSsm() const
Definition: SgTaskConfig.h:371
bool getHave2ApplyPxContrib() const
Definition: SgTaskConfig.h:365
bool getHave2ApplyOceanPoleTideContrib() const
Definition: SgTaskConfig.h:377
double getOpThreshold() const
Definition: SgTaskConfig.h:977
void setHave2ApplyPxyLibrationContrib(bool b)
Definition: SgTaskConfig.h:607
void setMinAuxSigma4Delay(double s)
Definition: SgTaskConfig.h:465
void setUseDelayType(VlbiDelayType)
void setIsTesting(bool)
void setHave2ApplyPyContrib(bool b)
Definition: SgTaskConfig.h:597
bool getHave2outputCovarMatrix() const
Definition: SgTaskConfig.h:284
bool getUseGoodQualityCodeAtStartup() const
Definition: SgTaskConfig.h:849
double getInitAuxSigma4Rate() const
Definition: SgTaskConfig.h:232
void setHave2ApplyPxContrib(bool b)
Definition: SgTaskConfig.h:596
void setHave2ApplyFeedCorrContrib(bool b)
Definition: SgTaskConfig.h:609
const QString & getExtAPrioriAxisOffsetsFileName() const
void setUseDynamicClockBreaks(bool)
void setHave2ApplyNutationHFContrib(bool b)
Definition: SgTaskConfig.h:605
void setHave2ApplyUt1LibrationContrib(bool b)
Definition: SgTaskConfig.h:606
void setHave2ApplyAxisOffsetContrib(bool b)
Definition: SgTaskConfig.h:614
void setUseExtAPrioriSitesPositions(bool)
int getActiveBandIdx() const
Definition: SgTaskConfig.h:873
bool getHave2ApplyFeedCorrContrib() const
Definition: SgTaskConfig.h:378
bool getHave2ApplyNwetContrib() const
Definition: SgTaskConfig.h:386
bool getOpHave2SuppressWeightCorrection() const
Definition: SgTaskConfig.h:993
const QString & getExtAPrioriErpFileName() const
void setLastModifiedNetId(const QString &netId)
Definition: SgTaskConfig.h:621
bool getHave2ApplyUt1LibrationContrib() const
Definition: SgTaskConfig.h:375
void setOpAction(OutliersProcessingAction)
void setExtAPrioriSitesPositionsFileName(const QString &)
OutliersProcessingAction getOpAction() const
Definition: SgTaskConfig.h:969
bool getHave2ApplyAxisOffsetContrib() const
Definition: SgTaskConfig.h:383
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
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
SgTaskConfig config
Definition: nuSolve.cpp:59
SgParametersDescriptor parametersDescriptor
Definition: nuSolve.cpp:60