InsertData.hxx

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// SVN: $Id: InsertData.hxx 7080 2010-06-10 15:34:33Z EckhardSutorius $
//-----------------------------------------------------------------------------
// Helper functions for inserting data from FITS files into TableData objects.
// These are not implemented as subclasses of DataMethod because these are more
// to do with setting up the structure of the data objects. These functions are
// used before any of the DataMethods are invoked. These functions are actually
// invoked in the various DataBuilder subclasses
//
// @@TODO: Should really be member functions of individual DataBuilder classes
//
#ifndef INSERTDATA_H
#define INSERTDATA_H

#include <string>

#include "Constants.h"
#include "Converter.h"
#include "FitsFile.h"
#include "Logger.h"
#include "MyException.h"
#include "StringOps.h"
#include "TableData.hxx"
#include "TableInfo.h"
//-----------------------------------------------------------------------------
class InsertDataException : public MyException
{
public:
  InsertDataException(const std::string& aMsg)
    : MyException("InsertDataException: ", aMsg) { }
};
//-----------------------------------------------------------------------------
// @@WARNING: no checks are made for where this may not be the case
template<typename DataType>
void insertExtNum(FitsFile& ff, TableInfo& info, TableData<DataType>& data)
{
  // Attribute number in schema for the FITS extension number.
  int colNo = info.getAttNo(ExpectNames::extNum);

  // There is nothing to do if the extension number is not named in
  // the schema
  if (colNo == TableInfo::ColNotFound) return;

  // First row number in the data object for a particular HDU
  int row1 = 0;

  // loop over all extenions
  for (int hduNo = 2; hduNo <= ff.getNumHdus(); ++hduNo) {

    // Move to this extension
    ff.movabsHdu(hduNo);

    int row2 = 0;

    // If this HDU contains image data, then the rows just range over
    // one
    if (ff.isImageHdu()) {
      row2 = row1 + 1;
    }

    // If this HDU contains a binary table, then the rows range over
    // the number of rows in the table in the FITS file
    else if (ff.isBinaryTable()) {
      row2 = row1 + ff.getNumRows();
    }

    // If none of the above, set a null row range. This is actually a
    // bit weird - it may be better to throw an exception
    else {
      row2 = 0;
    }

    // Put in the extension number over this row range
    for (int rowNo = row1; rowNo < row2; ++rowNo) {
      data.assign(colNo, rowNo, hduNo);
    }

    // First row for the next HDU
    row1 = row2;
  }
}
//-----------------------------------------------------------------------------
template<typename DataType>
void insertKeywordValue(int colNo, int rowNo, FitsFile& ff,
                        std::string keyword, TableData<DataType>& data)
{
  // Try and read the keyword
  try
  {
    std::string keyValue;
    std::string filename = ff.getFileName();
    try
    {
      ff.readKey(keyword, keyValue);
    }
    catch (FitsKeyNotExist& e)
    {
      if (filename.find(PreSuffixNames::tileSuffix) != string::npos)
      {
        ff.movabsHdu(2);
        ff.readKey(keyword, keyValue);
      }
    }
    // check for blank entries and undefined entries
    if (keyValue.empty() || keyValue == "UNDEF")
    {
      data.setundef(colNo, rowNo);
    }
    else
    {
      data.assign(colNo, rowNo, keyValue);
    }
  }
  catch (FitsKeyNotExist& e)
  {
    // Log a warning if the key doesn't exist but don't put in the default
    // value at this stage
    Logger log;
    log.addWarning("FITS keyword missing: " + keyword +
                   ". In HDU no. " + StringOps::NumToString(ff.getHduNum()));
  }
}
//-----------------------------------------------------------------------------
template<typename DataType>
void insertFitsPrimaryHeader(int rowNo, FitsFile& ff, TableInfo& info,
                             TableData<DataType>& data)
{
  ff.movabsHdu(1);

  // Loop over all attributes - looking for those that come from FITS
  // primary header keywords
  int numCols = info.getNumAttributes();
  for (int colNo = 0; colNo < numCols; ++colNo)
  {
    // Full name of value of keyword tag in schema
    std::string fullname = info.getFitsKeywordName(colNo);
    if (!fullname.empty())
    {
      // Split the hdu.key doublet std::string
      std::string reqHduType, keyword;
      StringOps::splitDoublet(fullname, reqHduType, keyword);

      // Does the doublet correspond to a primary FITS keyword
      if (reqHduType.length() == 0) {
        insertKeywordValue(colNo, rowNo, ff, keyword, data);
      }
    }
  }
}
//-----------------------------------------------------------------------------
template<typename DataType>
void insertFitsExtensionHeader(int rowNo, FitsFile& ff, TableInfo& info,
                               TableData<DataType>& data)
{
  // What is the type of the current HDU
  std::string hduType;
  if (ff.isImageHdu())
    hduType = "IMAGE";
  else if (ff.isBinaryTable())
    hduType = "BINTABLE";
  else
    throw InsertDataException("Was expecting IMAGE or BINARY extension");


  // Loop over all attributes - looking for those that come from FITS
  // extension header keywords
  int numCols = info.getNumAttributes();
  for (int colNo = 0; colNo < numCols; ++colNo)
  {
    // Full name of value of keyword tag in schema
    std::string fullname = info.getFitsKeywordName(colNo);
    if (!fullname.empty())
    {
      // Split the hdu.key doublet std::string
      std::string reqHduType, keyword;
      StringOps::splitDoublet(fullname, reqHduType, keyword);

      if (hduType == reqHduType) {
        insertKeywordValue(colNo, rowNo, ff, keyword, data);
      }
    }
  }
}
//-----------------------------------------------------------------------------
template<typename DataType>
void insertFitsColumns(int firstRow, FitsFile& ff, TableInfo& info,
                       TableData<DataType>& data)
{
  Logger log;
  //--> throw exception if ff is not binary table
  // Number of sources in this HDU
  int numSources = ff.getNumRows();

  // Loop over all attributes - looking for those that come from FITS
  // column names
  int numCols = info.getNumAttributes();
  for (int colNo = 0; colNo < numCols; ++colNo)
  {
    // Does this attribute come from a FITS column?
    std::string fcolName = info.getFitsColumnName(colNo);
    if (!fcolName.empty())
    {
      // Try and read the named FITS column
      try
      {
        // Read column data
        data.loadFitsColumn(ff, fcolName, colNo, firstRow);

        // Read the given units in the file
        std::string givenUnits = ff.readColumnUnit(fcolName);

        // These are the required units according to the schema
        std::string reqUnits = info.getUnits(colNo);

        // Conversion factor from given to required units
        Converter converter;
        double convFactor = converter.getFactor(givenUnits, reqUnits);
        //log.addMessage("Read FITS column: " + fcolName + " " +
        //               reqUnits + " " + givenUnits + " " +
        //               StringOps::NumToString(convFactor));

        // Rescale the input data to required units
        for (int rowNo = firstRow; rowNo < firstRow + numSources; ++rowNo)
        {
          Numeric val;
          data.value(colNo, rowNo, val);

          val *= convFactor;
          data.assign(colNo, rowNo, val);
        }
      }
      // Log warning if named column can't be found
      catch (FitsColNotFound& e)
      {
        for (int rowNo = firstRow; rowNo < firstRow + numSources; ++rowNo)
        {
          data.setundef(colNo, rowNo);
        }
        log.addWarning("Fits column: " + fcolName + " not found");
      }
    }
  }
}
//-----------------------------------------------------------------------------
#endif
//-----------------------------------------------------------------------------
// Change log:
//
// 11-Mar-2004,  IAB: Original version.

---