General Purpose Geodetic Library
SgPwlStorageIncRates.cpp
Go to the documentation of this file.
1 /*
2  *
3  * This file is a part of Space Geodetic Library. The library is used by
4  * nuSolve, a part of CALC/SOLVE system, and designed to make analysis of
5  * geodetic VLBI observations.
6  * Copyright (C) 2010-2020 Sergei Bolotin.
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program. If not, see <http://www.gnu.org/licenses/>.
20  *
21  */
22 
23 #include <SgLogger.h>
24 
25 #include <SgPwlStorageIncRates.h>
26 
27 #include <SgTaskConfig.h>
28 
29 
30 
31 
32 /*=======================================================================================================
33 *
34 * METHODS:
35 *
36 *======================================================================================================*/
37 //
38 // static first:
40 {
41  return "SgPwlStorageIncRates";
42 };
43 
44 
45 
47  SgPwlStorage()
48 {
49 };
50 
51 
52 
53 // A destructor:
55 {
56 };
57 
58 
59 
60 //
62 {
64  int nAs, nBs;
65  switch (dDomain)
66  {
67  default:
69  nAs = getNumOfPolynomials();
70  nBs = calcCurrentIdx(t) + 1;
71  break;
72  case SgPartial::DD_RATE:
74  nBs = 1;
75  break;
76  };
77  return nAs + nBs;
78 // return getNumOfPolynomials() + calcCurrentIdx(t) + 1;
79 };
80 
81 
82 
83 //
85 {
86  return numOfNodes_;
87 };
88 
89 
90 
91 //
93  const SgMJD& t0, const SgMJD& tN, const SgMJD& tRefer,
94  const SgTaskConfig* /*cfg*/)
95 {
96  if (isPOrigOwner_)
97  delete pOrig_;
98  pOrig_ = p;
99  isPOrigOwner_ = false;
100  tStart_ = t0;
101  tFinis_ = tN;
102  //tRefer_ = tN;
103  //tRefer_.setTime(0); // 0hr
104  tRefer_ = tRefer;
105  step_ = pOrig_->getStep();
106  //
107  if (false)
108  {
109  SgMJD t0h(tRefer_);
110  if (step_ > tFinis_-tStart_)
111  {
112  tStart_ = t0h - ceil((t0h - t0)*24.0)/24.0;
113  tFinis_ = t0h + ceil((tN - t0h)*24.0)/24.0;
114  step_ = tFinis_ - tStart_;
115  }
116  else
117  {
118  tStart_ = t0h - ceil((t0h - t0)*24.0)/24.0;
119  tFinis_ = tStart_ + ceil((tN - tStart_)/step_)*step_;
120  };
121  };
122  //
123  //
124  // if the step equal to an interval of data set, only a zero order (shift) should be set:
125  if (step_ > tFinis_-tStart_)
126  {
127  step_ = tFinis_ - tStart_ + 1.0E-4/DAY2SEC;
128  numOfPolynomials_ = 1;
129  }
130  else
132  if (numOfPolynomials_ > 0)
133  {
135  for (int i=0; i<numOfPolynomials_; i++)
136  {
137  pAi_[i].setName(pOrig_->getName() + ": A_" + QString("").sprintf("%d", i));
138  pAi_[i].tune(*p);
141  pAi_[i].setTLeft(tZero);
142  pAi_[i].setTRight(tInf);
143  };
145  "::deployParameters(): " + QString("").setNum(numOfPolynomials_) +
146  " polynomial parameters were allocated for " + pOrig_->getName() + " parameter");
147  };
148 
149  // segmented rates:
150  numOfNodes_ = ceil((tFinis_ - tStart_)/step_);
152  for (int i=0; i<numOfNodes_; i++)
153  {
154  pBi_[i].setName(pOrig_->getName() + ": B_" + QString("").sprintf("%03d", i));
155  pBi_[i].tune(*p);
157  pBi_[i].setTLeft(tStart_ + i*step_);
158  pBi_[i].setTRight(tInf);
159  };
160 
161  sumP2_ = 0.0;
162  sumX1P2_ = 0.0;
163  sumX2P2_ = 0.0;
164  sumT1P2_ = 0.0;
165 };
166 
167 
168 
169 //
171 {
173  return;
174  //
175  // adjust time from constraints equations:
176  SgMJD t(tt==tZero?tStart_:tt);
178  //
179  if (t < tStart_)
181  ": propagatePartials(): t(" + t.toString(SgMJD::F_YYYYMMDDHHMMSSSS) + ") < tStart(" +
183  if (tFinis_ < t)
185  ": propagatePartials(): tFinis(" + tFinis_.toString(SgMJD::F_YYYYMMDDHHMMSSSS) + ") < t(" +
187  //
188  double d(pOrig_->getD());
189  //
190  // Polynomials:
191  if (numOfPolynomials_ > 0)
192  {
193  double dt = (t - tRefer_);
194  double dd = 1.0;
195  switch (dDomain)
196  {
197  default:
199  for (int i=0; i<numOfPolynomials_; i++)
200  {
201  pAi_[i].setD(d*dd);
202  dd *= dt;
203  };
204  break;
205  case SgPartial::DD_RATE:
206  for (int i=1; i<numOfPolynomials_; i++)
207  {
208  pAi_[i].setD(i*d*dd);
209  dd *= dt/*/DAY2SEC*/;
210  };
211  break;
212  };
213  };
214  //
215  // rates:
216  int j=calcCurrentIdx(t);
217  switch (dDomain)
218  {
219  default:
221  for (int i=0; i<j; i++)
222  pBi_[i].setD(d*step_);
223  pBi_[j].setD(d*((t - tStart_) - j*step_));
224  break;
225  case SgPartial::DD_RATE:
226  pBi_[j].setD(d);
227  break;
228  };
229  //
230  pOrig_->zerofy();
231 };
232 
233 
234 
235 //
236 double SgPwlStorageIncRates::calcAX(const SgMJD& t, bool isWorkingBand)
237 {
239  double f(0.0), s2(0.0);
240  int j, n(0);
241  //
242  // Polynomials:
243  if (numOfPolynomials_ > 0)
244  {
245  double dt = (t - tRefer_);
246  double dd = 1.0;
247  switch (dDomain)
248  {
249  default:
251  for (int i=0; i<numOfPolynomials_; i++)
252  {
253  f += pAi_[i].getSolution()*dd;
254  s2+= pAi_[i].getSigma()*pAi_[i].getSigma()*dd*dd;
255  dd *= dt;
256  };
257  break;
258  case SgPartial::DD_RATE:
259  for (int i=1; i<numOfPolynomials_; i++)
260  {
261  f += i*pAi_[i].getSolution()*dd;
262  s2+= i*i*pAi_[i].getSigma()*pAi_[i].getSigma()*dd*dd;
263  dd *= dt/*/DAY2SEC*/;
264  };
265  break;
266  };
267  };
268  //
269  // Rates:
270  double fs(0.0), s2s(s2), tt, d;
271  if (numOfPolynomials_==1)
272  fs = f;
273  j = calcCurrentIdx(t);
274  //
275  switch (dDomain)
276  {
277  default:
279  for (int i=0; i<j; i++)
280  {
281  d = step_*pBi_[i].getSolution();
282  f += d;
283  fs += d;
284  d = step_*step_*pBi_[i].getSigma()*pBi_[i].getSigma();
285  s2 += d;
286  s2s+= d;
287  };
288  tt = ((t - tStart_) - j*step_);
289  d = tt*pBi_[j].getSolution();
290  f += d;
291  fs += d;
292  d = tt*tt*pBi_[j].getSigma()*pBi_[j].getSigma();
293  s2 += d;
294  s2s+= d;
295  n = pBi_[j].getNumObs();
296  //
297  // sets up the original parameter solution:
298  pOrig_->setSolution(fs);
299  pOrig_->setSigma(sqrt(s2s));
300  pOrig_->setNumObs(n);
301  // and statistics:
302  if (isWorkingBand)
303  {
304  sumP2_ += 1.0/s2;
305  sumX1P2_ += f /s2;
306  sumX2P2_ += f*f/s2;
307  sumT1P2_ += t.toDouble()/s2;
308  };
309  break;
310  case SgPartial::DD_RATE:
311  d = pBi_[j].getSolution();
312  f += d;
313  break;
314  };
315  // return Ax part:
316  return pOrig_->getD()*f;
317 };
318 
319 
320 
321 //
323 {
324  double f(0.0);
325  // Rates only:
326  int j(calcCurrentIdx(t));
327  if (j < 0)
328  j = 0;
329  else if (j > numOfNodes_-1)
330  j = numOfNodes_-1;
331  for (int i=0; i<j; i++)
332  f += step_*pBi_[i].getSolution();
333  f += ((t - tStart_) - j*step_)*pBi_[j].getSolution();
334  return f;
335 };
336 
337 
338 
339 //
341 {
342  // Rates only:
343  int j(calcCurrentIdx(t));
344  if (j < 0)
345  j = 0;
346  else if (j > numOfNodes_-1)
347  j = numOfNodes_ - 1;
348  return pBi_[j].getSigma()*step_;
349 };
350 
351 
352 
353 //
354 double SgPwlStorageIncRates::calc_P_a(const SgSymMatrix& P, int idx, const SgMJD& t)
355 {
357  double v(0.0);
358  if (numOfPolynomials_ > 0)
359  {
360  double dt = (t - tRefer_);
361  double dd = 1.0;
362  switch (dDomain)
363  {
364  default:
366  for (int i=0; i<numOfPolynomials_; i++)
367  {
368  v += P.getElement(idx, pAi_[i].getIdx())*dd;
369  dd *= dt;
370  };
371  break;
372  case SgPartial::DD_RATE:
373  for (int i=1; i<numOfPolynomials_; i++)
374  {
375  v += i*P.getElement(idx, pAi_[i].getIdx())*dd;
376  dd *= dt/*/DAY2SEC*/;
377  };
378  break;
379  };
380  };
381  //
382  int j=calcCurrentIdx(t);
383  switch (dDomain)
384  {
385  default:
387  for (int i=0; i<j; i++)
388  v += P.getElement(idx, pBi_[i].getIdx()) * step_;
389  v += P.getElement(idx, pBi_[j].getIdx()) * ((t - tStart_) - j*step_);
390  break;
391  case SgPartial::DD_RATE:
392  v += P.getElement(idx, pBi_[j].getIdx());
393  break;
394  };
395  //
396  return pOrig_->getD()*v;
397 };
398 
399 
400 
401 //
402 double SgPwlStorageIncRates::calc_aT_P_a(const SgVector& vP_a, const SgMJD& t)
403 {
405  double v(0.0);
406  if (numOfPolynomials_ > 0)
407  {
408  double dt = (t - tRefer_);
409  double dd = 1.0;
410  switch (dDomain)
411  {
412  default:
414  for (int i=0; i<numOfPolynomials_; i++)
415  {
416  v += vP_a.getElement(pAi_[i].getIdx())*dd;
417  dd *= dt;
418  };
419  break;
420  case SgPartial::DD_RATE:
421  for (int i=1; i<numOfPolynomials_; i++)
422  {
423  v += i*vP_a.getElement(pAi_[i].getIdx())*dd;
424  dd *= dt/*/DAY2SEC*/;
425  };
426  break;
427  };
428  };
429  //
430  int j=calcCurrentIdx(t);
431  switch (dDomain)
432  {
433  default:
435  for (int i=0; i<j; i++)
436  v += vP_a.getElement(pBi_[i].getIdx()) * step_;
437  v += vP_a.getElement(pBi_[j].getIdx()) * ((t - tStart_) - j*step_);
438  break;
439  case SgPartial::DD_RATE:
440  v += vP_a.getElement(pBi_[j].getIdx());
441  break;
442  };
443  //
444  return pOrig_->getD()*v;
445 };
446 
447 
448 
449 //
451 {
452  pars.clear();
454  int idx(calcCurrentIdx(t));
455  switch (dDomain)
456  {
457  default:
459  for (int i=0; i<getNumOfPolynomials(); i++)
460  pars.append(&pAi_[i]);
461  for (int i=0; i<idx+1; i++)
462  pars.append(&pBi_[i]);
463  break;
464  case SgPartial::DD_RATE:
465  for (int i=1; i<getNumOfPolynomials(); i++)
466  pars.append(&pAi_[i]);
467  pars.append(&pBi_[idx]);
468  break;
469  };
470 };
471 
472 
473 
474 //
475 /*
476 void SgPwlStorageIncRates::collectTraces4Sfo(const QList<SgParameter*> *listX, const SgSymMatrix& mPx)
477 {
478  double aConstr=pOrig_->getSigmaAPriori();
479  //
480  QMap<QString, SgParameter*> name2par;
481  QMap<QString, int> name2idx;
482  for (int i=0; i<listX->size(); i++)
483  {
484  name2par[listX->at(i)->getName()] = listX->at(i);
485  name2idx[listX->at(i)->getName()] = i;
486  };
487  //
488  QList<SgParameter*> l;
489  // collect B_i parameters that are in this partial solution:
490  for (int i=0; i<numOfNodes_; i++)
491  if (name2par.contains(pBi_[i].getName()))
492  l.append(&pBi_[i]);
493  //
494  // collect indices:
495  int *idx2r;
496  idx2r = new int[l.size()];
497  for (int i=0; i<l.size(); i++)
498  idx2r[i] = name2idx[l.at(i)->getName()];
499  //
500  // calc trace:
501  double d;
502  d = 0.0;
503  for (int i=0; i<l.size(); i++)
504  d += mPx.getElement(idx2r[i], idx2r[i])/aConstr/aConstr;
505 
506  trace_ += d;
507 
508  l.clear();
509  delete[] idx2r;
510 };
511 */
512 /*=====================================================================================================*/
513 
514 
515 
516 
517 /*=======================================================================================================
518 *
519 * FRIENDS:
520 *
521 *======================================================================================================*/
522 //
523 
524 
525 
526 /*=====================================================================================================*/
527 //
528 // aux functions:
529 //
530 
531 
532 // i/o:
533 
534 
535 /*=====================================================================================================*/
536 //
537 // constants:
538 //
539 
540 
541 /*=====================================================================================================*/
SgLogger * logger
Definition: SgLogger.cpp:231
const SgMJD tZero(1957, 10, 4)
const SgMJD tInf(2100, 1, 1)
#define DAY2SEC
radians to mas:
Definition: SgMathSupport.h:69
bool isAttr(uint a) const
Definition: SgAttribute.h:226
virtual void write(LogLevel, quint32, const QString &, bool=false)
Definition: SgLogger.cpp:88
@ ESTIMATOR
Definition: SgLogger.h:90
Definition: SgMJD.h:59
@ F_YYYYMMDDHHMMSSSS
Long verbose: Fri, the 2nd of Apr, 2010; 17hr 02min 43.6400sec.
Definition: SgMJD.h:67
QString toString(Format format=F_Verbose) const
Definition: SgMJD.cpp:1008
double toDouble() const
Definition: SgMJD.h:531
double getStep() const
Definition: SgParameter.h:523
double getSolution() const
Definition: SgParameter.h:435
void setTLeft(const SgMJD &t)
Definition: SgParameter.h:691
void setTRight(const SgMJD &t)
Definition: SgParameter.h:699
int getNumOfPolynomials() const
Definition: SgParameter.h:539
void tune(const SgParameterCfg &)
Definition: SgParameter.cpp:72
void setSigma(double v)
Definition: SgParameter.h:587
double getSigma() const
Definition: SgParameter.h:443
int getIdx() const
Definition: SgParameter.h:563
void setSolution(double v)
Definition: SgParameter.h:579
void setSigmaAPriori(double v)
Definition: SgParameter.h:619
double getSigmaAPrioriAux() const
Definition: SgParameter.h:483
void setPMode(SgParameterCfg::PMode mode)
Definition: SgParameter.h:603
void setD(double d)
Definition: SgPartial.h:347
void setName(const QString &name)
Definition: SgPartial.h:339
int getNumObs() const
Definition: SgPartial.h:299
@ DD_OFFSET
Definition: SgPartial.h:58
const QString & getName() const
Definition: SgPartial.h:283
double getD() const
Definition: SgPartial.h:291
void setNumObs(int n)
Definition: SgPartial.h:356
DataDomain getDataDomain() const
Definition: SgPartial.h:97
void zerofy()
Definition: SgPartial.h:408
@ Attr_IS_PARTIAL_SET
rise this bit on when the partial is assigned
Definition: SgPartial.h:53
virtual double calcRateSigma(const SgMJD &)
static const QString className()
virtual void deployParameters(SgParameter *, const SgMJD &tStart, const SgMJD &tFinis, const SgMJD &tRefer, const SgTaskConfig *)
virtual void propagatePartials(const SgMJD &t)
virtual double calc_P_a(const SgSymMatrix &, int, const SgMJD &)
virtual double calc_aT_P_a(const SgVector &, const SgMJD &)
virtual double calcRateSolution(const SgMJD &)
virtual double calcAX(const SgMJD &, bool)
virtual void getListOfActiveParameters(const SgMJD &t, QList< SgParameter * > &pars)
virtual int getNumOfActiveParameters(const SgMJD &t)
int getNumOfPolynomials() const
Definition: SgPwlStorage.h:259
double sumT1P2_
Definition: SgPwlStorage.h:179
int numOfPolynomials_
Definition: SgPwlStorage.h:169
bool isPOrigOwner_
Definition: SgPwlStorage.h:180
const SgMJD & tRefer() const
Definition: SgPwlStorage.h:291
double sumX2P2_
Definition: SgPwlStorage.h:178
SgParameter * pOrig_
Definition: SgPwlStorage.h:165
int calcCurrentIdx(const SgMJD &t)
Definition: SgPwlStorage.h:345
SgParameter * pAi_
Definition: SgPwlStorage.h:167
double sumX1P2_
Definition: SgPwlStorage.h:177
SgParameter * pBi_
Definition: SgPwlStorage.h:168
double getElement(unsigned int i, unsigned int j) const
Definition: SgSymMatrix.h:274
double getElement(unsigned int i) const
Definition: SgVector.h:362