KernelDb.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "KernelDb.h"
 
#include <iomanip>
#include <queue>
 
#include "CameraFactory.h"
#include "FileName.h"
#include "IException.h"
#include "IString.h"
#include "iTime.h"
#include "Kernel.h"
#include "Preference.h"
#include "Preference.h"
#include "PvlGroup.h"
#include "PvlKeyword.h"
#include "PvlObject.h"
 
using namespace std;
namespace Isis {
  KernelDb::KernelDb(const unsigned int allowedKernelTypes) {
    m_filename = "None";
    m_allowedKernelTypes = allowedKernelTypes;
    m_kernelDbFiles.clear();
  }
 

  KernelDb::KernelDb(const QString &dbName, const unsigned int allowedKernelTypes) :
    m_kernelData(dbName) {
    m_filename = dbName;
    m_allowedKernelTypes = allowedKernelTypes;
    m_kernelDbFiles.clear();
  }
 

  KernelDb::KernelDb(std::istream &dbStream, const unsigned int allowedKernelTypes) {
    dbStream >> m_kernelData;
    m_filename = "internal stream";
    m_allowedKernelTypes = allowedKernelTypes;
    m_kernelDbFiles.clear();
  }

  KernelDb::~KernelDb() {
  }

  Kernel KernelDb::leapSecond(Pvl &lab) {
    return findLast("LeapSecond", lab);
  }
 

  Kernel KernelDb::targetAttitudeShape(Pvl &lab) {
    return findLast("TargetAttitudeShape", lab);
  }
 

  Kernel KernelDb::targetPosition(Pvl &lab) {
    return findLast("TargetPosition", lab);
  }
 

  QList< std::priority_queue<Kernel> > KernelDb::spacecraftPointing(Pvl &lab) {
    return findAll("SpacecraftPointing", lab);
  }
 

  Kernel KernelDb::spacecraftClock(Pvl &lab) {
    return findLast("SpacecraftClock", lab);
  }
 

  Kernel KernelDb::spacecraftPosition(Pvl &lab) {
    return findLast("SpacecraftPosition", lab);
  }
 

  Kernel KernelDb::instrument(Pvl &lab) {
    return findLast("Instrument", lab);
  }
 

  Kernel KernelDb::frame(Pvl &lab) {
    return findLast("Frame", lab);
  }

  Kernel KernelDb::instrumentAddendum(Pvl &lab) {
    return findLast("InstrumentAddendum", lab);
  }
 

  Kernel KernelDb::dem(Pvl &lab) {
    return findLast("Dem", lab);
  }

  Kernel KernelDb::findLast(const QString &entry, Pvl &lab) {
 
    QList< priority_queue<Kernel> > queues = findAll(entry, lab);
    Kernel lastKernel;
 
    if (queues.size() > 0 && queues.at(0).size() > 0) {
      lastKernel = queues.at(0).top();
    }
 
    return lastKernel;
  }

