FileIndex.cc

Go to the documentation of this file.

#include "canvas/Persistency/Provenance/FileIndex.h"

#include "cetlib/container_algorithms.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

#include <algorithm>
#include <iomanip>
#include <ostream>

using namespace cet;
using namespace std;

namespace {
  bool
  subRunUnspecified(art::EventID const& eID)
  {
    // This is nasty, principally because we don't want to be
    // encouraging too many people to do this. Basically, we're
    // checking whether the only reason an EventID is invalid is
    // because its subRun number is invalid.
    return (!eID.isValid()) && eID.runID().isValid() &&
           art::EventID(art::SubRunID::firstSubRun(), eID.event()).isValid();
  }
}

namespace art {

  void
  FileIndex::addEntry(EventID const& eID, EntryNumber_t const entry)
  {
    entries_.emplace_back(eID, entry);
    resultCached() = false;
    sortState() = kNotSorted;
  }

  void
  FileIndex::addEntryOnLoad(EventID const& eID, EntryNumber_t const entry)
  {
    entries_.emplace_back(eID, entry);
    resultCached() = false;
  }

  void
  FileIndex::sortBy_Run_SubRun_Event()
  {
    stable_sort_all(entries_);
    resultCached() = false;
    sortState() = kSorted_Run_SubRun_Event;
  }

  void
  FileIndex::sortBy_Run_SubRun_EventEntry()
  {
    stable_sort_all(entries_, Compare_Run_SubRun_EventEntry());
    resultCached() = false;
    sortState() = kSorted_Run_SubRun_EventEntry;
  }

  bool
  FileIndex::allEventsInEntryOrder() const
  {
    if (!resultCached()) {
      resultCached() = true;
      EntryNumber_t maxEntry{Element::invalidEntry};
      for (auto const& e : entries_) {
        if (e.getEntryType() == kEvent) {
          if (e.entry_ < maxEntry) {
            allInEntryOrder() = false;
            return false;
          }
          maxEntry = e.entry_;
        }
      }
      allInEntryOrder() = true;
      return true;
    }
    return allInEntryOrder();
  }

  bool
  FileIndex::eventsUniqueAndOrdered() const
  {

    auto it = cbegin();
    auto itEnd = cend();

    // Set up the iterators to point to first two events
    // (In the trivial case where there is zero or one event,
    // the set is unique and ordered by construction).

    if (it == itEnd)
      return true;

    // Step to first event
    while (it->getEntryType() != kEvent) {
      ++it;
      if (it == itEnd)
        return true;
    }
    auto itPrevious = it;

    // Step to second event
    ++it;
    if (it == itEnd)
      return true;
    while (it->getEntryType() != kEvent) {
      ++it;
      if (it == itEnd)
        return true;
    }

    for (; it != itEnd; ++it) {
      if (it->getEntryType() == kEvent) {
        if (it->eventID_ <= itPrevious->eventID_)
          return false;
        itPrevious = it;
      }
    }
    return true; // finished and found no duplicates
  }

  FileIndex::const_iterator
  FileIndex::findPosition(EventID const& eID) const
  {

    assert(sortState() == kSorted_Run_SubRun_Event);

    Element el{eID};
    return lower_bound_all(entries_, el);
  }

  template <>
  FileIndex::const_iterator
  FileIndex::findPosition(EventID const& eID, bool exact) const
  {

    assert(sortState() == kSorted_Run_SubRun_Event);

    if (subRunUnspecified(eID)) {
      return findEventForUnspecifiedSubRun(eID, exact);
    }

    const_iterator it = findPosition(eID);
    const_iterator itEnd = entries_.end();
    while (it != itEnd && it->getEntryType() != FileIndex::kEvent) {
      ++it;
    }
    if (it == itEnd)
      return itEnd;
    if (exact && (*it != eID))
      return itEnd;
    return it;
  }

