MPSim::~MPSim() { DayTime endTime; logStream << "Execution end at: " << endTime.printf(epochFormat) << endl; logStream << "Total execution time: " << endTime - startTime << " seconds" << endl; }
// Update the file name, returns true if the file name changed bool updateFileName(const DayTime& t=DayTime()) { bool openedNewFile = false; const std::string newFilename=t.printf(filespec); if (currentFilename.size() == 0 && newFilename.size() > 0) { currentFilename = newFilename; currentTime = t; BaseStream::open(currentFilename.c_str(), omode); if (debugLevel) std::cout << "Opened " << currentFilename << std::endl; openedNewFile=true; } else if (newFilename == currentFilename) { currentTime = t; openedNewFile=false; } else { if (debugLevel) std::cout << "Closing " << currentFilename << std::endl; BaseStream::close(); currentFilename = newFilename; currentTime = t; BaseStream::open(currentFilename.c_str(), omode); if (debugLevel) std::cout << "Opened " << currentFilename << std::endl; openedNewFile=true; } return openedNewFile; };
void xINCDayTime :: FinishUp (void) { gpstk::DayTime dtorig(2000,12,1,0,0,0.); DayTime endTime; cout << endl << setprecision(4); cout << endTime.printf("Completed on %B %d, %Y %H:%02M:%02S") << endl; cout << "Processing time " << endTime-startTime << " seconds." << endl; cout << endl; }
//------------------------------------------------------------------------------------ int main(int argc, char **argv) { try { totaltime = clock(); int iret,nfile,reading,nread; // Title and description Title = PrgmName + ", part of the GPS ToolKit, Ver " + PrgmVers + ", Run "; PrgmEpoch.setLocalTime(); Title += PrgmEpoch.printf("%04Y/%02m/%02d %02H:%02M:%02S"); Title += "\n"; cout << Title; // get command line iret=GetCommandLine(argc, argv); if(iret) return iret; PrevEpoch = DayTime::BEGINNING_OF_TIME; // loop over input files - reading them twice Ninterps = 0; for(reading=1; reading <= 2; reading++) { nread = 0; for(nfile=0; nfile<PIC.InputObsName.size(); nfile++) { iret = ReadFile(nfile,reading); if(iret < 0) break; nread++; } // quit if error if(iret < 0) break; if(nread>0) { iret = AfterReadingFiles(reading); if(iret < 0) break; } CurrEpoch = DayTime::BEGINNING_OF_TIME; } PIC.oflog << PrgmName << " did " << Ninterps << " interpolations" << endl; totaltime = clock()-totaltime; PIC.oflog << PrgmName << " timing: " << fixed << setprecision(3) << double(totaltime)/double(CLOCKS_PER_SEC) << " seconds.\n"; cout << PrgmName << " timing: " << fixed << setprecision(3) << double(totaltime)/double(CLOCKS_PER_SEC) << " seconds.\n"; PIC.oflog.close(); return iret; } catch(FFStreamError& e) { cout << "FFStream exception:\n" << e << endl; } catch(Exception& e) { cout << "GPSTK exception:\n" << e << endl; } catch (...) { cout << "Unknown exception in main." << endl; } } // end main()
//------------------------------------------------------------------------------------ int OutputClockData(void) throw(Exception) { try { if(CI.Verbose) oflog << "BEGIN OutputClockData()" << endl; if(CI.OutputClkFile.empty()) return 0; int i; DayTime tt; map<string,Station>::const_iterator it; format f166(16,6),f92(9,2,2),f96(9,6); // open an output file for Clk data ofstream clkofs; clkofs.open(CI.OutputClkFile.c_str(),ios::out); if(clkofs.is_open()) { oflog << "Opened file " << CI.OutputClkFile << " for DD data output." << endl; clkofs << "# " << Title << endl; clkofs << "CLK site week sec_wk Rx_clk_bias(m) Sig(m) TT_off(s)\n"; } else { // TD error msg return -1; } // loop over stations for(it=Stations.begin(); it != Stations.end(); it++) { // loop over epochs for(i=0; i<it->second.ClockBuffer.size(); i++) { tt = FirstEpoch + it->second.CountBuffer[i]*CI.DataInterval; clkofs << "CLK " << it->first << " " << tt.printf("%4F %10.3g") << " " << f166 << it->second.ClockBuffer[i] << " " << f92 << it->second.ClkSigBuffer[i] // TD add clock polynomial Evaluate(tt) << " " << f92 << it->second.RxTimeOffset[i] << endl; } // loop over epochs } // loop over stations clkofs.close(); return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } catch(exception& e) { Exception E("std except: "+string(e.what())); GPSTK_THROW(E); } catch(...) { Exception e("Unknown exception"); GPSTK_THROW(e); } } // end OutputClockData()
/// returns 0 if all tests pass int main() { using gpstk::DayTime; try { cout << "BOT:" << DayTime(gpstk::DayTime::BEGINNING_OF_TIME) << endl; cout << "EOT:" << DayTime(gpstk::DayTime::END_OF_TIME) << endl; DayTime dt; dt.setSystemTime(); cout << "Check that the output matches the current UTC time." << endl << "string printf()" << endl; dtft(cout, dt, "mjd: %Q (%.0Q)"); dtft(cout, dt, "mjd: %5.3Q"); dtft(cout, dt, "mdy: %02m/%02d/%04Y"); dtft(cout, dt, "hms: %02H:%02M:%02S"); dtft(cout, dt, "hms: %02H:%02M:%06.3f"); dtft(cout, dt, "cal: %A, %B %d, %Y"); dtft(cout, dt, "week: %F(%G)"); dtft(cout, dt, "sow: %g"); dtft(cout, dt, "sow: %06.3g"); dtft(cout, dt, "doy: %j:%s"); dtft(cout, dt, "dow: %w"); dtft(cout, dt, "z: %Z (%z)"); dtft(cout, dt, "unix: %U.%06u"); cout << endl << "The following functions use DayTime::setToString()" << endl; string format = "%02m/%02d/%04Y %02H:%02M:%02S"; string st = dt.printf(format); DayTime q; q.setToString(st, format); dtft(cout, q, format); cout << "Tests complete." << endl; return 0; } catch(gpstk::Exception& e) { cout << e << endl; } catch(...) { cout << "Some other exception thrown..." << endl; } cout << "Exiting with exceptions." << endl; return -1; }
bool MPSim::initialize(int argc, char *argv[]) throw() { if(!BasicFramework::initialize(argc, argv)) return false; if (logfileOption.getCount()>0) { logFileName = StringUtils::asString(logfileOption.getValue().front()); } logStream.open( logFileName.c_str() ); logStream << "mpsim log file" << endl; logStream << "Execution started at: " << startTime.printf(epochFormat) << endl; return true; }
int DumpGrid(DayTime& time, string dumpfile) { try { ofstream ofs; // open output file ofs.open(dumpfile.c_str(),ios_base::out); if (!ofs) return -6; else lofs << "Opened output file " << dumpfile << endl; if (Grid.size() == 0) return 0; int i; for (i=0; i<Grid.size(); i++) { ofs << " " << time.printf("%4F %8.1g") << fixed << setprecision(3) << " " << setw(7) << Grid[i].lon << " " << setw(6) << Grid[i].lat << " " << setw(7) << Grid[i].gdop << " " << setw(7) << Grid[i].pdop << " " << setw(7) << Grid[i].hdop << " " << setw(7) << Grid[i].vdop << " " << setw(7) << Grid[i].tdop << " " << setw(6) << Grid[i].nsvs << fixed << setprecision(7) << " " << setw(9) << Grid[i].bdop << " " << endl; } ofs.close(); return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } }
//------------------------------------------------------------------------------------ // called from DDBase.cpp int OutputRawData(void) throw(Exception) { try { if(CI.Verbose) oflog << "BEGIN OutputRawData()" << endl; if(CI.OutputRawFile.empty()) return 0; int i; DayTime tt; map<string,Station>::const_iterator it; map<GSatID,RawData>::const_iterator jt; format f133(13,3),f52(5,2); // open an output file for RAW data ofstream rawofs; rawofs.open(CI.OutputRawFile.c_str(),ios::out); if(rawofs.is_open()) { oflog << "Opened file " << CI.OutputRawFile << " for raw data output.." << endl; rawofs << "# " << Title << endl; rawofs << "RAW site sat week sec_wk count L1_cyc L2_cyc" << " P1_m P2_m ER_m EL AZ\n"; } else { // TD error msg return -1; } // loop over stations for(it=Stations.begin(); it != Stations.end(); it++) { // loop over satellites for(jt=it->second.RawDataBuffers.begin(); jt != it->second.RawDataBuffers.end(); jt++) { // loop over epochs for(i=0; i<jt->second.count.size(); i++) { tt = FirstEpoch + jt->second.count[i]*CI.DataInterval; rawofs << "RAW " << it->first << " " << jt->first << " " << tt.printf("%4F %10.3g") << " " << setw(5) << jt->second.count[i] << " " << f133 << jt->second.L1[i] << " " << f133 << jt->second.L2[i] << " " << f133 << jt->second.P1[i] << " " << f133 << jt->second.P2[i] << " " << f133 << jt->second.ER[i] << " " << f52 << jt->second.elev[i] << " " << f52 << jt->second.az[i] << endl; } // end loop over epochs } // loop over satellites } // loop over stations // close output file rawofs.close(); return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } catch(exception& e) { Exception E("std except: "+string(e.what())); GPSTK_THROW(E); } catch(...) { Exception e("Unknown exception"); GPSTK_THROW(e); } } // end OutputRawData()
//------------------------------------------------------------------------------------ int OutputDDData(void) throw(Exception) { try { if(CI.Verbose) oflog << "BEGIN OutputDDData()" << endl; if(CI.OutputDDDFile.empty()) return 0; int i; double wlb; DayTime tt; map<DDid,DDData>::const_iterator it; format f166(16,6); // open an output file for DDD data ofstream dddofs; dddofs.open(CI.OutputDDDFile.c_str(),ios::out); if(dddofs.is_open()) { oflog << "Opened file " << CI.OutputDDDFile << " for DD data output." << endl; dddofs << "# " << Title << endl; dddofs << "DDD sit1 sit2 sat ref week sec_wk DDL1_m " << "DDL2_m DDER_m resL1_m resL2_m"; if(CI.Frequency == 3) dddofs << " WLbias_m"; dddofs << endl; } else { // TD error msg return -1; } // loop over DDids for(it=DDDataMap.begin(); it != DDDataMap.end(); it++) { // loop over epochs for(i=0; i<it->second.count.size(); i++) { tt = FirstEpoch + it->second.count[i]*CI.DataInterval; if(CI.Frequency == 3) wlb = wl1p * it->second.DDL1[i] // wide lane range minus phase + wl2p * it->second.DDL2[i] // = WL phase - NL range - wl1r * it->second.DDP1[i] - wl2r * it->second.DDP2[i]; dddofs << "DDD " << it->first << " " << tt.printf("%4F %10.3g") << " " << f166 << it->second.DDL1[i] << " " << f166 << it->second.DDL2[i] << " " << f166 << it->second.DDER[i] << " " << f166 << it->second.DDL1[i] - it->second.DDER[i] << " " << f166 << it->second.DDL2[i] - it->second.DDER[i]; if(CI.Frequency == 3) dddofs << " " << f166 << wlb; dddofs << endl; } } dddofs.close(); return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } catch(exception& e) { Exception E("std except: "+string(e.what())); GPSTK_THROW(E); } catch(...) { Exception e("Unknown exception"); GPSTK_THROW(e); } } // end OutputDDData()
//------------------------------------------------------------------------------------ // called from EditDDs.cpp int OutputRawDData(const DDid& ddid, const DDData& dddata, const vector<int>& mark) throw(Exception) { try { bool TripleOut=true; // output triple differences as well if(CI.OutputRawDDFile.empty()) return 0; static ofstream rddofs; // allow caller to close the file... if(mark.size() == 0) { if(rddofs.is_open()) rddofs.close(); return 0; } if(!rddofs.is_open()) { // first call : open the file if(CI.Verbose) oflog << "BEGIN OutputRawDData()" << endl; rddofs.open(CI.OutputRawDDFile.c_str(),ios::out); if(rddofs.is_open()) { oflog << "Opened file " << CI.OutputRawDDFile << " for raw DD data output." << endl; rddofs << "# " << Title << endl; rddofs << "RDD sit1 sit2 sat ref week sec_wk flag DDL1_m" << " " << "DDL2_m DDER_m resL1_m resL2_m"; if(CI.Frequency == 3) rddofs << " WLbias_m"; rddofs << endl; if(TripleOut) rddofs << "RTD sit1 sit2 sat ref week sec_wk flag TDL1_m" << " TDL2_m TDER_m" << endl; } else { // TD error msg return -1; } } int i; double wlb; DayTime tt; format f166(16,6); // loop over epochs for(i=0; i<dddata.count.size(); i++) { tt = FirstEpoch + dddata.count[i]*CI.DataInterval; if(CI.Frequency == 3) wlb = wl1p * dddata.DDL1[i] // wide lane range minus phase + wl2p * dddata.DDL2[i] // = WL phase - NL range - wl1r * dddata.DDP1[i] - wl2r * dddata.DDP2[i]; rddofs << "RDD " << ddid << " " << tt.printf("%4F %10.3g") << " " << setw(2) << mark[i] << " " << f166 << dddata.DDL1[i] << " " << f166 << dddata.DDL2[i] << " " << f166 << dddata.DDER[i] << " " << f166 << dddata.DDL1[i] - dddata.DDER[i] << " " << f166 << dddata.DDL2[i] - dddata.DDER[i]; if(CI.Frequency == 3) rddofs << " " << f166 << wlb; rddofs << endl; if(TripleOut && i>0) { // wlb is a dummy here, = delta time for this triple diff wlb = (dddata.count[i]-dddata.count[i-1])*CI.DataInterval; rddofs << "RTD " << ddid << " " << tt.printf("%4F %10.3g") << " " << setw(2) << 10*mark[i]+mark[i-1] << " " << f166 << (dddata.DDL1[i]-dddata.DDL1[i-1])/wlb << " " << f166 << (dddata.DDL2[i]-dddata.DDL2[i-1])/wlb << " " << f166 << (dddata.DDER[i]-dddata.DDER[i-1])/wlb << endl; } } return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } catch(exception& e) { Exception E("std except: "+string(e.what())); GPSTK_THROW(E); } catch(...) { Exception e("Unknown exception"); GPSTK_THROW(e); } } // end OutputRawDData()
WxObservation WxObsData::getWxObservation(const DayTime& t, unsigned iv, bool interpolate) const throw(ObjectNotFound) { if (obs.empty()) { ObjectNotFound e("No WxObservation available near time " + t.printf("%02H:%02M:%02S on day %03j of %4Y")); GPSTK_THROW(e); } // get the first object after time t; WxObsMap::const_iterator after = obs.upper_bound(t); if (after == obs.begin()) { const WxObservation& wxa = after->second; if ((wxa.t >= (t - iv)) && (wxa.t <= (t + iv))) { // only after point fits return wxa; } else { ObjectNotFound e("No WxObservation available near time " + t.printf("%02H:%02M:%02S on day %03j of %4Y")); GPSTK_THROW(e); } } // get the first object at or before time t; WxObsMap::const_iterator before = after; before--; if (after == obs.end()) { const WxObservation& wxb = before->second; if((wxb.t >= (t - iv)) && (wxb.t <= (t + iv))) { // only before point fits return wxb; } else { ObjectNotFound e("No WeatherData available near time " + t.printf("%02H:%02M:%02S on day %03j of %4Y")); GPSTK_THROW(e); } } else { const WxObservation& wxa = after->second; const WxObservation& wxb = before->second; if (interpolate) { if((wxb.t >= (t - iv)) && (wxb.t <= (t + iv))) { if ((wxa.t >= (t - iv)) && (wxa.t <= (t + iv))) { // both points fit, linearly interpolate and create // a WeatherData object with those values double dtw = wxa.t - wxb.t; double dt = t - wxb.t; double slope = (wxa.pressure - wxb.pressure) / dtw; double pressure = slope * dt + wxb.pressure; slope = (wxa.humidity - wxb.humidity) / dtw; double humidity = slope * dt + wxb.humidity; slope = (wxa.temperature - wxb.temperature) / dtw; double temp = slope * dt + wxb.temperature; WxObservation wx(t, temp, pressure, humidity); return wx; } else { // only before point fits return wxb; } } else if ((wxa.t >= (t - iv)) && (wxa.t <= (t + iv))) { // only after point fits return wxa; } else { ObjectNotFound e("No WeatherData available near time " + t.printf("%02H:%02M:%02S on day %03j of %4Y")); GPSTK_THROW(e); } } else { if((wxb.t >= (t - iv)) && (wxb.t <= (t + iv))) { if ((wxa.t >= (t - iv)) && (wxa.t <= (t + iv))) { // both points fit, return closer point, or // before point if at same distance double diffa = wxa.t - t; double diffb = t - wxb.t; return(diffa < diffb ? wxa : wxb); } else { // only before point fits return wxb; } } else if ((wxa.t >= (t - iv)) && (wxa.t <= (t + iv))) { // only after point fits return wxa; } else { ObjectNotFound e("No WeatherData available near time " + t.printf("%02H:%02M:%02S on day %03j of %4Y")); GPSTK_THROW(e); } } } }
//------------------------------------------------------------------------------------ int InterpolateAndOutput(void) throw(Exception) { // interpolate positions and output to rinex try { bool Lagrange; int i,ipts; double PDOP,GDOP,rms,err,dt,Dt,delt,xx,yy,zz,tt; DayTime t0,ttag; RinexObsData psdata; vector<double> times,X,Y,Z,T; map<DayTime,PosInfo>::iterator itb,ite,itB,itE,itr; // if no previous epoch, nothing to do if(PrevEpoch==DayTime::BEGINNING_OF_TIME) return 0; // find 4 positions on each side of CurrEpoch-1/2dt ite = TimePositionMap.lower_bound(CurrEpoch); if(ite == TimePositionMap.end()) return 0; // no position; get it next time if(ite->first - LastInterpolated < 0) return 0; // already done itb = ite; if(itb == TimePositionMap.begin()) { //PIC.oflog << "Warning: cannot interpolate at " << CurrEpoch //<< ": before beginning of data" << endl; PIC.oflog << "Echo position at first epoch " << CurrEpoch.printf("%04Y/%02m/%02d %02H:%02M:%6.3f = %4F %.3g") << endl; // create the aux header // use data from the begin time RinexPositionComments(psdata,CurrEpoch, itb->second.N, itb->second.X, itb->second.Y, itb->second.Z, itb->second.T, itb->second.PDOP, itb->second.GDOP, itb->second.rms); // write it out ofstr << psdata; return 0; } itb--; // itb and ite are now on either side of the times at which to interpolate if(PIC.Debug) PIC.oflog << "Interpolate : " << itb->first.printf("%02H:%02M:%04.1f") << " to " << ite->first.printf("%02H:%02M:%04.1f") << " : (" << (ite->first - itb->first) << " sec)" << endl; // now expand them out, up to 3 more epochs, watching for gaps TD: 3*DT input itB = itb; itE = ite; for(i=0; i<3; i++) { if(itB == TimePositionMap.begin() || (i==0 && itE->first-itB->first > 3*PIC.DT)) break; // increase the end time ttag = itE->first; itE++; if(itE == TimePositionMap.end() || itE->first-ttag > 3*PIC.DT) { itE--; break; } // decrease the begin time ttag = itB->first; itB--; if(ttag-itB->first > 3*PIC.DT) { itE--; itB++; break; } } // fill the arrays for interpolation t0 = itB->first; ipts = 1; itr = itB; if(PIC.Debug) PIC.oflog << "Data for interpolation:\n"; while(1) { if(PIC.Debug) PIC.oflog << " " << ipts << " " << itr->first.printf("%02M:%04.1f") << fixed << setprecision(3) << " " << setw(6) << (itr->first-t0) << " " << setw(13) << itr->second.X << " " << setw(13) << itr->second.Y << " " << setw(13) << itr->second.Z << ((itr==itb || itr==ite) ? " *":"") << endl; times.push_back(itr->first - t0); // sec X.push_back(itr->second.X); // m Y.push_back(itr->second.Y); Z.push_back(itr->second.Z); T.push_back(itr->second.T); if(itr == itE) break; itr++; ipts++; } // compute the time intervals involved ttag = itb->first; Dt = ite->first - ttag; // time interval over which interpolating if(Dt > 3*PIC.DT) { PIC.oflog << "Warning: cannot interpolate at " << CurrEpoch << ": large gap = " << Dt << " seconds." << endl; return 0; } dt = PIC.DT/double(PIC.irate); // is there enough data to do Lagrange interpolation? // fall back to linear interpolation if have to, but not over long periods if(ipts < 2 || (ipts==2 && Dt>3*PIC.DT)) { PIC.oflog << "Warning: cannot interpolate at " << CurrEpoch << ": not enough data" << endl; return 0; // not enough data } Lagrange = (ipts == 2 ? false : true); // number of interpolations needed to cover Dt, plus 1 endpt ipts = int(0.5+Dt/dt); PIC.oflog << "Dt dt and ipts are " << Dt << " " << dt << " " << ipts << CurrEpoch.printf(" at %04Y/%02m/%02d %02H:%02M:%6.3f = %4F %.3g") << endl; // loop over the interpolation times you want delt = itb->first - t0; // time since first data point for(i=0; i<ipts; i++) { ttag += dt; // itb->first was done last epoch delt += dt; // use 1. known position if i==ipts-1 (last epoch, ite) // 2. Lagrange if you have more than 1 data on each side // 3. linear interpolation xx = (i==ipts-1 ? ite->second.X : (Lagrange ? LagrangeInterpolation(times,X,delt,err) : X[0]+(X[1]-X[0])*delt/Dt)); yy = (i==ipts-1 ? ite->second.Y : (Lagrange ? LagrangeInterpolation(times,Y,delt,err) : Y[0]+(Y[1]-Y[0])*delt/Dt)); zz = (i==ipts-1 ? ite->second.Z : (Lagrange ? LagrangeInterpolation(times,Z,delt,err) : Z[0]+(Z[1]-Z[0])*delt/Dt)); tt = (i==ipts-1 ? ite->second.T : (Lagrange ? LagrangeInterpolation(times,T,delt,err) : T[0]+(T[1]-T[0])*delt/Dt)); // create the aux header // use N,DOPs,RMS of _end_ time for all interpolated times RinexPositionComments(psdata,ttag, ite->second.N, xx,yy,zz,tt, ite->second.PDOP, ite->second.GDOP, ite->second.rms); // write it out ofstr << psdata; if(i != ipts-1) Ninterps++; LastInterpolated = ttag; } return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } catch(exception& e) { Exception E("std except: "+string(e.what())); GPSTK_THROW(E); } catch(...) { Exception e("Unknown exception"); GPSTK_THROW(e); } }
//------------------------------------------------------------------------------------ int Timetable(void) throw(Exception) { try { if(CI.Verbose) oflog << "BEGIN Timetable()" << " at total time " << fixed << setprecision(3) << double(clock()-totaltime)/double(CLOCKS_PER_SEC) << " seconds." << endl; int ib,iret; list<TTSegment>::iterator ttit; if(CI.TimeTableFile.size() > 0) { iret = ReadTimeTable(); } else if(CI.RefSat.id != -1) { // user says use this sat only // loop over baselines for(ib=0; ib<Baselines.size(); ib++) { TTSegment ts; ts.site1 = word(Baselines[ib],0,'-'); ts.site2 = word(Baselines[ib],1,'-'); ts.sat = CI.RefSat; ts.start = ts.first = 0; ts.end = ts.last = maxCount; ts.minelev = ts.maxelev = 0.0; ts.length = ts.end - ts.start + 1; TimeTable.push_back(ts); iret = 0; } } else { // loop over baselines for(ib=0; ib<Baselines.size(); ib++) { iret = ComputeBaselineTimeTable(Baselines[ib]); if(iret) break; } // end loop over baselines } if(iret == 0) { // write out timetable to log // REF site site sat week use_first use_last data_start data_end DayTime tt; GSatID sat; oflog << "Here is the time table (" << TimeTable.size() << ")" << endl; if(CI.Screen) cout << "Time table (" << TimeTable.size() << "):" << endl; oflog << "# " << Title << endl; oflog << "# REF site site sat week use_first use_last data_start data_end\n"; if(CI.Screen) cout << "# REF site site sat week use_first use_last data_start data_end\n"; for(ttit=TimeTable.begin(); ttit != TimeTable.end(); ttit++) { oflog << "REF " << ttit->site1 << " " << ttit->site2 << " " << ttit->sat; if(CI.Screen) cout << "REF " << ttit->site1 << " " << ttit->site2 << " " << ttit->sat; tt = FirstEpoch + CI.DataInterval * ttit->first; oflog << tt.printf(" %4F %10.3g"); // TD week rollover! if(CI.Screen) cout << tt.printf(" %4F %10.3g"); // TD week rollover! tt = FirstEpoch + CI.DataInterval * ttit->last; oflog << tt.printf(" %10.3g"); if(CI.Screen) cout << tt.printf(" %10.3g"); tt = FirstEpoch + CI.DataInterval * ttit->start; oflog << tt.printf(" %10.3g"); if(CI.Screen) cout << tt.printf(" %10.3g"); tt = FirstEpoch + CI.DataInterval * ttit->end; oflog << tt.printf(" %10.3g"); if(CI.Screen) cout << tt.printf(" %10.3g"); // TD? ttit->minelev, ttit->maxelev, ttit->length, ttit->metric() oflog << " " << fixed << setw(4) << setprecision(1) << ttit->minelev; if(CI.Screen) cout << " " << fixed << setw(4) << setprecision(1) << ttit->minelev; oflog << " " << fixed << setw(4) << setprecision(1) << ttit->maxelev; if(CI.Screen) cout << " " << fixed << setw(4) << setprecision(1) << ttit->maxelev; // write the number of counts for this ref oflog << " " << setw(5) << ttit->length; if(CI.Screen) cout << " " << setw(5) << ttit->length; oflog << endl; if(CI.Screen) cout << endl; // for next time sat = ttit->sat; } oflog << "End of time table." << endl; if(CI.Screen) cout << "End of time table." << endl; } return iret; return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } catch(exception& e) { Exception E("std except: "+string(e.what())); GPSTK_THROW(E); } catch(...) { Exception e("Unknown exception"); GPSTK_THROW(e); } } // end Timetable()
void RinexNavHeader::reallyPutRecord(FFStream& ffs) const throw(std::exception, FFStreamError, StringException) { RinexNavStream& strm = dynamic_cast<RinexNavStream&>(ffs); strm.header = (*this); unsigned long allValid; if (version == 2.0) allValid = allValid20; else if (version == 2.1) allValid = allValid21; else if (version == 2.11) allValid = allValid211; else { FFStreamError err("Unknown RINEX version: " + asString(version,3)); err.addText("Make sure to set the version correctly."); GPSTK_THROW(err); } if ((valid & allValid) != allValid) { FFStreamError err("Incomplete or invalid header."); err.addText("Make sure you set all header valid bits for all of the available data."); GPSTK_THROW(err); } string line; if (valid & versionValid) { line = rightJustify(asString(version,3), 10); line += string(10, ' '); line += string("NAVIGATION"); //leftJustify(fileType, 20); line += string(30, ' '); line += versionString; strm << line << endl; strm.lineNumber++; } if (valid & runByValid) { line = leftJustify(fileProgram,20); line += leftJustify(fileAgency,20); DayTime dt; dt.setLocalTime(); string dat = dt.printf("%02m/%02d/%04Y %02H:%02M:%02S"); line += leftJustify(dat, 20); line += runByString; strm << line << endl; strm.lineNumber++; } if (valid & commentValid) { vector<string>::const_iterator itr = commentList.begin(); while (itr != commentList.end()) { line = leftJustify((*itr), 60); line += commentString; strm << line << endl; strm.lineNumber++; itr++; } } if (valid & ionAlphaValid) { line = string(2, ' '); for (int i = 0; i < 4; i++) { line += rightJustify(doub2for(ionAlpha[i], 12, 2),12); // should be 12.4 } line += string(10, ' '); line += ionAlphaString; strm << line << endl; strm.lineNumber++; } if (valid & ionBetaValid) { line = string(2, ' '); for (int i = 0; i < 4; i++) { line += rightJustify(doub2for(ionBeta[i], 12, 2),12); } line += string(10, ' '); line += ionBetaString; strm << line << endl; strm.lineNumber++; } if (valid & deltaUTCValid) { line = string(3, ' '); //line += string(2, ' '); line += doub2for(A0, 19, 2); line += doub2for(A1, 19, 2); line += rightJustify(asString(UTCRefTime),9); line += rightJustify(asString(UTCRefWeek),9); line += string(1, ' '); line += deltaUTCString; strm << line << endl; strm.lineNumber++; } if (valid & leapSecondsValid) { line = rightJustify(asString(leapSeconds), 6); line += string(54, ' '); line += leapSecondsString; strm << line << endl; strm.lineNumber++; } if (valid & endValid) { line = string(60,' '); line += endOfHeader; strm << line << endl; strm.lineNumber++; } }
//------------------------------------------------------------------------------------ int EditDDSlips(const DDid& ddid, DDData& dddata, int frequency) throw(Exception) { try { int i,j,k,n,m,tdcount,tddt,ii,iter; double slip,fslip,tol; vector<int> slipindex; vector<double> td,slipsize; DayTime tt; TwoSampleStats<double> tsstats; // -------------------------------------- define td tolerance for slips const int iter_limit = 3; // this allows iter_limit-1 slips to be fixed const double tolerance = 0.5; // cycles // 3.4 const double tol = 0.5; // cycles -- TD make input // 3.2 revert tol = 0.9; // cycles //#define turnoffslips 1 // iterate for(iter=1; iter<=iter_limit; iter++) { if(iter == 1) tol = tolerance; if(iter > 1) tol = 0.6 * tolerance; td.clear(); slipsize.clear(); slipindex.clear(); tsstats.Reset(); // -------------------------------------- find slips // compute triple differences // j is the index of the previous good point for(k=0,j=-1,i=0; i<dddata.count.size(); i++) { if(mark[i] == 0) { //oflog << "Data 1 marked at count " << dddata.count[i] << endl; continue; } if(j == -1) { j = i; continue; } //tdcount = dddata.count[i]; tt = FirstEpoch + CI.DataInterval * dddata.count[i]; tddt = dddata.count[i]-dddata.count[j]; td.push_back( (frequency == 1 ? dddata.DDL1[i] - dddata.DDL1[j] : dddata.DDL2[i] - dddata.DDL2[j] ) - (dddata.DDER[i] - dddata.DDER[j]) ); tsstats.Add(dddata.count[i],td[k]); // slip in cycles slip = td[k]/(frequency == 1 ? wl1 : wl2); // fractional part of slip fslip = fabs(fmod(slip,1.0)); if(fslip > 0.5) fslip = 1.0-fslip; #ifndef turnoffslips // look for slips // if frac > 0.2, call it a slip anyway and hope it will be combined if(fabs(slip) > tol) { // || fslip > 0.2) oflog << " Warning - DD " << ddid << " L" << frequency << fixed << " slip " << setprecision(3) << setw(8) << slip << " cycles, at " << tt.printf(" %4F %10.3g = %Y/%02m/%02d %2H:%02M:%6.3f") << " = count " << dddata.count[i] << " on iteration " << iter << endl; // first see if it can be combined with previous slip n = slipindex.size(); if(n>0 && dddata.count[i]-dddata.count[slipindex[n-1]] < CI.MaxGap) { // combine these slips slipsize[n-1] += slip; // mark all points from old slip to pt before this as bad for(m=slipindex[n-1]; m<i; m++) { mark[m] = 0; ngood--; nbad++; } slipindex[n-1] = i; oflog << " Warning - DD " << ddid << " L" << frequency << fixed << " last two slips combined (iter " << iter << ")" << endl; } else { slipindex.push_back(i); slipsize.push_back(slip); } } #endif if(tddofs) { tddofs << "TDS " << ddid << " L" << frequency << fixed << " " << iter << " " << setw(4) << dddata.count[i] << " " << tt.printf("%4F %10.3g") << " " << setw(3) << tddt << setprecision(6) << " " << setw(11) << td[k] << " " << setw(11) << slip << setprecision(3) << " " << setw(8) << fslip << endl; } k++; j = i; } // end for loop over dddata to compute TDs // if too small, delete the whole pass if(td.size() < 10) return -1; // print stats to log if(CI.Verbose) { double median,mad,mest; vector<double> weights; weights.resize(td.size()); mad = Robust::MedianAbsoluteDeviation(&td[0], td.size(), median); mest = Robust::MEstimate(&td[0], td.size(), median, mad, &weights[0]); oflog << " TUR " << ddid << " L" << frequency << fixed << setprecision(3) << " " << iter << " " << setw(5) << tsstats.N() << " " << setw(7) << tsstats.AverageY() << " " << setw(7) << tsstats.StdDevY() << " " << setw(7) << tsstats.SigmaYX() << " " << setw(7) << median << " " << setw(7) << mest << " " << setw(7) << mad << endl; } // if no slips found, normal return if(slipindex.size() == 0) return 0; // if on last iteration, don't bother to fix... if(iter == iter_limit) break; // TD check for too many slips -> reject the whole pass //if(CI.Verbose) for(i=0; i<slipindex.size(); i++) // oflog << "Slip " << " L" << frequency << setprecision(3) << slipsize[i] // << " found at count " << dddata.count[slipindex[i]] << endl; // -------------------------------------- remove slips // add a dummy.. slipindex.push_back(99999); // ii is slip count, k is current correction in cycles, // j is index of previous good point for(k=0,j=-1,ii=0,i=0; i<dddata.count.size(); i++) { if(mark[i] == 0) { //oflog << "Data 2 marked at " << dddata.count[i] << endl; continue; } tt = FirstEpoch + CI.DataInterval * dddata.count[i]; // fix if(i == slipindex[ii]) { // new slip on this count k += int(slipsize[ii] + (slipsize[ii]>0 ? 0.5 : -0.5)); if(CI.Verbose) oflog << " Fix L" << frequency << " slip at count " << dddata.count[i] << " " << tt.printf("%4F %10.3g") << " total mag " << k << " iteration " << iter << endl; ii++; } // fix double differences using accumulated net slip if(k != 0) { if(frequency == 1) dddata.DDL1[i] -= k * wl1; else dddata.DDL2[i] -= k * wl2; } // output the slip-edited DDs and TDs if(tddofs) { tddofs << "SED " << ddid << fixed << " L" << frequency << " " << iter << " " << setw(4) << dddata.count[i] << " " << tt.printf("%4F %10.3g") << " " << setw(11) << setprecision(6) // DD in m << (frequency == 1 ? dddata.DDL1[i] : dddata.DDL2[i]) - dddata.DDER[i] << " " << setw(11) << (j == -1 ? 0.0 : // TD in m (frequency == 1 ? dddata.DDL1[i] - dddata.DDL1[j] : dddata.DDL2[i] - dddata.DDL2[j]) - (dddata.DDER[i] - dddata.DDER[j]) ) << endl; j = i; } // end output } // end for loop over data to fix slips } // end for loop over iterations // failed - return non-zero to delete the whole segment oflog << " Warning - Delete " << ddid << " L" << frequency << ": unable to fix slips" << endl; return -1; } catch(Exception& e) { GPSTK_RETHROW(e); } catch(exception& e) { Exception E("std except: "+string(e.what())); GPSTK_THROW(E); } catch(...) { Exception e("Unknown exception"); GPSTK_THROW(e); } }
//------------------------------------------------------------------------------------ int main(int argc, char **argv) { try { clock_t totaltime; // for timing totaltime = clock(); // locals int i,iret=0; DayTime CurrEpoch; // defaults to current local time SolarSystem SSEphemeris; // program name, title and version PrgmName = string("testSSEph"); Title = PrgmName + ", test program for JPL ephemeris, version " + Version + ", " + CurrEpoch.printf("Run %04Y/%02m/%02d at %02H:%02M:%02S"); // default command line input bool verbose=false,debug=false; string inputFilename,testFilename,logFilename; // parse the command line input for(i=0; i<argc; i++) { string word = string(argv[i]); if(argc == 1 || word == "-h" || word == "--help") { cout << "Program " << PrgmName << " reads a binary JPL planetary ephemeris file, created by " << "convertSSEph,\n and a test file, downloaded from the JPL ftp site, " << "containing times and planets\n with JPL-generated ephemeris " << "coordinate values. The coordinates are computed using\n the binary " << "file and the SolarSystem class, and compared with the JPL values;\n " << "any difference larger than 10^-13 is noted with the word 'Failure' " << "at EOL.\n Note that some large coordinate values may differ at the " << "level of 10^-13 because the\n size of double precision is barely " << "able to hold that much precision; compare the\n computed value " << "with the JPL value (copied as a string) in the output file.\n" << "\n Usage: " << PrgmName << " [options]\n Options are:\n" << " --log <file> name of optional log file (otherwise stderr)\n" << " --file <file> name of binary SS ephemeris file\n" << " --test <file> name of JPL test file (e.g. testpo.403)\n" << " --verbose print info to the log file.\n" << " --debug print debugging info to the log file.\n" << " --help print this and quit.\n" ; return 0; } else if(i == 0) continue; else if(word == "-d" || word == "--debug") debug = true; else if(word == "-v" || word == "--verbose") verbose = true; else if(word == "--log") logFilename = string(argv[++i]); else if(word == "--file") inputFilename = string(argv[++i]); else if(word == "--test") testFilename = string(argv[++i]); } // test input if(inputFilename.empty()) { LOG(ERROR) << "Must specify an input binary file name"; return -1; } if(testFilename.empty()) { LOG(ERROR) << "Must specify an input test file name"; return -1; } if(!logFilename.empty()) { // choose the log file logstrm.open(logFilename.c_str(),ios_base::out); ConfigureLOG::Stream() = &logstrm; // if not the above, output is to stderr cout << Title << endl; cout << "Output is logged to file " << logFilename << endl; } // set the maximum level to be logged ConfigureLOG::ReportLevels() = ConfigureLOG::ReportTimeTags() = true; if(debug) ConfigureLOG::ReportingLevel() = ConfigureLOG::FromString("DEBUG"); else if(verbose) ConfigureLOG::ReportingLevel() = ConfigureLOG::FromString("VERBOSE"); else ConfigureLOG::ReportingLevel() = ConfigureLOG::FromString("INFO"); // = any of ERROR,WARNING,INFO,VERBOSE,DEBUG,DEBUGn (n=1,2,3,4,5,6,7) //cout << "Reporting in main is " // << ConfigureLOG::ToString(ConfigureLOG::ReportingLevel()) << endl; // display title in the log file LOG(INFO) << Title; // now read the binary file, and read selected records // use the binary to test using the JPL file testpo.<EPH#> LOG(VERBOSE) << "Initialize with file " << inputFilename; SSEphemeris.initializeWithBinaryFile(inputFilename); LOG(VERBOSE) << "End Initialize"; LOG(INFO) << "Ephemeris number is " << SSEphemeris.JPLNumber(); bool foundEOT=false; int target,center,coord; double JD,PV[6],value,diff; SolarSystem::Planet Target,Center; ifstream istrm; istrm.open(testFilename.c_str(),ios::in); if(!istrm.is_open()) { LOG(ERROR) << "Could not open test file " << testFilename; } else while(1) { string line,word; getline(istrm,line); stripTrailing(line,'\r'); strip(line); if(line.empty()) ; else if(line == string("EOT")) foundEOT = true; else if(!foundEOT) ; else { word = stripFirstWord(line); // DEPHEM word = stripFirstWord(line); // date in YYYY.MM.DD form JD = for2doub(stripFirstWord(line)); target = asInt(stripFirstWord(line)); center = asInt(stripFirstWord(line)); coord = asInt(stripFirstWord(line)) - 1; // my coords are 0-5, theirs 1-6 word = stripFirstWord(line); value = for2doub(word); word = rightJustify(word,25); Target = SolarSystem::Planet(target); Center = SolarSystem::Planet(center); iret = SSEphemeris.computeState(JD, Target, Center, PV, false); if(iret == -1 || iret == -2) continue; // time is not in file diff = fabs(PV[coord]-value); LOG(INFO) << fixed << setprecision(1) << setw(9) << JD << " " << setw(2) << target //<< " " << setw(2) << Target << " " << setw(2) << center //<< " " << setw(2) << Center << " " << setw(1) << coord+1 << " " << scientific << setprecision(5) << setw(13) << diff << " " << word << " " << fixed << setprecision(20) << setw(25) << PV[coord] << " " << iret << (diff > 1.e-13 ? " Failure" : "") ; } if(istrm.eof() || !istrm.good()) break; } if(iret) LOG(INFO) << PrgmName << " terminating with error code " << iret << ", which means " << (iret == 0 ? "OK" : (iret == -1 ? "last time in file was before first time in ephemeris" : (iret == -2 ? "time is beyond end time of ephemeris" : (iret == -3 ? "file reading failed" : "ephemeris file is corrupted")))) ; // compute run time totaltime = clock()-totaltime; LOG(INFO) << PrgmName << " timing: " << fixed << setprecision(9) << double(totaltime)/double(CLOCKS_PER_SEC) << " seconds."; if(LOGstrm != cout) cout << PrgmName << " timing: " << fixed << setprecision(9) << double(totaltime)/double(CLOCKS_PER_SEC) << " seconds." << endl; return iret; } catch(Exception& e) { LOG(ERROR) << "GPSTk Exception : " << e.what(); } catch (...) { LOG(ERROR) << "Unknown error in " << PrgmName << ". Abort." << endl; } return -1; } // end main()
void RinexMetHeader::reallyPutRecord(FFStream& ffs) const throw(std::exception, FFStreamError, gpstk::StringUtils::StringException) { RinexMetStream& strm = dynamic_cast<RinexMetStream&>(ffs); // since they want to output this header, let's store // it internally for use by the data strm.header = (*this); // i'm casting out const here to set the correct required valid bits. // deal with it =P unsigned long allValid; if (version == 2.0) allValid = allValid20; else if (version == 2.1) allValid = allValid21; else { FFStreamError err("Unknown RINEX version: " + asString(version,2)); err.addText("Make sure to set the version correctly."); GPSTK_THROW(err); } if ((valid & allValid) != allValid) { string errstr("Incomplete or invalid header: missing: "); errstr += bitString(allValid & ~valid); FFStreamError err(errstr); err.addText("Make sure you set all header valid bits for all of the available data."); GPSTK_THROW(err); } string line; // line by line, let's do this. if (valid & versionValid) { line = rightJustify(asString(version,2), 9); line += string(11, ' '); line += leftJustify(fileType, 40); line += versionString; strm << line << endl; strm.lineNumber++; } if (valid & runByValid) { line = leftJustify(fileProgram,20); line += leftJustify(fileAgency,20); DayTime dt; dt.setLocalTime(); string dat = dt.printf("%02m/%02d/%04Y %02H:%02M:%02S"); line += leftJustify(dat, 20); line += runByString; strm << line << endl; strm.lineNumber++; } if (valid & commentValid) { vector<string>::const_iterator itr = commentList.begin(); while (itr != commentList.end()) { line = leftJustify((*itr), 60); line += commentString; strm << line << endl; strm.lineNumber++; itr++; } } if (valid & markerNameValid) { line = leftJustify(markerName, 60); line += markerNameString; strm << line << endl; strm.lineNumber++; } if (valid & markerNumberValid) { line = leftJustify(markerNumber, 60); line += markerNumberString; strm << line << endl; strm.lineNumber++; } if (valid & obsTypeValid) { line = rightJustify(asString(obsTypeList.size()),6); vector<RinexMetType>::const_iterator itr = obsTypeList.begin(); size_t numWritten = 0; while (itr != obsTypeList.end()) { numWritten++; // stupid continuation lines =P if ((numWritten % (maxObsPerLine+1)) == 0) { line += obsTypeString; strm << line << endl; strm.lineNumber++; line = string(6,' '); } line += rightJustify(convertObsType(*itr), 6); itr++; } // pad the line out to 60 chrs and add label line += string(60 - line.size(), ' '); line += obsTypeString; strm << line << endl; strm.lineNumber++; } if (valid & sensorTypeValid) { // only write out the sensor types that are // in the obsTypeList vector<sensorType>::const_iterator itr = sensorTypeList.begin(); while (itr != sensorTypeList.end()) { if (std::find(obsTypeList.begin(), obsTypeList.end(), (*itr).obsType) != obsTypeList.end()) { line = leftJustify((*itr).model, 20); line += leftJustify((*itr).type, 20); line += string(6, ' '); line += rightJustify(asString((*itr).accuracy,1),7); line += string(4, ' '); line += convertObsType((*itr).obsType); line += string(1, ' '); line += sensorTypeString; strm << line << endl; strm.lineNumber++; } itr++; } } if (valid & sensorPosValid) { // only write out the sensor positions that are // in the obsTypeList vector<sensorPosType>::const_iterator itr = sensorPosList.begin(); while (itr != sensorPosList.end()) { if (std::find(obsTypeList.begin(), obsTypeList.end(), (*itr).obsType) != obsTypeList.end()) { line = rightJustify(asString((*itr).position[0],4),14); line += rightJustify(asString((*itr).position[1],4),14); line += rightJustify(asString((*itr).position[2],4),14); line += rightJustify(asString((*itr).height,4),14); line += string(1, ' '); line += convertObsType((*itr).obsType); line += string(1, ' '); line += sensorPosString; strm << line << endl; strm.lineNumber++; } itr++; } } if (valid & endValid) { line = string(60, ' '); line += endOfHeader; strm << line << endl; strm.lineNumber++; } }
//------------------------------------------------------------------------------------ int main(int argc, char **argv) { try { // ------------------------------------------------------------------ // START totaltime = clock(); int iret; DayTime CurrEpoch; // Title title and version Title = PrgmName + ", ARL:UT DD phase estimation processor, Ver " + Version; // PrgmDesc description PrgmDesc = " Prgm " + PrgmName + " will read GPS data from any number of RINEX obs files and process them\n" " in a double-differenced carrier phase estimation algorithm to produce precise\n" " estimates of relative positions. Input is on the command line, or of the same\n" " format in a file (see -f<file> below). DDBase is built on the GPS Toolkit (GPSTk).\n" " NB. Input option --DT <data_interval_(seconds)> is optional but recommended.\n" " NB. Stations are defined, and many inputs for each are identified, by a label\n" " (called station label or id below), which is case sensitive and must be used\n" " consistently throughout. It cannot be 'X','Y' or 'Z' nor contain '-' or '_';\n" " four characters work best.\n" " NB. There must be at least two stations defined, with observation file(s)\n" " provided for each, and at least one station must be fixed.\n" " Options may be given in an input file (see -f<file>); the '#' character marks\n" " a comment, to EOL. All input options are shown below, followed by a\n" " description, and the default value, if there is one, in ().\n"; // get current time time_t timer; struct tm *tblock; timer = time(NULL); tblock = localtime(&timer); CurrEpoch.setYMDHMS(1900+tblock->tm_year,1+tblock->tm_mon, tblock->tm_mday,tblock->tm_hour,tblock->tm_min,tblock->tm_sec); // print title and current time to screen Title += CurrEpoch.printf(", Run %04Y/%02m/%02d %02H:%02M:%02S"); cout << Title << endl; for(;;) { // ------------------------------------------------------------------ // get command line input; -99 is 'help' return if((iret = CI.GetCmdInput(argc, argv))) break; // ------------------------------------------------------------------ // test command input for validity if((iret = CI.ValidateCmdInput())) break; // dump command input to log if(CI.Verbose) { cout << "Output is directed to log file " << CI.LogFile << endl; CI.Dump(oflog); } // if 'validate' switch is on, quit here if(CI.Validate) break; // ------------------------------------------------------------------ // Configure #1 if((iret = Configure(1))) break; // ------------------------------------------------------------------ // Open and read all files, compute PR solution, edit and buffer raw data if((iret = ReadAndProcessRawData())) break; // ------------------------------------------------------------------ // Edit buffers if((iret = EditRawDataBuffers())) break; // ------------------------------------------------------------------ // Output raw data buffers if((iret = OutputRawDataBuffers())) break; // ------------------------------------------------------------------ // Configure #2 if((iret = Configure(2))) break; // ------------------------------------------------------------------ // clock processing if((iret = ClockModel())) break; // ------------------------------------------------------------------ // synchronization of data to epoch (SolutionEpoch) if((iret = Synchronization())) break; // ------------------------------------------------------------------ // correct ephemeris range, elevation, and compute phase windup if((iret = RecomputeFromEphemeris())) break; // ------------------------------------------------------------------ // Orbit processing if((iret = EphemerisImprovement())) break; // ------------------------------------------------------------------ // output 'raw' data here OutputRawData(); // ------------------------------------------------------------------ // Compute or read the timetable if((iret = Timetable())) break; // ------------------------------------------------------------------ // Compute double differences, and buffer if((iret = DoubleDifference())) break; // ------------------------------------------------------------------ // Edit double differences if((iret = EditDDs())) break; // ------------------------------------------------------------------ // Configure #3 : prepare estimation if((iret = Configure(3))) break; // ------------------------------------------------------------------ // Estimation if((iret = Estimation())) break; break; } // end for(;;) // END -------------------------------------------------------------- // error condition? -99 is 'normal' help return from GetCmdInput if(iret != -99) { if(iret) { cerr << PrgmName << " terminating with error code " << iret << endl; oflog << PrgmName << " terminating with error code " << iret << endl; } // compute run time totaltime = clock()-totaltime; cout << PrgmName << " timing: " << fixed << setprecision(3) << double(totaltime)/double(CLOCKS_PER_SEC) << " seconds." << endl; oflog << PrgmName << " timing: " << fixed << setprecision(3) << double(totaltime)/double(CLOCKS_PER_SEC) << " seconds." << endl; } return iret; } catch(Exception& e) { cerr << "GPSTk Exception : " << e; oflog << "GPSTk Exception : " << e; } catch (...) { cerr << "Unknown error in DDBase. Abort." << endl; oflog << "Unknown error in DDBase. Abort." << endl; } // close files oflog.close(); return -1; } // end main()
int WriteStatsFile(string statsfile) { try { ofstream sofs; sofs.open(statsfile.c_str(),ios_base::out); if (!sofs) return -7; else { bool wtd; double W,f; int i; for (i=0; i<Grid.size(); i++) { W = 1.0; // for completeness, if stats are weighted (they are not in this program's output), // they have to be re-normalized.... wtd = HGridStats[i].Weighted(); if (wtd) { W = HGridStats[i].Normalization(); f = W / double(HGridStats[i].N()); } // write the unweighted stats to the file sofs << " " << setw(5) << i << fixed << setprecision(2) << " " << setw(7) << Grid[i].lon << " " << setw(6) << Grid[i].lat << setprecision(10) << " " << setw( 4) << HGridStats[i].N() << " " << setw(12) << HGridStats[i].Minimum() << " " << setw(12) << HGridStats[i].Maximum(); if (wtd) { sofs << " " << setw(12) << HGridStats[i].Average()*f << " " << setw(12) << HGridStats[i].Variance()*f*f*f*f << " Y"; // this says 'are they weighted?' (see Stats.hpp in GPS-Tk) } else { sofs << " " << setw(12) << HGridStats[i].Average() << " " << setw(12) << HGridStats[i].Variance() << " N"; } sofs << " " << setw(12) << W; wtd = NGridStats[i].Weighted(); if (wtd) { W = NGridStats[i].Normalization(); f = W / double(NGridStats[i].N()); } sofs << setprecision(10) << " " << setw( 4) << NGridStats[i].N() << " " << setw(12) << NGridStats[i].Minimum() << " " << setw(12) << NGridStats[i].Maximum(); if (wtd) { sofs << " " << setw(12) << NGridStats[i].Average()*f << " " << setw(12) << NGridStats[i].Variance()*f*f*f*f << " Y"; } else { sofs << " " << setw(12) << NGridStats[i].Average() << " " << setw(12) << NGridStats[i].Variance() << " N"; } sofs << " " << setw(12) << W << endl; } // output absolute worst-site DOPs sofs << "Abs WORSTN" << " " << setw(5) << IworstN << TworstN.printf(" %4F %8.1g") << fixed << setprecision(2) << " " << setw(7) << Grid[IworstN].lon << " " << setw(7) << Grid[IworstN].lat << " " << setw(5) << WorstN << " " << setw(5) << NtrofN << endl; sofs << "Abs WORSTG" << " " << setw(5) << IworstG << TworstG.printf(" %4F %8.1g") << fixed << setprecision(2) << " " << setw(7) << Grid[IworstG].lon << " " << setw(7) << Grid[IworstG].lat << " " << setw(5) << WorstG << " " << setw(5) << NpeakG << endl; sofs << "Abs WORSTP" << " " << setw(5) << IworstP << TworstP.printf(" %4F %8.1g") << fixed << setprecision(2) << " " << setw(7) << Grid[IworstP].lon << " " << setw(7) << Grid[IworstP].lat << " " << setw(5) << WorstP << " " << setw(5) << NpeakP << endl; sofs << "Abs WORSTH" << " " << setw(5) << IworstH << TworstH.printf(" %4F %8.1g") << fixed << setprecision(2) << " " << setw(7) << Grid[IworstH].lon << " " << setw(7) << Grid[IworstH].lat << " " << setw(5) << WorstH << " " << setw(5) << NpeakH << endl; sofs << "Abs WORSTV" << " " << setw(5) << IworstV << TworstV.printf(" %4F %8.1g") << fixed << setprecision(2) << " " << setw(7) << Grid[IworstV].lon << " " << setw(7) << Grid[IworstV].lat << " " << setw(5) << WorstV << " " << setw(5) << NpeakV << endl; sofs << "Abs WORSTT" << " " << setw(5) << IworstT << TworstT.printf(" %4F %8.1g") << fixed << setprecision(2) << " " << setw(7) << Grid[IworstT].lon << " " << setw(7) << Grid[IworstT].lat << " " << setw(5) << WorstT << " " << setw(5) << NpeakT << endl; // output worst-site DOPs averaged over the day (avg. of worst-site values @ each timept.) sofs << "Avg WORSTN " << fixed << setprecision(2) << setw(5) << AvgWorstSiteDOP.wnsvs << endl; sofs << "Avg WORSTG " << fixed << setprecision(2) << setw(5) << AvgWorstSiteDOP.wgdop << endl; sofs << "Avg WORSTP " << fixed << setprecision(2) << setw(5) << AvgWorstSiteDOP.wpdop << endl; sofs << "Avg WORSTH " << fixed << setprecision(2) << setw(5) << AvgWorstSiteDOP.whdop << endl; sofs << "Avg WORSTV " << fixed << setprecision(2) << setw(5) << AvgWorstSiteDOP.wvdop << endl; sofs << "Avg WORSTT " << fixed << setprecision(2) << setw(5) << AvgWorstSiteDOP.wtdop << endl; } sofs.close(); return 0; } catch(Exception& e) { GPSTK_RETHROW(e); } }
void NavSum::process() { try { ofstream out; out.open(outputFileOption.getValue()[0].c_str()); if (out.fail()) { cout << "Opening output file " << outputFileOption.getValue()[0] << " failed." << endl << " navsum is ending..." << endl << endl; return; } // filter the data... first by block number, then by PRN FileFilterFrame<FICStream, FICData> data(inputFileOption.getValue()[0]); if (!blockFilterList.empty()) data.filter(FICDataFilterBlock(blockFilterList)); if (!prnFilterList.empty()) data.filter(FICDataFilterPRN(prnFilterList)); out << "Block# PRN or Transmit ! Toe/Toa" << endl; out << "in set Type SVID mm/dd/yy DOY hh:mm:ss Week SOW ! mm/dd/yy DOY HH:MM:SS" << endl; std::string xmitFmt("%02m/%02d/%02y %03j %02H:%02M:%02S %4F %6.0g"); std::string epochFmt("%02m/%02d/%02y %03j %02H:%02M:%02S"); DayTime XMitT; DayTime EpochT; uint32_t temp; int PRNID; int xmitPRN; int xMitWeek; int EpochWeek; char line[100]; string linestr; int count = 0; list<FICData>& ficlist = data.getData(); list<FICData>::iterator itr = ficlist.begin(); while (itr != ficlist.end()) { FICData& r = *itr; count++; int blockType = r.blockNum; double diff = 0.0; double Toe = 0.0; double HOW = 0.0; double xMitSOW = 0.0; double iMitSOW = 0; long IODC = 0; int fit = 0; switch (blockType) { case 9: PRNID = (short) r.f[19]; HOW = r.f[2]; Toe = r.f[33]; xMitWeek = (int) r.f[5]; IODC = ((long) r.f[9]) / 2048; fit = (int) r.f[34]; EpochWeek = xMitWeek; diff = Toe - HOW; if (diff < -1.0 * (double) DayTime::HALFWEEK) EpochWeek++; if (diff > (double) DayTime::HALFWEEK) xMitWeek--; XMitT = DayTime( xMitWeek, HOW-6.0 ); EpochT = DayTime( EpochWeek, Toe ); sprintf(line," %5d %3d %02d %s ! %s 0x%03lX %1d", count,blockType,PRNID, XMitT.printf(xmitFmt).c_str(), EpochT.printf(epochFmt).c_str(), IODC, fit); linestr = string(line); out << linestr << endl; totalsByBlock[BLK9]++; totalsByPRN[PRNID][BLK9]++; break; case 109: PRNID = (int) r.i[1]; xMitWeek = (int) r.i[0]; temp = (uint32_t) r.i[3]; XMitT = buildXMitTime( temp, xMitWeek ); sprintf(line," %5d %3d %02d %s !", count,blockType,PRNID, XMitT.printf(xmitFmt).c_str() ); linestr = string(line); out << linestr << endl; totalsByBlock[BLK109]++; totalsByPRN[PRNID][BLK109]++; break; case 62: PRNID = r.i[3]; xMitWeek = (int) r.i[5]; EpochWeek = (int) r.i[0]; iMitSOW = r.i[1]; if (iMitSOW<0) { iMitSOW += gpstk::DayTime::FULLWEEK; xMitWeek--; } xMitSOW = (double) iMitSOW; XMitT = DayTime( xMitWeek, xMitSOW ); if (PRNID>0 && PRNID<33) { EpochT = DayTime( EpochWeek, r.f[8] ); sprintf(line," %5d %3d %02d %s ! %s", count,blockType,PRNID, XMitT.printf(xmitFmt).c_str(), EpochT.printf(epochFmt).c_str() ); } else { sprintf(line," %5d %3d %02d %s !", count,blockType,PRNID, XMitT.printf(xmitFmt).c_str() ); } linestr = string(line); out << linestr << endl; totalsByBlock[BLK62]++; totalsBySVID[PRNID][BLK62]++; break; case 162: PRNID = r.i[0]; xMitWeek = r.i[14]; EpochWeek = r.i[13]; temp = (uint32_t) r.i[2]; xmitPRN = r.i[11]; XMitT = buildXMitTime( temp, xMitWeek ); sprintf(line," %5d %3d %02d %s ! %02d", count,blockType,PRNID, XMitT.printf(xmitFmt).c_str(), xmitPRN); linestr = string(line); out << linestr << endl; totalsByBlock[BLK162]++; totalsBySVID[PRNID][BLK162]++; break; } itr++; } printSummary( out ); } catch (Exception& exc) { cerr << exc; exit(1); } catch (...) { cerr << "Caught unknown exception" << endl; exit(1); } }