  QList< std::priority_queue<Kernel> > KernelDb::findAll(const QString &entry,
      Pvl &lab) {
 
    QList< priority_queue<Kernel> > queues;
    PvlObject &cube = lab.findObject("IsisCube");
    int cameraVersion = -1;
 
    try {
      cameraVersion = CameraFactory::CameraVersion(lab);
    }
    catch (IException &) {
    }
 
    // Make sure the entry has been loaded into memory
    if (!m_kernelData.hasObject(entry)) {
      priority_queue<Kernel> emptyKernelQueue;
      emptyKernelQueue.push(Kernel());
      queues.push_back(emptyKernelQueue);
      return queues;
    }
 
    // Get the start and end time for the cube
    iTime start;
    iTime end;
 
    if (cube.hasGroup("Instrument")) {
      start = (QString) cube.findGroup("Instrument")["StartTime"];
 
      if (cube.findGroup("Instrument").hasKeyword("StopTime")) {
        end = ((QString) cube.findGroup("Instrument")["StopTime"]);
      }
      else {
        end = ((QString) cube.findGroup("Instrument")["StartTime"]);
      }
    }
 
    // Loop through the objects to look for all matches to the entry value
    for (int i = 0; i < m_kernelData.objects(); i++) {
      if (m_kernelData.object(i).isNamed(entry)) {
        priority_queue<Kernel> filesFound;
        PvlObject &obj = m_kernelData.object(i);
 
        for (int groupIndex = obj.groups() - 1; groupIndex >= 0; groupIndex--) {
          // Get the group and start testing the cases in the keywords
          // to see if they all match this cube
          PvlGroup &grp = obj.group(groupIndex);
 
          // If the group name isn't selection, skip it.
          if (!grp.isNamed("Selection")) continue;
 
          QString type = "";
 
          // Make sure the type is allowed
          if (grp.hasKeyword("Type")) {
            type = (QString) grp["Type"];
            if (!(Kernel::typeEnum(type) & m_allowedKernelTypes)) {
              // will return 1 for each bit that has 1 in both type and allowed and
              // return 0 for all other bits
              //
              // so, if Type = 0010 and allowed = 1010, then this bitwise operator
              // (type & allowed) returns 0010 and is true.
              // That is, this type is allowed.
              continue;
            }
          }
 
 
          bool startMatches = matches(lab, grp, start, cameraVersion);
          bool endMatches = matches(lab, grp, end, cameraVersion);
 
          if (startMatches && endMatches) {
            // Simple case - the selection simply matches
            filesFound.push(Kernel(Kernel::typeEnum(type), files(grp)));
            QStringList kernelfiles = files(grp);
          }
          else if (startMatches) {
            // Well, the selection start matched but not the end.
            // Let's look for a second selection to handle overlap areas.
            for (int endTimeIndex = obj.groups() - 1;
                endTimeIndex >= 0;
                endTimeIndex--) {
 
              PvlGroup &endTimeGrp = obj.group(endTimeIndex);
 
              // The second selection must:
              //   Not be the current selection
              //   Be a selection
              //   Be of the same quality
              //   Match the end time
              //
              // *If start time is also matched, do not merge and simply take the
              // secondary match
              if (endTimeIndex == groupIndex) continue;
              if (!endTimeGrp.isNamed("Selection")) continue;
              if (grp.hasKeyword("Type") != endTimeGrp.hasKeyword("Type")) continue;
              if (grp.hasKeyword("Type") &&
                  grp["Type"] != endTimeGrp["Type"]) continue;
              if (!matches(lab, endTimeGrp, end, cameraVersion)) continue;
 
              // Better match is true if we find a full overlap
              bool betterMatch = false;
 
              // True if we have matching time ranges = we want to merge
              bool endTimesMatch = true;
 
              // Check for matching time ranges
              for (int keyIndex = 0;
                  !betterMatch && keyIndex < grp.keywords();
                  keyIndex++) {
                PvlKeyword &key = grp[keyIndex];
 
                if (!key.isNamed("Time")) continue;
 
                iTime timeRangeStart((QString)key[0]);
                iTime timeRangeEnd((QString)key[1]);
 
                bool thisEndMatches = matches(lab, endTimeGrp,
                                              timeRangeEnd, cameraVersion);
                endTimesMatch = endTimesMatch && thisEndMatches;
 
                if (matches(lab, endTimeGrp, start, cameraVersion)
                   && matches(lab, endTimeGrp, end, cameraVersion)) {
                  // If we run into a continuous kernel, we want to take that in all
                  //   cases.
                  betterMatch = true;
                }
              }
 
              // No exact match but time ranges overlap, merge the selections
              if (!betterMatch && endTimesMatch) {
                QStringList startMatchFiles = files(grp);
                QStringList endMatchFiles = files(endTimeGrp);
 
                while (endMatchFiles.size()) {
                  startMatchFiles.push_back(endMatchFiles[endMatchFiles.size() - 1]);
                  endMatchFiles.pop_back();
                }
 
                filesFound.push(
                  Kernel(Kernel::typeEnum(type), startMatchFiles));
              }
              // Found an exact match, use it
              else if (betterMatch) {
                filesFound.push(Kernel(Kernel::typeEnum(type), files(endTimeGrp)));
                QStringList kernelfiles = files(endTimeGrp);
              }
            }
          }
        }
 
        queues.push_back(filesFound);
      }
    }
 
    if (queues.size() == 0) {
      priority_queue<Kernel> emptyKernelQueue;
      emptyKernelQueue.push(Kernel());
      queues.push_back(emptyKernelQueue);
    }
 
    return queues;
  }