  template <>
  FileIndex::const_iterator
  FileIndex::findPosition(SubRunID const& srID, bool exact) const
  {
    assert(sortState() != kNotSorted);
    const_iterator it;
    auto const invID = EventID::invalidEvent(srID);
    if (sortState() == kSorted_Run_SubRun_EventEntry) {
      Element const el{invID};
      it = lower_bound_all(entries_, el, Compare_Run_SubRun_EventEntry());
    } else {
      it = findPosition(invID);
    }
    auto const itEnd = entries_.cend();
    while (it != itEnd && it->getEntryType() != FileIndex::kSubRun) {
      ++it;
    }
    if (it == itEnd)
      return itEnd;
    if (exact && (it->eventID_.subRunID() != srID))
      return itEnd;
    return it;
  }

  template <>
  FileIndex::const_iterator
  FileIndex::findPosition(RunID const& rID, bool exact) const
  {
    assert(sortState() != kNotSorted);
    const_iterator it;
    auto const invID = EventID::invalidEvent(rID);
    if (sortState() == kSorted_Run_SubRun_EventEntry) {
      Element const el{invID};
      it = lower_bound_all(entries_, el, Compare_Run_SubRun_EventEntry());
    } else {
      it = findPosition(invID);
    }
    auto const itEnd = entries_.cend();
    while (it != itEnd && it->getEntryType() != FileIndex::kRun) {
      ++it;
    }
    if (it == itEnd)
      return itEnd;
    if (exact && (it->eventID_.runID() != rID))
      return itEnd;
    return it;
  }

  FileIndex::const_iterator
  FileIndex::findSubRunOrRunPosition(SubRunID const& srID) const
  {
    assert(sortState() != kNotSorted);
    const_iterator it;
    if (sortState() == kSorted_Run_SubRun_EventEntry) {
      Element el{EventID::invalidEvent(srID)};
      it = lower_bound_all(entries_, el, Compare_Run_SubRun_EventEntry());
    } else {
      it = findPosition(EventID::invalidEvent(srID));
    }
    auto const itEnd = entries_.cend();
    while (it != itEnd && it->getEntryType() != FileIndex::kSubRun &&
           it->getEntryType() != FileIndex::kRun) {
      ++it;
    }
    return it;
  }

  bool
  operator<(FileIndex::Element const& lh, FileIndex::Element const& rh)
  {
    bool const result = lh.eventID_ < rh.eventID_;
    return result;
  }

  bool
  Compare_Run_SubRun_EventEntry::operator()(FileIndex::Element const& lh,
                                            FileIndex::Element const& rh)
  {
    if (lh.eventID_.subRunID() == rh.eventID_.subRunID()) {
      if ((!lh.eventID_.isValid()) && (!rh.eventID_.isValid())) {
        return false;
      } else if (!lh.eventID_.isValid()) {
        return true;
      } else if (!rh.eventID_.isValid()) {
        return false;
      } else {
        return lh.entry_ < rh.entry_;
      }
    } else {
      return lh.eventID_.subRunID() < rh.eventID_.subRunID();
    }
  }

  ostream&
  operator<<(ostream& os, FileIndex::Element const& el)
  {
    os << el.eventID_ << ": entry# " << el.entry_;
    return os;
  }

  void
  FileIndex::print_event_list(ostream& os) const
  {
    os << "\nPrinting the list of Runs, SubRuns, and Events stored in the root "
          "file.\n\n";
    os << setw(15) << "Run" << setw(15) << "SubRun" << setw(15) << "Event"
       << "\n";
    for (auto const& e : entries_) {
      if (e.getEntryType() == FileIndex::kEvent) {
        os << setw(15) << e.eventID_.run() << setw(15) << e.eventID_.subRun()
           << setw(15) << e.eventID_.event() << "\n";
      } else if (e.getEntryType() == FileIndex::kSubRun) {
        os << setw(15) << e.eventID_.run() << setw(15) << e.eventID_.subRun()
           << setw(15) << " "
           << "\n";
      } else if (e.getEntryType() == FileIndex::kRun) {
        os << setw(15) << e.eventID_.run() << setw(15) << " " << setw(15) << " "
           << "\n";
      }
    }
  }

