// ************************************************************************** /** @class FitsFile @brief FITS writter for the FACT project. The FactFits class is able to open, manage and update FITS files. The file columns should be given to the class before the file is openned. Once a file has been created, the structure of its columns cannot be changed. Only row can be added. This class relies on the CCfits and CFitsIO packages. */ // ************************************************************************** #include "FitsFile.h" using namespace std; using namespace CCfits; bool FitsFile::WriteDefaultKeys(const string &prgname, float version) { if (!fTable) return false; try { const Time now; WriteKey("TELESCOP", "FACT", "Telescope that acquired this data"); WriteKey("PACKAGE", PACKAGE_NAME, "Package name"); WriteKey("VERSION", PACKAGE_VERSION, "Package description"); WriteKey("CREATOR", prgname, "Program that wrote this file"); WriteKey("EXTREL", version, "Release Number"); WriteKey("COMPILED", __DATE__ " " __TIME__, "Compile time"); WriteKey("REVISION", REVISION, "SVN revision"); WriteKey("ORIGIN", "FACT", "Institution that wrote the file"); WriteKey("DATE", now.Iso(), "File creation date"); WriteKey("NIGHT", now.NightAsInt(), "Night as int"); WriteKey("TIMESYS", "UTC", "Time system"); WriteKey("TIMEUNIT", "d", "Time given in days w.r.t. to MJDREF"); WriteKey("MJDREF", 40587, "Store times in UNIX time (for convenience, seconds since 1970/1/1)"); //WriteKey("CONTACT", PACKAGE_BUGREPORT, "Current package maintainer"); //WriteKey("URL", PACKAGE_URL, "Current repositiory location"); } catch (const CCfits::FitsException &e) { Error("CCfits::Table::addKey failed for '"+fTable->name()+"' in '"+fFile->name()+"': "+e.message()); return false; } return true; } // -------------------------------------------------------------------------- // //! Add a new column to the vectors storing the column data. //! @param names the vector of string storing the columns names //! @param types the vector of string storing the FITS data format //! @param numElems the number of elements in this column //! @param type the char describing the FITS data format //! @param name the name of the particular column to be added. // void FitsFile::AddColumn(char type, const string &name, int numElems, const string &unit) { fColNames.push_back(name); fColUnits.push_back(unit); ostringstream str; if (numElems != 1) str << numElems; switch (toupper(type)) { case 'B': str << 'L'; break; // logical case 'C': str << 'B'; break; // byte case 'S': str << 'I'; break; // short case 'I': str << 'J'; break; // int case 'X': str << 'K'; break; // long long case 'F': str << 'E'; break; // float case 'D': str << 'D'; break; // double } fColTypes.push_back(str.str()); } void FitsFile::AddColumn(const string &name, const string &format, const string &unit) { fColNames.push_back(name); fColUnits.push_back(unit); fColTypes.push_back(format); } bool FitsFile::OpenFile(const string &filename, bool allow_open) { if (fFile || fTable) { Error("FitsFile::OpenFile - File already open."); return false; } // fFileName = fileName; if (!allow_open && access(filename.c_str(), F_OK)==0) { Error("File '"+filename+"' already existing."); return false; } //create the FITS object try { fFile = new CCfits::FITS(filename, CCfits::RWmode::Write); } catch (CCfits::FitsException e) { Error("CCfits::FITS failed for '"+filename+"': "+e.message()); return false; } /* "SIMPLE = T / file does conform to FITS standard " "BITPIX = 8 / number of bits per data pixel " "NAXIS = 0 / number of data axes " "EXTEND = T / FITS dataset may contain extensions " "COMMENT FITS (Flexible Image Transport System) format is defined in 'Astronomy" "COMMENT and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H " "END "; */ fIsOwner = true; return true; } void FitsFile::ResetColumns() { fColNames.clear(); fColTypes.clear(); fColUnits.clear(); } bool FitsFile::SetFile(CCfits::FITS *file) { if (!file) { Error("Fits::SetFile failed: NULL argument."); return false; } if (fFile) { Error("Fits::SetFile failed: File already set."); return false; } fFile = file; fIsOwner = false; return true; } bool FitsFile::OpenTable(const string &tablename) { if (!fFile) { Error("FitsFile::OpenTable - No file open."); return false; } if (fTable) { Error("FitsFile::OpenTable - Table already open."); return false; } //actually create the table CCfits::Table *table = 0; try { table = fFile->addTable(tablename, 0, fColNames, fColTypes, fColUnits); } catch (const CCfits::FitsException &e) { Error("CCfits::Table::addTable failed for '"+tablename+"' in '"+fFile->name()+"': "+e.message()); return false; } if (table->rows() != 0) { Error("FITS table '"+tablename+"' created in '"+fFile->name()+"' on the fly looks non-empty."); return false; } // Set this as last - we use it for IsOpen() fTable = table; fNumRows = 0; return true; } // -------------------------------------------------------------------------- // //! This looks for a suitable table in the fits file, i.e. that corresponds to the name and column names. (no format check yet) //! @param tableName. the base table name to be obtained. If not suitable, numbers are appened to the name //! @param allNames. the name of all columns //! @param allDataTypes. the data types of all columns //! @param allUnits. the units of the columns //! @return a pointer to the newly retrieved/created table // bool FitsFile::OpenNewTable(const string &tableName, int maxtry) { if (!fFile) { Error("FitsFile::OpenNewTable - No file open."); return false; } if (fTable) { Error("FitsFile::OpenNewTable - Table already open."); return false; } //first, let's check if the table already exist in the file fFile->read(vector(1, tableName)); // FIXME: Check for fFile and fTable const multimap &extMap = fFile->extension(); for (int i=0; iWarn("Already 10 different tables with different formats exist in this file. Please consider re-creating the file entirely (i.e. delete it please)"); ostringstream str; str << tableName; if (i != 0) str << "-" << i; const string tname = str.str(); const multimap::const_iterator it = extMap.find(tname); //current table name does not exist yet. return its associated fits table newly created if (it == extMap.end()) { // What is this for? //for (multimap::const_iterator it=extMap.begin(); // it!= extMap.end(); it++) // fMess->Debug(it->first); return OpenTable(tname); } CCfits::Table *table = dynamic_cast(it->second); // something wrong happened while getting the table pointer if (!table) { Error("HDU '"+tname+"' found in file, but it is not a proper CCfits::Table."); return false; } //now check that the table columns are the same //as the service columns table->makeThisCurrent(); // FIXME: To be checked... /* const map cMap = table->column(); for (vector::const_iterator ii=fFile->fColNames; ii!=fFile->fColNames.end(); ii++) if (cMap.find(*ii) == cMap.end()) continue; */ fNumRows = table->rows(); // ----------- This is just a simple sanity check ---------- // This is not necessary this is done already in // findSuitableTable (either directly or indirectly through OpenTable) // fFile->fTable->makeThisCurrent(); //If the file already existed, then we must load its data to memory before writing to it. if (fNumRows>0) { CCfits::BinTable* bTable = dynamic_cast(table); if (!bTable) { Error("Table '"+tableName+"' found in '"+fFile->name()+"' is not a binary table."); return false; } //read the table binary data. vector colName; bTable->readData(true, colName); // double check that the data was indeed read from the disk. // Go through the fTable instead as colName is empty (yes, it is !) const auto &cMap = table->column(); //check that the existing columns are the same as the ones we want to write for (map::const_iterator mapIt = cMap.begin(); mapIt != cMap.end(); mapIt++) { bool found = false; for (unsigned int ii=0;iifirst == fColNames[ii]) { found = true; if (mapIt->second->format() != fColTypes[ii]) { Error("Column "+fColNames[ii]+" has wrong format ("+fColTypes[ii]+" vs "+mapIt->second->format()+" in file)"); return false; } } } if (!found) { Error("Column "+mapIt->first+" only exist in written file"); return false; } } //now we know that all the file's columns are requested. Let's do it the other way around for (unsigned int ii=0;ii::const_iterator mapIt = cMap.begin(); mapIt != cMap.end(); mapIt++) { if (fColNames[ii] == mapIt->first) { found = true; if (fColTypes[ii] != mapIt->second->format()) { Error("Column "+fColNames[ii]+" has wrong format ("+fColTypes[ii]+" vs "+mapIt->second->format()+" in file)"); return false; } } } if (!found) { Error("Column "+fColNames[ii]+" only exist in requested description"); return false; } } for (map::const_iterator cMapIt = cMap.begin(); cMapIt != cMap.end(); cMapIt++) { if (!cMapIt->second->isRead()) { Error("Reading column '"+cMapIt->first+"' back from '"+fFile->name()+"' failed."); return false; } } } // Set this as last - we use it for IsOpen() fTable = table; return true; } ostringstream str; str << "FitsFile::OpenNewTable failed - more than " << maxtry << " tables tried." << endl; Error(str); return false; } bool FitsFile::AddRow() { if (!fFile || !fTable) { Error("FitsFile::AddRow - No table open."); return false; } //insert a new row (1==number of rows to insert) int status(0); fits_insert_rows(fFile->fitsPointer(), fNumRows, 1, &status); // Status is also directly returned, but we need to give the // pointer anyway if (status) { char text[30];//max length of cfitsio error strings (from doc) fits_get_errstatus(status, text); ostringstream str; str << "Inserting row " << fNumRows << " failed in '"+fFile->name()+"': " << text << " (fits_insert_rows,rc=" << status << ")"; Error(str); return false; } fNumRows++; fCursor = 1; return true; } bool FitsFile::WriteData(size_t &start, const void *ptr, size_t size) { if (!fFile || !fTable) { Error("FitsFile::AddRow - No table open."); return false; } int status = 0; fits_write_tblbytes(fFile->fitsPointer(), fNumRows, start, size, (unsigned char*)ptr, &status); // Status is also directly returned, but we need to give the // pointer anyway if (status) { char text[30];//max length of cfitsio error strings (from doc) fits_get_errstatus(status, text); ostringstream str; str << "Writing row " << fNumRows << " failed in '"+fFile->name()+"': " << text << " (file_write_tblbytes,rc=" << status << ")"; Error(str); } start += size; return status==0; } void FitsFile::Close() { if (!fFile) return; if (fIsOwner) { const string name = fFile->name(); delete fFile; } //WARNING: do NOT delete the table as it gets deleted by the // fFile object fFile = NULL; fTable = NULL; } void FitsFile::Flush() { if (!fFile) return; int status = 0; fits_flush_file(fFile->fitsPointer(), &status); if (status) { char text[30]; fits_get_errstatus(status, text); ostringstream str; str << "Flushing file " << fFile->name() << " failed: " << text << " (fits_flush_file, rc=" << status << ")"; Error(str); } } size_t FitsFile::GetDataSize() const { size_t size = 0; for (vector::const_iterator it=fColTypes.begin(); it!=fColTypes.end(); it++) { size_t id=0; int n=1; try { n = stoi(*it, &id); } catch (const exception&) { } if (n==0) continue; switch ((*it)[id]) { case 'L': case 'A': size += n*1; break; // ascii case 'B': size += n*1; break; // logical/byte case 'I': size += n*2; break; // short case 'J': size += n*4; break; // int case 'K': size += n*8; break; // long long case 'E': size += n*4; break; // float case 'D': size += n*8; break; // double default: throw runtime_error("FitsFile::GetDataSize - id not known."); } } return size; }