  bool KernelDb::matches(const Pvl &lab, PvlGroup &grp,
                         iTime timeToMatch, int cameraVersion) {
    // These are the conditions that make this test pass:
    //   1) No time OR At least one matching time
    //   2) All keyword matches are true OR No keyword matches present
    //
    // In order to accomplish this, matchTime is initialized to true and remains
    // as such if and only if there are no time conditionals. If Time keywords
    // exist, one of them has to set matchTime to true. The matchKeywords is
    // true until a mismatch is found.
    const PvlObject &cube = lab.findObject("IsisCube");
    bool matchTime = !grp.hasKeyword("Time");
    bool matchKeywords = true;
    double startOffset = 0;
    double endOffset = 0;
    QString instrument = "";
 
    if (grp.hasKeyword("StartOffset")){
      startOffset = (double) grp["StartOffset"] + 0.001;
    }
    if (grp.hasKeyword("EndOffset")){
      endOffset = (double) grp["EndOffset"] + 0.001;
    }
    if (grp.hasKeyword("Instrument")){
      instrument = (QString) grp["Instrument"];
    }
 
    // First, the time search. Loop through the keywords, if the name isn't
    //  Time then skip it. If it is, then get the start/end times and keep
    //  looking until one is found.
    for (int keyword = 0; keyword < grp.keywords(); keyword++) {
      PvlKeyword key = grp[keyword];
 
      if (key.isNamed("Time")) {
 
        // Pull the selections start and end time out
        iTime kernelStart = (QString) key[0];
        iTime kernelEnd   = (QString) key[1];
 
        // If the kernel times inside of the requested times we
        // set the matchTime to be true.
        if ((kernelStart - startOffset <= timeToMatch) && (kernelEnd + endOffset >= timeToMatch)) {
          matchTime = true;
        }
        // If the kernel segment has an instrument specification that doesn't match
        // the instrument id in the label then the timing is always invalid
        if (!instrument.isEmpty()) {
          const PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse);
          QString instId = (QString) inst.findKeyword("InstrumentId");
          if (instId.compare(instrument) != 0) {
            matchTime = false;
          }
        }
      }
 
      else if (key.isNamed("Match")) {
        try {
          QString matchGroup = key[0];
          QString matchKey   = key[1];
          QString matchValue = key[2];
 
          QString cubeValue = cube.findGroup(matchGroup)[matchKey];
          cubeValue = cubeValue.simplified().trimmed().toUpper();
          matchValue = matchValue.simplified().trimmed().toUpper();
 
          // If QStrings are not the same, match automatically fails
          if (cubeValue.compare(matchValue) != 0) {
            matchKeywords = false;
          }
        }
        catch (IException &e) {
          // This error is thrown if the group or keyword do not exist in 'lab'
          matchKeywords = false;
        }
      }
      else if (key.isNamed("CameraVersion")) {
        try {
          for (int camVersionKeyIndex = 0;
              camVersionKeyIndex < key.size();
              camVersionKeyIndex++) {
 
            bool versionMatch = false;
            IString val = key[camVersionKeyIndex];
            IString commaTok;
 
            while ((commaTok = val.Token(",")).ToQt().length() > 0) {
              if (commaTok.find('-') != string::npos) {
                QString dashTok;
                int start = commaTok.Token("-").ToInteger();
                int end = commaTok.Token("-").ToInteger();
                int direction;
                direction = (start <= end) ? 1 : -1;
                // Save the entire range of bands
                for (int version = start;
                    version != end + direction;
                    version += direction) {
                  if (version == cameraVersion) {
                    versionMatch = true;
                  }
                }
              }
              // This token is a single band specification
              else {
                if (commaTok.ToInteger() == cameraVersion) {
                  versionMatch = true;
                }
              }
            }
 
            if (!versionMatch) {
              matchKeywords = false;
            }
          }
        }
        catch (IException &) {
          matchKeywords = false;
        }
      }
    }
 
