[2820] | 1 | #include "machdefs.h"
|
---|
| 2 | #include "sopnamsp.h"
|
---|
| 3 |
|
---|
| 4 | #include <stdio.h>
|
---|
| 5 | #include <string.h>
|
---|
| 6 | #include <iostream>
|
---|
| 7 | #include <typeinfo>
|
---|
| 8 |
|
---|
| 9 | #include "datatable.h"
|
---|
| 10 | #include "fitsblkrw.h"
|
---|
| 11 | #include "fitshandler.h"
|
---|
| 12 |
|
---|
| 13 | // #include "fitshdtable.h"
|
---|
| 14 |
|
---|
| 15 | DECL_TEMP_SPEC /* equivalent a template <> , pour SGI-CC en particulier */
|
---|
| 16 | void FitsHandler<BaseDataTable>::Write(FitsInOutFile& os)
|
---|
| 17 | {
|
---|
| 18 |
|
---|
| 19 | if (dobj == NULL)
|
---|
| 20 | throw NullPtrError("FitsHandler<DataTable>::Write() NULL dobj pointer ");
|
---|
| 21 |
|
---|
| 22 | DataTable* dt = dynamic_cast< DataTable *> (dobj);
|
---|
| 23 | if (dt == NULL)
|
---|
| 24 | throw FitsIOException("FitsHandler<DataTable>::Write() Not a DataTable object");
|
---|
| 25 |
|
---|
| 26 | int tbltyp = os.GetDef_TableType();
|
---|
[2846] | 27 | string strcoltag;
|
---|
| 28 | long strwidth = os.GetDef_StrColWidth();
|
---|
| 29 | if (strwidth < 1) strwidth = 16;
|
---|
| 30 | char buff[32];
|
---|
| 31 | if (tbltyp == ASCII_TBL)
|
---|
| 32 | sprintf(buff, "A%ld",strwidth);
|
---|
| 33 | else
|
---|
| 34 | sprintf(buff, "%ldA",strwidth);
|
---|
| 35 | strcoltag = buff;
|
---|
| 36 |
|
---|
[2820] | 37 | vector<string> colnames, tform, tunit;
|
---|
| 38 | for(sa_size_t k=0; k<dobj->NVar(); k++) {
|
---|
[2846] | 39 | bool fgoknm = true;
|
---|
| 40 | bool fgoktun = true;
|
---|
[2820] | 41 | switch ( dobj->GetColumType(k) ) {
|
---|
| 42 | case BaseDataTable::IntegerField :
|
---|
| 43 | if (tbltyp == ASCII_TBL) tform.push_back("I9");
|
---|
| 44 | else tform.push_back("J");
|
---|
| 45 | break;
|
---|
| 46 | case BaseDataTable::LongField :
|
---|
| 47 | if (tbltyp == ASCII_TBL) tform.push_back("I12");
|
---|
| 48 | else tform.push_back("K");
|
---|
| 49 | break;
|
---|
| 50 | case BaseDataTable::FloatField :
|
---|
| 51 | if (tbltyp == ASCII_TBL) tform.push_back("E12.5");
|
---|
| 52 | else tform.push_back("E");
|
---|
| 53 | break;
|
---|
| 54 | case BaseDataTable::DoubleField :
|
---|
[2846] | 55 | case BaseDataTable::DateTimeField :
|
---|
[2820] | 56 | if (tbltyp == ASCII_TBL) tform.push_back("D15.8");
|
---|
| 57 | else tform.push_back("D");
|
---|
[2846] | 58 | if (dobj->GetColumType(k) == BaseDataTable::DateTimeField ) {
|
---|
| 59 | tunit.push_back("Days (DateTimeField)");
|
---|
| 60 | fgoktun = false;
|
---|
| 61 | }
|
---|
[2820] | 62 | break;
|
---|
[2846] | 63 | case BaseDataTable::ComplexField :
|
---|
| 64 | if (tbltyp == ASCII_TBL) {
|
---|
| 65 | cout << "FitsHandler<BaseDataTable>::Write()/Warning ComplexField not supported for ASCII_TBL "
|
---|
| 66 | << endl;
|
---|
| 67 | fgoknm = false;
|
---|
| 68 | }
|
---|
| 69 | else tform.push_back("C");
|
---|
| 70 | break;
|
---|
| 71 | case BaseDataTable::DoubleComplexField :
|
---|
| 72 | if (tbltyp == ASCII_TBL) {
|
---|
| 73 | cout << "FitsHandler<BaseDataTable>::Write()/Warning DoubleComplexField not supported for ASCII_TBL "
|
---|
| 74 | << endl;
|
---|
| 75 | fgoknm = false;
|
---|
| 76 | }
|
---|
| 77 | else tform.push_back("M");
|
---|
| 78 | break;
|
---|
[2820] | 79 | case BaseDataTable::StringField :
|
---|
[2846] | 80 | tform.push_back(strcoltag);
|
---|
[2820] | 81 | break;
|
---|
| 82 | default:
|
---|
| 83 | throw IOExc("FitsHandler<BaseDataTable>::Write() unknown column type ");
|
---|
| 84 | break;
|
---|
| 85 | }
|
---|
[2846] | 86 | if (fgoknm) {
|
---|
| 87 | colnames.push_back(dobj->GetColumName(k));
|
---|
| 88 | if (fgoktun) tunit.push_back("");
|
---|
| 89 | }
|
---|
[2820] | 90 | }
|
---|
| 91 |
|
---|
| 92 | // On cree la table
|
---|
[2846] | 93 | string extname = os.NextExtensionName();
|
---|
[2820] | 94 | os.CreateTable(os.GetDef_TableType(), extname, colnames, tform, tunit);
|
---|
| 95 |
|
---|
| 96 | // Ecriture des donnees des colonnes
|
---|
| 97 | for(sa_size_t l=0; l<dobj->NEntry(); l+=dobj->SegmentSize()) {
|
---|
| 98 | sa_size_t icol = 0;
|
---|
| 99 | sa_size_t sz = dobj->SegmentSize();
|
---|
| 100 | sa_size_t iseg = l/sz;
|
---|
| 101 | if ((l+sz) > dobj->NEntry()) sz = dobj->NEntry()-l;
|
---|
| 102 | for(sa_size_t k=0; k<dobj->NVar(); k++) {
|
---|
| 103 | sa_size_t sk = dobj->mNames[k].ser;
|
---|
[2846] | 104 | //DBG cout << "DBG-A k= " << k << " nom=" << dobj->mNames[k].nom << " ser=" << sk
|
---|
| 105 | //DBG << " type=" << dobj->GetColumType(k) << endl;
|
---|
[2820] | 106 | switch ( dobj->GetColumType(k) ) {
|
---|
| 107 | case BaseDataTable::IntegerField :
|
---|
| 108 | icol++;
|
---|
| 109 | FitsBlockRW<int_4>::WriteColumnData(os, icol, l+1, 1,
|
---|
| 110 | dt->mICols[sk].GetCstSegment(iseg), sz);
|
---|
| 111 | break;
|
---|
| 112 | case BaseDataTable::LongField :
|
---|
| 113 | icol++;
|
---|
| 114 | FitsBlockRW<int_8>::WriteColumnData(os, icol, l+1, 1,
|
---|
| 115 | dt->mLCols[sk].GetCstSegment(iseg), sz);
|
---|
| 116 | break;
|
---|
| 117 | case BaseDataTable::FloatField :
|
---|
| 118 | icol++;
|
---|
| 119 | FitsBlockRW<r_4>::WriteColumnData(os, icol, l+1, 1,
|
---|
| 120 | dt->mFCols[sk].GetCstSegment(iseg), sz);
|
---|
| 121 | break;
|
---|
| 122 | case BaseDataTable::DoubleField :
|
---|
[2846] | 123 | case BaseDataTable::DateTimeField :
|
---|
[2820] | 124 | icol++;
|
---|
| 125 | FitsBlockRW<r_8>::WriteColumnData(os, icol, l+1, 1,
|
---|
| 126 | dt->mDCols[sk].GetCstSegment(iseg), sz);
|
---|
| 127 | break;
|
---|
[2846] | 128 | case BaseDataTable::ComplexField :
|
---|
| 129 | if (tbltyp == BINARY_TBL) {
|
---|
| 130 | icol++;
|
---|
| 131 | FitsBlockRW< complex<r_4> >::WriteColumnData(os, icol, l+1, 1,
|
---|
| 132 | dt->mYCols[sk].GetCstSegment(iseg), sz);
|
---|
| 133 | }
|
---|
| 134 | break;
|
---|
| 135 | case BaseDataTable::DoubleComplexField :
|
---|
| 136 | if (tbltyp == BINARY_TBL) {
|
---|
| 137 | icol++;
|
---|
| 138 | FitsBlockRW< complex<r_8> >::WriteColumnData(os, icol, l+1, 1,
|
---|
| 139 | dt->mZCols[sk].GetCstSegment(iseg), sz);
|
---|
| 140 | }
|
---|
| 141 | break;
|
---|
| 142 | case BaseDataTable::StringField :
|
---|
| 143 | icol++;
|
---|
| 144 | FitsBlockRW<std::string>::WriteColumnData(os, icol, l+1, 1,
|
---|
| 145 | dt->mSCols[sk].GetCstSegment(iseg), sz);
|
---|
| 146 | break;
|
---|
[2820] | 147 | default:
|
---|
| 148 | break;
|
---|
| 149 | }
|
---|
| 150 | }
|
---|
| 151 | }
|
---|
| 152 | // Ecriture de SegmentSize et autre elements de DVList
|
---|
| 153 |
|
---|
| 154 | os.WriteHeaderRecords(dobj->Info());
|
---|
| 155 | MuTyV mtv = dobj->SegmentSize();
|
---|
| 156 | os.WriteKey("SEGMSIZE",mtv," SOPHYA::DataTable SegmentSize");
|
---|
[2846] | 157 | mtv = "SOPHYA::DataTable";
|
---|
| 158 | os.WriteKey("SOPCLSNM",mtv," Object class name ");
|
---|
[2820] | 159 | }
|
---|
| 160 |
|
---|
| 161 |
|
---|
| 162 |
|
---|
| 163 | DECL_TEMP_SPEC /* equivalent a template <> , pour SGI-CC en particulier */
|
---|
| 164 | void FitsHandler<BaseDataTable>::Read(FitsInOutFile& is)
|
---|
| 165 | {
|
---|
| 166 |
|
---|
| 167 | int hdutyp = is.CurrentHDUType();
|
---|
| 168 | if ( (hdutyp != BINARY_TBL ) && (hdutyp != ASCII_TBL) )
|
---|
| 169 | throw FitsIOException("FitsHandler<DataTable>::Read() Not a binary or ascii table HDU");
|
---|
| 170 |
|
---|
| 171 | sa_size_t segsz = is.GetNbRows() / 16; // Taille de segment par defaut
|
---|
| 172 | if (segsz > 2048) segsz = 2048;
|
---|
| 173 | string key = "SEGMSIZE";
|
---|
[2846] | 174 | bool knex = false;
|
---|
| 175 | string ssegsz = is.KeyValue(key, knex);
|
---|
| 176 | if (!knex && (ssegsz.length() > 0)) segsz = atoi(ssegsz.c_str());
|
---|
[2820] | 177 | if (segsz < 16) segsz = 16;
|
---|
| 178 |
|
---|
| 179 | if (dobj == NULL) { // On cree la table si besoin
|
---|
| 180 | dobj = new DataTable(segsz);
|
---|
| 181 | }
|
---|
| 182 | else {
|
---|
| 183 | dobj->Clear(); // On efface la table sinon
|
---|
| 184 | dobj->mSegSz = segsz;
|
---|
| 185 | }
|
---|
| 186 |
|
---|
| 187 | // On gere les DataTable pour le moment ...
|
---|
| 188 | DataTable* dt = dynamic_cast< DataTable *> (dobj);
|
---|
| 189 | if (dt == NULL)
|
---|
| 190 | throw FitsIOException("FitsHandler<DataTable>::Read() Not a DataTable object");
|
---|
| 191 |
|
---|
| 192 | vector<string> colnames;
|
---|
| 193 | vector<int> coltypes;
|
---|
| 194 | vector<long> repcnt, width;
|
---|
| 195 | vector<long> colpos;
|
---|
| 196 | is.GetColInfo(colnames, coltypes, repcnt, width);
|
---|
| 197 | // --ATTENTION-- repcnt (contenu=vecteur) pas pris en compte pour le moment
|
---|
| 198 | for(sa_size_t k=0; k<colnames.size(); k++) {
|
---|
| 199 | switch ( coltypes[k] ) {
|
---|
| 200 | case TBYTE :
|
---|
| 201 | case TSHORT :
|
---|
| 202 | case TUSHORT :
|
---|
| 203 | case TINT :
|
---|
| 204 | dt->AddIntegerColumn(colnames[k]);
|
---|
| 205 | colpos.push_back(k+1);
|
---|
| 206 | break;
|
---|
| 207 | case TUINT:
|
---|
| 208 | case TLONG :
|
---|
| 209 | case TULONG :
|
---|
| 210 | #ifdef TLONGLONG
|
---|
| 211 | case TLONGLONG :
|
---|
| 212 | #endif
|
---|
| 213 | dt->AddLongColumn(colnames[k]);
|
---|
| 214 | colpos.push_back(k+1);
|
---|
| 215 | break;
|
---|
| 216 | case TFLOAT :
|
---|
| 217 | dt->AddFloatColumn(colnames[k]);
|
---|
| 218 | colpos.push_back(k+1);
|
---|
| 219 | break;
|
---|
| 220 | case TDOUBLE :
|
---|
| 221 | dt->AddDoubleColumn(colnames[k]);
|
---|
| 222 | colpos.push_back(k+1);
|
---|
| 223 | break;
|
---|
[2846] | 224 | case TCOMPLEX :
|
---|
| 225 | dt->AddComplexColumn(colnames[k]);
|
---|
| 226 | colpos.push_back(k+1);
|
---|
| 227 | break;
|
---|
| 228 | case TDBLCOMPLEX :
|
---|
| 229 | dt->AddDoubleComplexColumn(colnames[k]);
|
---|
| 230 | colpos.push_back(k+1);
|
---|
| 231 | break;
|
---|
| 232 | case TSTRING :
|
---|
| 233 | dt->AddStringColumn(colnames[k]);
|
---|
| 234 | colpos.push_back(k+1);
|
---|
| 235 | break;
|
---|
[2820] | 236 | default:
|
---|
| 237 | cout << "FitsHandler<BaseDataTable>::Read() NOT handled field type "
|
---|
| 238 | << coltypes[k] << endl;
|
---|
| 239 | break;
|
---|
| 240 | }
|
---|
| 241 | }
|
---|
| 242 |
|
---|
| 243 | // ------- Mise a jour des champs Nb d'entrees, nb segments ...
|
---|
| 244 | dobj->mNEnt = is.GetNbRows();
|
---|
| 245 | while ((dobj->SegmentSize()*dobj->NbSegments()) < dobj->NEntry())
|
---|
| 246 | dobj->Extend();
|
---|
[2846] | 247 | //DBG cout << " DBG2 -- dobj->mNSeg = " << dobj->NbSegments() << " SegSize="
|
---|
| 248 | //DBG << dobj->SegmentSize() << " NEntry=" << dobj->NEntry() << endl;
|
---|
[2820] | 249 |
|
---|
| 250 | // Lecture des donnees des colonnes
|
---|
| 251 | for(sa_size_t l=0; l<dobj->NEntry(); l+=dobj->SegmentSize()) {
|
---|
| 252 | sa_size_t icol = 0;
|
---|
| 253 | sa_size_t sz = dobj->SegmentSize();
|
---|
| 254 | sa_size_t iseg = l/sz;
|
---|
| 255 | if ((l+sz) > dobj->NEntry()) sz = dobj->NEntry()-l;
|
---|
| 256 | for(sa_size_t k=0; k<dobj->NVar(); k++) {
|
---|
| 257 | sa_size_t sk = dobj->mNames[k].ser;
|
---|
| 258 | icol = colpos[k];
|
---|
| 259 | // cout << " DBG-3 , k=" << k << " icol=" << icol << endl;
|
---|
| 260 | switch ( dobj->GetColumType(k) ) {
|
---|
| 261 | case BaseDataTable::IntegerField :
|
---|
| 262 | FitsBlockRW<int_4>::ReadColumnData(is, icol, l+1, 1,
|
---|
| 263 | dt->mICols[sk].GetSegment(iseg), sz);
|
---|
| 264 | break;
|
---|
| 265 | case BaseDataTable::LongField :
|
---|
| 266 | FitsBlockRW<int_8>::ReadColumnData(is, icol, l+1, 1,
|
---|
| 267 | dt->mLCols[sk].GetSegment(iseg), sz);
|
---|
| 268 | break;
|
---|
| 269 | case BaseDataTable::FloatField :
|
---|
| 270 | FitsBlockRW<r_4>::ReadColumnData(is, icol, l+1, 1,
|
---|
| 271 | dt->mFCols[sk].GetSegment(iseg), sz);
|
---|
| 272 | break;
|
---|
| 273 | case BaseDataTable::DoubleField :
|
---|
[2846] | 274 | case BaseDataTable::DateTimeField :
|
---|
[2820] | 275 | FitsBlockRW<r_8>::ReadColumnData(is, icol, l+1, 1,
|
---|
| 276 | dt->mDCols[sk].GetSegment(iseg), sz);
|
---|
| 277 | break;
|
---|
[2846] | 278 | case BaseDataTable::ComplexField :
|
---|
| 279 | FitsBlockRW< complex<r_4> >::ReadColumnData(is, icol, l+1, 1,
|
---|
| 280 | dt->mYCols[sk].GetSegment(iseg), sz);
|
---|
| 281 | break;
|
---|
| 282 | case BaseDataTable::DoubleComplexField :
|
---|
| 283 | FitsBlockRW< complex<r_8> >::ReadColumnData(is, icol, l+1, 1,
|
---|
| 284 | dt->mZCols[sk].GetSegment(iseg), sz);
|
---|
| 285 | break;
|
---|
| 286 | case BaseDataTable::StringField :
|
---|
| 287 | FitsBlockRW<std::string>::ReadColumnData(is, icol, l+1, 1,
|
---|
| 288 | dt->mSCols[sk].GetSegment(iseg), sz);
|
---|
| 289 | break;
|
---|
[2820] | 290 | default:
|
---|
| 291 | break;
|
---|
| 292 | }
|
---|
| 293 | }
|
---|
| 294 | }
|
---|
| 295 |
|
---|
| 296 | // Mise a jour nombre d'entree
|
---|
| 297 | // Lecture DVList
|
---|
| 298 | is.GetHeaderRecords(dobj->Info());
|
---|
| 299 | }
|
---|
| 300 |
|
---|
| 301 |
|
---|
| 302 |
|
---|
| 303 |
|
---|