DataMethodFactory.hxx

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// CVS: $Revision: 7472 $, $Date: 2010-09-01 11:37:02 +0100 (Wed, 01 Sep 2010) $, $Author: NicholasCross $
//-----------------------------------------------------------------------------
#ifndef DMFACTORY_H
#define DMFACTORY_H

#include <cstdlib>
#include <map>
#include <string>

#include "Constants.h"
#include "FitsFile.h"
#include "MyException.h"
#include "TableInfo.h"
#include "IllumTable.hxx"
#include "Options.h"
#include "StringOps.h"

// Data Methods
#include "AxesLength.hxx"
#include "Cartesian.hxx"
#include "CurationTaskID.hxx"
#include "DegToH.hxx"
#include "FileName.hxx"
#include "FileTimeStamp.hxx"
#include "FilterID.hxx"
#include "FrameID.hxx"
#include "FrameType.hxx"
#include "GalacticCoords.hxx"
#include "HtmIndex.hxx"
#include "JulianDayNum.hxx"
#include "Magnitudes.hxx"
#include "Moon.hxx"
#include "NumDetectors.hxx"
#include "ObjectID.hxx"
#include "ProgrammeID.hxx"
#include "QuantitiesByAst.hxx"
#include "RaDecByAst.hxx"
#include "HlRadCirc.hxx"
#include "HlRadii.hxx"
#include "SloanCoords.hxx"
#include "SkySubScale.hxx"
#include "TotalExpTime.hxx"
#include "TelRunNum.hxx"
#include "UtDate.hxx"
#include "VersionNum.hxx"
#include "VSAMagnitudes.hxx"
#include "VSAProject.hxx"
//-----------------------------------------------------------------------------
class DataMethodFactoryException : public MyException
{
public:
  DataMethodFactoryException(const std::string& aMsg)
    : MyException("DataMethodFactoryException: ", aMsg) { }
};
//-----------------------------------------------------------------------------
bool isMagnitudeError(const std::string& name)
{
  return StringOps::hasSubstr(name, "Mag") &&
        (StringOps::hasSubstr(name, "Err") ||
         StringOps::hasSubstr(name, "err"));
}
//-----------------------------------------------------------------------------
bool isMagnitude(const std::string& name)
{
  // If name has substring "Mag" but not "Err"
  return StringOps::hasSubstr(name, "Mag") && !isMagnitudeError(name) 
    && !StringOps::hasSubstr(name, "NoAperCorr");
}
//-----------------------------------------------------------------------------
bool isAperMag(const std::string& name)
{
  // If name has substring "Aper" but not "NoAperCorr"
  return StringOps::hasSubstr(name, "aperMag") && !isMagnitudeError(name)
    && !StringOps::hasSubstr(name, "NoAperCorr");
}
//-----------------------------------------------------------------------------
bool isWcsQuantity(const std::string& name)
{
  return
    name == ExpectNames::centralRa ||
    name == ExpectNames::centralDec ||
    name == ExpectNames::minRa ||
    name == ExpectNames::minDec ||
    name == ExpectNames::maxRa ||
    name == ExpectNames::maxDec ||
    name == ExpectNames::imageExtent;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
std::map<int, StringMap> makeTargetList(TableInfo& info)
{
  using std::map;
  Options options;

  int numTargets = 0;
  map<int, StringMap> target;

  for (unsigned n = 0; n < info.getNumAttributes(); ++n)
  {
    std::string name = info.getName(n);

    bool hasFits = !info.getFitsKeywordName(n).empty() ||
                   !info.getFitsColumnName(n).empty();

    if (!info.getUsingValue(n).empty() || !hasFits)
    {
      // Special case for axis length
      if (name == ExpectNames::numAxes) {
          target[numTargets][0] = ExpectNames::numAxes;
          target[numTargets][1] = ExpectNames::axis1Length;
          target[numTargets][2] = ExpectNames::axis2Length;
          ++numTargets;
      }

      // Special case for Cartesian vectors
      else if (name == ExpectNames::cx) {
        target[numTargets][0] = ExpectNames::cx;
        target[numTargets][1] = ExpectNames::cy;
        target[numTargets][2] = ExpectNames::cz;
        ++numTargets;
      }

      // Special case for WCS quantities
      else if (name == ExpectNames::centralRa) {
        target[numTargets][0] = ExpectNames::centralRa;
        target[numTargets][1] = ExpectNames::centralDec;
        target[numTargets][2] = ExpectNames::posAngle;
        target[numTargets][3] = ExpectNames::imageExtent;
        target[numTargets][4] = ExpectNames::xPixSize;
        target[numTargets][5] = ExpectNames::yPixSize;
        target[numTargets][6] = ExpectNames::minRa;
        target[numTargets][7] = ExpectNames::minDec;
        target[numTargets][8] = ExpectNames::maxRa;
        target[numTargets][9] = ExpectNames::maxDec;
        ++numTargets;
      }

      // Special case for (ra, dec) from WCS
      else if (name == ExpectNames::ra) {
        target[numTargets][0] = ExpectNames::ra;
        target[numTargets][1] = ExpectNames::dec;
        ++numTargets;
      }

      // Special case for galactic (l, b)
      else if (name == ExpectNames::l) {
        target[numTargets][0] = ExpectNames::l;
        target[numTargets][1] = ExpectNames::b;
        ++numTargets;
      }

      // Special case for Sloan (lambda, theta)
      else if (name == ExpectNames::lambda) {
        target[numTargets][0] = ExpectNames::lambda;
        target[numTargets][1] = ExpectNames::eta;
        ++numTargets;
      }

      // Special case for the Moon
      else if (name == ExpectNames::raMoon) {
        target[numTargets][0] = ExpectNames::raMoon;
        target[numTargets][1] = ExpectNames::decMoon;
        target[numTargets][2] = ExpectNames::illumMoon;
        target[numTargets][3] = ExpectNames::raMoonTopo;
        target[numTargets][4] = ExpectNames::decMoonTopo;
        ++numTargets;
      }
      // Special case for the circular half-light radius
      else if (name == ExpectNames::hlCircRadAs) {
        target[numTargets][0] = ExpectNames::hlCircRadAs;
        target[numTargets][1] = ExpectNames::hlCircRadErrAs;
        ++numTargets;
      }
      // Special case for the half-light radii
      else if (name == ExpectNames::hlGeoRadAs) {
        target[numTargets][0] = ExpectNames::hlGeoRadAs;
        target[numTargets][1] = ExpectNames::hlSMnRadAs;
        target[numTargets][2] = ExpectNames::hlSMjRadAs;
        target[numTargets][3] = ExpectNames::hlCorSMnRadAs;
        target[numTargets][4] = ExpectNames::hlCorSMjRadAs;
        ++numTargets;
      }
      // Special case for VSA Magnitudes and deltaMags
      else if (StringOps::ToLower(options.getArchive()) == "vsa" && 
               isMagnitude(name)) {
        target[numTargets][0] = name;
        target[numTargets][1] = ExpectNames::deltaMag;
        target[numTargets][2] = ExpectNames::illumCorr;
        target[numTargets][3] = ExpectNames::distortCorr;
        target[numTargets][4] = ExpectNames::saturatCorr;
        if (isAperMag(name) && 
            atoi(name.substr(name.rfind("Mag")+3).c_str()) < 8)
        {
          target[numTargets][5] = name.insert(name.rfind("Mag")+3,"NoAperCorr");
        } else {
          target[numTargets][5] = name;
        }
        ++numTargets;
      }

      // All other single value targets
      else {
        if (name != ExpectNames::illumCorr 
            && name != ExpectNames::distortCorr
            && name != ExpectNames::saturatCorr
            && !StringOps::hasSubstr(name, "NoAperCorr"))
        {
          target[numTargets][0] = name;
          ++numTargets;
        }
      }
    } // end if hasQ
  } // end loop through each attribute

  return target;
} // makeTargetList
//-----------------------------------------------------------------------------
bool isFrameID(const std::string& name)
{
  return (name == ExpectNames::multiframeID ||
          name == ExpectNames::combiframeID ||
          name == ExpectNames::darkID ||
          name == ExpectNames::flatID ||
          name == ExpectNames::confID ||
          name == ExpectNames::frinID ||
          name == ExpectNames::skyID ||
          name == ExpectNames::maskID ||
          name == ExpectNames::diffimID ||
          name == ExpectNames::stackID ||
          name == ExpectNames::mosaicID);
}
//-----------------------------------------------------------------------------
template<typename DataType>
DataMethod<DataType>* getFrameIDMethod(const std::string& name,
                                       TableInfo& info,
                                       FitsFile& ff)
{
  if (!info.getUsingValue(info.getAttNo(name)).empty())
  {
    std::string filename = ff.getFileName();
    std::string filePath = filename.substr(0,filename.rfind("/")+1);
    return new IndirectFrameID<DataType>(filePath);
  }
  else
  {
    return new DirectFrameID<DataType>(ff);
  }
}
//-----------------------------------------------------------------------------
template<typename DataType>
DataMethod<DataType>* getMethod(StringMap& target, TableInfo& info,
                                IllumTable& illum, 
                                FitsFile& fpix, FitsFile& fcat)
{
  Options options;
  int numArgs = target.size();

  if (numArgs == 1)
  {
    std::string name = target[0];

    // Select method to calculate the frame ID. This needs some
    // special consideration as to how the method is selected, so
    // delegate this to separately implemented function
    
    if (isFrameID(name))
    {
      return getFrameIDMethod<DataType>(name, info, fpix);
    }
    else if (name == ExpectNames::skySubScale)
    {
      return new SkySubScale<DataType>();
    }
    else if (name == ExpectNames::cuEventID)
    {
      return new CurationTaskID<DataType>();
    }
    else if (name == ExpectNames::ukirtRunNo)
    {
      return new TelRunNum<DataType>(fpix);
    }
    else if (name == ExpectNames::vistaRunNo)
    {
      return new TelRunNum<DataType>(fpix);
    }
    else if (name == ExpectNames::fileTimeStamp)
    {
      return new FileTimeStamp<DataType>(fpix);
    }
    else if (name == ExpectNames::programmeID)
    {
      return new ProgrammeID<DataType>();
    }
    else if (name == ExpectNames::numDetectors)
    {
      return new NumDetectors<DataType>(fpix);
    }
    else if (name == ExpectNames::fileName)
    {
      return new FileName<DataType>(fpix);
    }
    else if (name == ExpectNames::catName)
    {
      return new FileName<DataType>(fcat);
    }
    else if (name == ExpectNames::versionNum)
    {
      return new VersionNum<DataType>(fpix);
    }
    else if (name == ExpectNames::filterID)
    {
      if (info.isTableNumeric())
        return new FilterIDByFits<DataType>(fpix);
      else
        return new FilterID<DataType>();
    }
    else if (name == ExpectNames::project && 
             StringOps::ToLower(options.getArchive()) == "vsa")
    {
      return new VSAProject<DataType>(fpix);
    }
    else if (name == ExpectNames::utDate && 
             StringOps::ToLower(options.getArchive()) == "vsa")
    {
      return new UtDate<DataType>();
    }
    else if (name == ExpectNames::raBase && 
             StringOps::ToLower(options.getArchive()) == "vsa")
    {
      return new DegToH<DataType>();
    }
    else if (name == ExpectNames::julianDayNum)
    {
      return new JulianDayNum<DataType>();
    }
    else if (name == ExpectNames::frameType)
    {
      return new FrameType<DataType>(fpix);
    }
    else if (StringOps::ToLower(options.getArchive()) == "wsa" &&
             isMagnitude(name))
    {
      return new CalibratedMagnitude<DataType>(fcat, illum);
    }
    else if (isMagnitudeError(name))
    {
      return new MagnitudeError<DataType>();
    }
    else if (name == ExpectNames::totalExpTime)
    {
      return new TotalExpTime<DataType>(fpix);
    }
    else if (name == ExpectNames::htmID)
    {
      return new HtmIndex<DataType>
                 (
                   atoi(info.readTag(info.getAttNo(name),
                                     TagNames::HTMLEVEL).c_str()
                       )
                 );
    }
    else if (name == ExpectNames::objectId)
    {
      return new ObjectID<DataType>();
    }
    else
    {
      return new NothingToDo<DataType>();
    }
  } // end if numArgs == 1
  else if (numArgs == 2)
  {
    std::string name1 = target[0];
    std::string name2 = target[1];

    if (name1 == ExpectNames::l && name2 == ExpectNames::b)
    {
      return new GalacticCoords<DataType>();
    }
    else if (name1 == ExpectNames::lambda && name2 == ExpectNames::eta)
    {
      return new SloanCoords<DataType>();
    }
    else if (name1 == ExpectNames::ra  &&
             name2 == ExpectNames::dec &&
             !info.getUsingValue(info.getAttNo(name1)).empty())
    {
      return new RaDecByAst<DataType>(fcat);
    }
    else if (name1 == ExpectNames::hlCircRadAs && 
             name2 == ExpectNames::hlCircRadErrAs)
    {
      return new HlRadCirc<DataType>(fcat,fpix);
    }
    else
    {
      return new NothingToDo<DataType>();
    }
  } // end if numArgs == 2
  else if (numArgs == 3)
  {
    std::string name1 = target[0];
    std::string name2 = target[1];
    std::string name3 = target[2];

    // Case where cartesian calculation is required
    if (name1 == ExpectNames::cx &&
        name2 == ExpectNames::cy &&
        name3 == ExpectNames::cz)
    {
      return new Cartesian<DataType>();
    }
    else if (name1 == ExpectNames::numAxes     &&
             name2 == ExpectNames::axis1Length &&
             name3 == ExpectNames::axis2Length)
    {
      return new AxesLength<DataType>(fpix);
    }
    else
    {
      return new NothingToDo<DataType>();
    }
  } // end if numArgs == 3
  else if (numArgs == 5)
  {
    std::string name1 = target[0];
    std::string name2 = target[1];
    std::string name3 = target[2];
    std::string name4 = target[3];
    std::string name5 = target[4];
    
    if (name1 == ExpectNames::raMoon  &&
        name2 == ExpectNames::decMoon &&
        name3 == ExpectNames::illumMoon &&
        name4 == ExpectNames::raMoonTopo &&
        name5 == ExpectNames::decMoonTopo)
    {
      return new Moon<DataType>();
    }
    else if (name1 == ExpectNames::hlGeoRadAs &&
             name2 == ExpectNames::hlSMnRadAs &&
             name3 == ExpectNames::hlSMjRadAs &&
             name4 == ExpectNames::hlCorSMnRadAs &&
             name5 == ExpectNames::hlCorSMjRadAs)
    {
      return new HlRadii<DataType>(fcat,fpix);
    }
    else
    {
      return new NothingToDo<DataType>();
    }
  } // end if numArgs == 5
  else if (numArgs == 6)
  {
    std::string name1 = target[0];
    std::string name2 = target[1];
    std::string name3 = target[2];
    std::string name4 = target[3];
    std::string name5 = target[4];
    std::string name6 = target[5];

    if (StringOps::ToLower(options.getArchive()) == "vsa" &&
        name1 != ExpectNames::deltaMag && isMagnitude(name1) && 
        name2 == ExpectNames::deltaMag &&
        name3 == ExpectNames::illumCorr &&
        name4 == ExpectNames::distortCorr &&
        name5 == ExpectNames::saturatCorr)
    {
      return new CalibratedVSAMagnitude<DataType>(fcat, illum, name1);
    }
    else
    {
      return new NothingToDo<DataType>();
    }
  } // end if numArgs == 6
  else if (numArgs == 10)
  {
    std::string name1 = target[0];
    std::string name2 = target[1];
    std::string name3 = target[2];
    std::string name4 = target[3];
    std::string name5 = target[4];
    std::string name6 = target[5];
    std::string name7 = target[6];
    std::string name8 = target[7];
    std::string name9 = target[8];
    std::string name10 = target[9];

    // WCS quantities
    if (name1 == ExpectNames::centralRa &&
        name2 == ExpectNames::centralDec &&
        name3 == ExpectNames::posAngle &&
        name4 == ExpectNames::imageExtent &&
        name5 == ExpectNames::xPixSize &&
        name6 == ExpectNames::yPixSize &&
        name7 == ExpectNames::minRa &&
        name8 == ExpectNames::minDec &&
        name9 == ExpectNames::maxRa &&
        name10 == ExpectNames::maxDec)
    {
      return new QuantitiesByAst<DataType>(fpix);
    }
    else
    {
      return new NothingToDo<DataType>();
    }
  } // end if numArgs == 10
  else
  {
    return new NothingToDo<DataType>();
  }
}
//-----------------------------------------------------------------------------
#endif
//-----------------------------------------------------------------------------
// Change log:
//
// 27-May-2004,  IAB: Original version.
// 16-Mar-2006,  RSC: Made function checkArguments() in DataMethodFactory.hxx a
//                    method of DataMethod called determineSourceAndTarget()
//  7-Apr-2008, ETWS: Upgraded to use new detection table layout.
// 17-Apr-2008, ETWS: Included illumination correction.