    return matchKeywords && matchTime;
  }

  void KernelDb::loadSystemDb(const QString &mission, const Pvl &lab) {
 
    // Get the base DataDirectory
    PvlGroup &dataDir = Preference::Preferences().findGroup("DataDirectory");
    QString baseDir = dataDir["Base"];
 
    // Get the mission DataDirectory
    QString missionDir = dataDir[mission];
 
    // Load the leapsecond DB
    loadKernelDbFiles(dataDir, baseDir + "/kernels/lsk", lab);
    // Load the target attitude shape DB
    // Try to get mission specific pck data, if that
    // fails, fallback to the base pck data
    try {
      loadKernelDbFiles(dataDir, missionDir + "/kernels/pck", lab);
    }
    catch (IException &e) {
      loadKernelDbFiles(dataDir, baseDir + "/kernels/pck", lab);
    }
    // Load the target position DB
    FileName tpDbPath(missionDir + "/kernels/tspk");
    if (tpDbPath.fileExists()) {
      loadKernelDbFiles(dataDir, missionDir + "/kernels/tspk", lab);
    }
    else {
      loadKernelDbFiles(dataDir, baseDir + "/kernels/spk", lab);
    }
    // Load the DEM DB
    loadKernelDbFiles(dataDir, baseDir + "/dems", lab);
    // Load the mission specific spacecraft pointing DB
    loadKernelDbFiles(dataDir, missionDir + "/kernels/ck", lab);
    // Load the mission specific frame DB
    loadKernelDbFiles(dataDir, missionDir + "/kernels/fk", lab);
    // Load the mission specific instrument DB
    loadKernelDbFiles(dataDir, missionDir + "/kernels/ik", lab);
    // Load the mission specific spacecraft clock DB
    loadKernelDbFiles(dataDir, missionDir + "/kernels/sclk", lab);
    // Load the mission specific spacecraft position DB
    loadKernelDbFiles(dataDir, missionDir + "/kernels/spk", lab);
    // Load the mission specific instrument addendum DB
    loadKernelDbFiles(dataDir, missionDir + "/kernels/iak", lab);
    readKernelDbFiles();
  }

  void KernelDb::loadKernelDbFiles(PvlGroup &dataDir,
                                   QString directory, const Pvl &lab) {
    // get most recent version of config file
    FileName configFile = directory + "/kernels.????.conf";
    bool noConfigFile = false;
    // if there is no config file, default to the most recent kernel db file
    try {
      configFile = configFile.highestVersion();
    }
    catch (IException &e) {
      noConfigFile = true;
    }
    if (noConfigFile) {
      FileName kernelDb(directory + "/kernels.????.db");
      m_kernelDbFiles.append(kernelDb.highestVersion());
    }
    else { // else, read in the appropriate database files from the config file
      PvlObject inst = Pvl(configFile.expanded()).findObject("Instrument");
      bool foundMatch = false;
      // loop through each group until we find a match
      for (int groupIndex = 0; groupIndex < inst.groups(); groupIndex++) {
        if (!foundMatch) {
          PvlGroup &grp = inst.group(groupIndex);
          // Only add files in Selection groups with matching intrument id
          if (grp.isNamed("Selection")
              && KernelDb::matches(lab, grp, iTime(), 1)) {
            foundMatch = true;
            // add each File keywords in the matching group to the list
            for (int keyIndex = 0; keyIndex < grp.keywords(); keyIndex++) {
              PvlKeyword keyword = grp[keyIndex];
              if (keyword.isNamed("File")) {
                QString dir = dataDir[keyword[0]];
                FileName kernelDb( dir + "/" + keyword[1]);
                m_kernelDbFiles.append(kernelDb.highestVersion());
              }
            }
          }
        }
      }
    }
      return;
  }
 

  void KernelDb::readKernelDbFiles() {
    // read each of the database files appended to the list into m_kernelData
    foreach (FileName kernelDbFile, m_kernelDbFiles) {
      try {
        m_kernelData.read(kernelDbFile.expanded());
      }
      catch (IException &e) {
        QString msg = "Unable to read kernel database file ["
                      + kernelDbFile.expanded() + "].";
        throw IException(e, IException::Unknown, msg, _FILEINFO_);
      }
    }
  }

  QList<FileName> KernelDb::kernelDbFiles() {
    return m_kernelDbFiles;
  }
 

  QStringList KernelDb::files(PvlGroup &grp) {
    QStringList files;
 
    for (int i = 0; i < grp.keywords(); i++) {
      PvlKeyword kfile = grp[i];
      if (kfile.name() != "File") continue;
 
      // Two values in the "File" keyword from the DB,
      // indicates an ISIS preference in the DataDirectory section
      // and a filename
      if (kfile.size() == 2) {
        QString pref = kfile[0];
        QString version = kfile[1];
        FileName filename("$" + pref + "/" + version);
        if (filename.isVersioned())
          filename = filename.highestVersion();
        files.push_back(filename.originalPath() + "/" + filename.name());
      }
      // One value in "File" indicates a full file spec
      else if (kfile.size() == 1) {
        FileName filename(kfile[0]);
        if (filename.isVersioned())
          filename = filename.highestVersion();
        files.push_back(filename.originalPath() + "/" + filename.name());
      }
      else {
        QString msg = "Invalid File keyword value in [Group = ";
        msg += grp.name() + "] in database file [";
        msg += m_filename + "]";
        throw IException(IException::Unknown, msg, _FILEINFO_);
      }
    }
 
    return files;
  }
} //end namespace isis