  ostream&
  operator<<(ostream& os, FileIndex const& fileIndex)
  {

    os << "\nPrinting FileIndex contents.  This includes a list of all Runs, "
          "SubRuns\n"
       << "and Events stored in the root file.\n\n";
    os << setw(15) << "Run" << setw(15) << "SubRun" << setw(15) << "Event"
       << setw(15) << "TTree Entry"
       << "\n";
    for (auto const& e : fileIndex) {
      if (e.getEntryType() == FileIndex::kEvent) {
        os << setw(15) << e.eventID_.run() << setw(15) << e.eventID_.subRun()
           << setw(15) << e.eventID_.event() << setw(15) << e.entry_ << "\n";
      } else if (e.getEntryType() == FileIndex::kSubRun) {
        os << setw(15) << e.eventID_.run() << setw(15) << e.eventID_.subRun()
           << setw(15) << " " << setw(15) << e.entry_ << "  (SubRun)"
           << "\n";
      } else if (e.getEntryType() == FileIndex::kRun) {
        os << setw(15) << e.eventID_.run() << setw(15) << " " << setw(15) << " "
           << setw(15) << e.entry_ << "  (Run)"
           << "\n";
      }
    }
    return os;
  }

  FileIndex::const_iterator
  FileIndex::findEventForUnspecifiedSubRun(EventID const& eID, bool exact) const
  {

    RunID const& runID = eID.runID();
    EventNumber_t event = eID.event();
    SubRunID last_subRunID;

    // Try to find the event.
    auto const firstEvent =
      findPosition(EventID::firstEvent(SubRunID::firstSubRun(runID)), false);
    const_iterator it = firstEvent;
    const_iterator const itEnd = entries_.end();
    if (it == itEnd)
      return it;

    // Starting with it, jump to the first event of each subrun until
    // we find either:
    //
    // 1. The next run.
    // 2. An event number higher than we want.
    // 3. The end of the file index.
    while ((it != itEnd) && (it->eventID_.runID() == runID) &&
           (it->eventID_.event() < event)) {
      last_subRunID = it->eventID_.subRunID();
      // Get the first event in the next subrun.
      it = findPosition(EventID::firstEvent(it->eventID_.subRunID().next()),
                        false);
    }

    const_iterator result = itEnd;
    if ((it != itEnd) && (it->eventID_.runID() == runID) &&
        (it->eventID_.event() == event)) {
      // We started on the correct event.
      result = it;
    } else if (last_subRunID.isValid()) {
      // Find the event in the last subrun.
      result = findPosition(EventID(last_subRunID, event), exact);
    }
    if (result == itEnd) {
      // Did not find anything.
      mf::LogWarning("FileIndex")
        << "Could not find incompletely specified event " << eID
        << " with smart algorithm:\n"
        << "Assuming pathological file structure (event selection?) and\n"
        << "trying again (inefficient).\n"
        << "NOTE: this will find only the event with matching event number "
        << "and the\n"
        << "      lowest subrun number: any others are inaccessible via this "
        << "method.";
      SubRunID trySubRun{SubRunID::firstSubRun(runID)};
      // Try to find the highest subrun number in this run.
      const_iterator findIt(firstEvent);
      SubRunID lastSubRunInRun{trySubRun};
      for (; findIt != itEnd && findIt->eventID_.runID() == runID;
           findIt =
             findPosition(EventID::firstEvent(lastSubRunInRun.next()), false)) {
        lastSubRunInRun = findIt->eventID_.subRunID();
      }
      // Now loop through each subrun looking for an exact match to our event.
      while ((findIt = findPosition(EventID(trySubRun, event), true)) ==
               itEnd &&
             trySubRun < lastSubRunInRun) {
        trySubRun = trySubRun.next();
      }
      result = findIt;
    }
    return result;
  }
}