|
|
|
#include <RootFile.h>
Definition at line 45 of file RootFile.h.
| typedef boost::array<RootTree*, NumBranchTypes> edm::RootFile::RootTreePtrArray |
Definition at line 47 of file RootFile.h.
| edm::RootFile::RootFile | ( | std::string const & | fileName, |
| ProcessConfiguration const & | processConfiguration, | ||
| std::string const & | logicalFileName, | ||
| boost::shared_ptr< InputFile > | filePtr, | ||
| boost::shared_ptr< EventSkipperByID > | eventSkipperByID, | ||
| bool | skipAnyEvents, | ||
| int | remainingEvents, | ||
| int | remainingLumis, | ||
| unsigned int | treeCacheSize, | ||
| int | treeMaxVirtualSize, | ||
| InputSource::ProcessingMode | processingMode, | ||
| RunNumber_t const & | forcedRunNumber, | ||
| bool | noEventSort, | ||
| GroupSelectorRules const & | groupSelectorRules, | ||
| InputType::InputType | inputType, | ||
| boost::shared_ptr< DuplicateChecker > | duplicateChecker, | ||
| bool | dropDescendantsOfDroppedProducts, | ||
| std::vector< boost::shared_ptr< IndexIntoFile > > const & | indexesIntoFiles, | ||
| std::vector< boost::shared_ptr< IndexIntoFile > >::size_type | currentIndexIntoFile, | ||
| std::vector< ProcessHistoryID > & | orderedProcessHistoryIDs, | ||
| bool | usingGoToEvent | ||
| ) |
Definition at line 103 of file RootFile.cc.
References edm::IndexIntoFile::begin(), branchChildren_, edm::poolNames::branchIDListBranchName(), branchIDLists_, branchListIndexesUnchanged_, edm::BranchDescription::branchName(), edm::BranchDescription::branchType(), edm::BranchTypeToAuxiliaryBranchName(), checkReleaseVersion(), edm::BranchDescription::className(), edm::roottree::defaultNonEventCacheSize, edm::IndexIntoFile::doneFileInitialization(), dropOnInput(), edm::IndexIntoFile::end(), edm::errors::EventCorruption, edm::poolNames::eventHistoryBranchName(), eventProcessHistoryIDs_, eventProcessHistoryIter_, eventSkipperByID_, edm::FileBlock::EventsOrLumisSelectedByID, eventTree_, Exception, fid_, file_, fileFormatVersion(), fileFormatVersion_, edm::poolNames::fileFormatVersionBranchName(), edm::poolNames::fileIdentifierBranchName(), filePtr_, edm::errors::FileReadError, edm::fillProductRegistryTransients(), edm::IndexIntoFile::firstAppearanceOrder, edm::cc::forcedRunOffset(), forcedRunOffset_, edm::BranchDescription::friendlyClassName(), edm::friendlyname::friendlyName(), edm::roottree::getEntry(), hasNewlyDroppedBranch_, i, edm::poolNames::idToParameterSetBlobsBranchName(), indexIntoFile_, indexIntoFileBegin_, edm::poolNames::indexIntoFileBranchName(), indexIntoFileEnd_, indexIntoFileIter_, edm::InEvent, initializeDuplicateChecker(), edm::InLumi, edm::InRun, edm::detail::ThreadSafeRegistry< KEY, T, E >::insertMapped(), edm::detail::ThreadSafeRegistry< KEY, T, E >::instance(), lumiTree_, edm::poolNames::metaDataTreeName(), edm::poolNames::moduleDescriptionMapBranchName(), newBranchToOldBranch(), newBranchToOldBranch_, edm::IndexIntoFile::numericalOrder, edm::poolNames::parameterSetMapBranchName(), edm::poolNames::parameterSetsTreeName(), edm::InputType::Primary, edm::poolNames::processConfigurationBranchName(), processConfigurations_, edm::poolNames::processHistoryBranchName(), edm::poolNames::processHistoryMapBranchName(), parseEventContent::prod, edm::poolNames::productDependenciesBranchName(), edm::poolNames::productDescriptionBranchName(), edm::ProductRegistry::productList(), productRegistry(), productRegistry_, provenanceAdaptor_, readEventHistoryTree(), readParentageTree(), edm::RootTree::resetTraining(), runTree_, secondaryEventPrincipal_, edm::InputType::SecondarySource, edm::ParameterSet::setID(), setIfFastClonable(), edm::setRefCoreStreamer(), edm::RootTree::trainCache(), edm::roottree::trainCache(), treePointers_, edm::errors::UnimplementedFeature, edm::BranchDescription::updateFriendlyClassName(), edm::BranchIDListHelper::updateFromInput(), validateFile(), and whyNotFastClonable_.
:
file_(fileName),
logicalFile_(logicalFileName),
processConfiguration_(processConfiguration),
processConfigurations_(),
filePtr_(filePtr),
eventSkipperByID_(eventSkipperByID),
fileFormatVersion_(),
fid_(),
indexIntoFileSharedPtr_(new IndexIntoFile),
indexIntoFile_(*indexIntoFileSharedPtr_),
orderedProcessHistoryIDs_(orderedProcessHistoryIDs),
indexIntoFileBegin_(indexIntoFile_.begin(noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder)),
indexIntoFileEnd_(indexIntoFileBegin_),
indexIntoFileIter_(indexIntoFileBegin_),
eventProcessHistoryIDs_(),
eventProcessHistoryIter_(eventProcessHistoryIDs_.begin()),
skipAnyEvents_(skipAnyEvents),
noEventSort_(noEventSort),
whyNotFastClonable_(0),
hasNewlyDroppedBranch_(),
branchListIndexesUnchanged_(false),
eventAux_(),
eventTree_(filePtr_, fileFormatVersion_, InEvent, treeMaxVirtualSize, treeCacheSize, roottree::defaultLearningEntries),
lumiTree_(filePtr_, fileFormatVersion_, InLumi, treeMaxVirtualSize, roottree::defaultNonEventCacheSize, roottree::defaultNonEventLearningEntries),
runTree_(filePtr_, fileFormatVersion_, InRun, treeMaxVirtualSize, roottree::defaultNonEventCacheSize, roottree::defaultNonEventLearningEntries),
treePointers_(),
lastEventEntryNumberRead_(-1LL),
productRegistry_(),
branchIDLists_(),
processingMode_(processingMode),
forcedRunOffset_(0),
newBranchToOldBranch_(),
eventHistoryTree_(0),
eventSelectionIDs_(new EventSelectionIDVector),
branchListIndexes_(new BranchListIndexes),
history_(),
branchChildren_(new BranchChildren),
duplicateChecker_(duplicateChecker),
provenanceAdaptor_(),
secondaryEventPrincipal_(),
eventBranchMapper_() {
hasNewlyDroppedBranch_.assign(false);
treePointers_[InEvent] = &eventTree_;
treePointers_[InLumi] = &lumiTree_;
treePointers_[InRun] = &runTree_;
// Read the metadata tree.
// We use a smart pointer so the tree will be deleted after use, and not kept for the life of the file.
std::auto_ptr<TTree> metaDataTree(dynamic_cast<TTree *>(filePtr_->Get(poolNames::metaDataTreeName().c_str())));
if(0 == metaDataTree.get()) {
throw Exception(errors::FileReadError) << "Could not find tree " << poolNames::metaDataTreeName()
<< " in the input file.\n";
}
// To keep things simple, we just read in every possible branch that exists.
// We don't pay attention to which branches exist in which file format versions
FileFormatVersion *fftPtr = &fileFormatVersion_;
if(metaDataTree->FindBranch(poolNames::fileFormatVersionBranchName().c_str()) != 0) {
TBranch *fft = metaDataTree->GetBranch(poolNames::fileFormatVersionBranchName().c_str());
fft->SetAddress(&fftPtr);
roottree::getEntry(fft, 0);
metaDataTree->SetBranchAddress(poolNames::fileFormatVersionBranchName().c_str(), &fftPtr);
}
setRefCoreStreamer(0, !fileFormatVersion().splitProductIDs(), !fileFormatVersion().productIDIsInt()); // backward compatibility
FileID *fidPtr = &fid_;
if(metaDataTree->FindBranch(poolNames::fileIdentifierBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::fileIdentifierBranchName().c_str(), &fidPtr);
}
IndexIntoFile *iifPtr = &indexIntoFile_;
if(metaDataTree->FindBranch(poolNames::indexIntoFileBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::indexIntoFileBranchName().c_str(), &iifPtr);
}
// Need to read to a temporary registry so we can do a translation of the BranchKeys.
// This preserves backward compatibility against friendly class name algorithm changes.
ProductRegistry inputProdDescReg;
ProductRegistry *ppReg = &inputProdDescReg;
metaDataTree->SetBranchAddress(poolNames::productDescriptionBranchName().c_str(), (&ppReg));
typedef std::map<ParameterSetID, ParameterSetBlob> PsetMap;
PsetMap psetMap;
PsetMap *psetMapPtr = &psetMap;
if(metaDataTree->FindBranch(poolNames::parameterSetMapBranchName().c_str()) != 0) {
//backward compatibility
assert(!fileFormatVersion().parameterSetsTree());
metaDataTree->SetBranchAddress(poolNames::parameterSetMapBranchName().c_str(), &psetMapPtr);
} else {
assert(fileFormatVersion().parameterSetsTree());
// We use a smart pointer so the tree will be deleted after use, and not kept for the life of the file.
std::auto_ptr<TTree> psetTree(dynamic_cast<TTree *>(filePtr_->Get(poolNames::parameterSetsTreeName().c_str())));
if(0 == psetTree.get()) {
throw Exception(errors::FileReadError) << "Could not find tree " << poolNames::parameterSetsTreeName()
<< " in the input file.\n";
}
typedef std::pair<ParameterSetID, ParameterSetBlob> IdToBlobs;
IdToBlobs idToBlob;
IdToBlobs* pIdToBlob = &idToBlob;
psetTree->SetBranchAddress(poolNames::idToParameterSetBlobsBranchName().c_str(), &pIdToBlob);
std::auto_ptr<TTreeCache> psetTreeCache = roottree::trainCache(psetTree.get(), *filePtr_, roottree::defaultNonEventCacheSize, "*");
filePtr_->SetCacheRead(psetTreeCache.get());
for(Long64_t i = 0; i != psetTree->GetEntries(); ++i) {
psetTree->GetEntry(i);
psetMap.insert(idToBlob);
}
filePtr_->SetCacheRead(0);
}
// backward compatibility
ProcessHistoryRegistry::collection_type pHistMap;
ProcessHistoryRegistry::collection_type *pHistMapPtr = &pHistMap;
if(metaDataTree->FindBranch(poolNames::processHistoryMapBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::processHistoryMapBranchName().c_str(), &pHistMapPtr);
}
ProcessHistoryRegistry::vector_type pHistVector;
ProcessHistoryRegistry::vector_type *pHistVectorPtr = &pHistVector;
if(metaDataTree->FindBranch(poolNames::processHistoryBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::processHistoryBranchName().c_str(), &pHistVectorPtr);
}
ProcessConfigurationVector* procConfigVectorPtr = &processConfigurations_;
if(metaDataTree->FindBranch(poolNames::processConfigurationBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::processConfigurationBranchName().c_str(), &procConfigVectorPtr);
}
std::auto_ptr<BranchIDListRegistry::collection_type> branchIDListsAPtr(new BranchIDListRegistry::collection_type);
BranchIDListRegistry::collection_type *branchIDListsPtr = branchIDListsAPtr.get();
if(metaDataTree->FindBranch(poolNames::branchIDListBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::branchIDListBranchName().c_str(), &branchIDListsPtr);
}
BranchChildren* branchChildrenBuffer = branchChildren_.get();
if(metaDataTree->FindBranch(poolNames::productDependenciesBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::productDependenciesBranchName().c_str(), &branchChildrenBuffer);
}
// backward compatibility
std::vector<EventProcessHistoryID> *eventHistoryIDsPtr = &eventProcessHistoryIDs_;
if(metaDataTree->FindBranch(poolNames::eventHistoryBranchName().c_str()) != 0) {
metaDataTree->SetBranchAddress(poolNames::eventHistoryBranchName().c_str(), &eventHistoryIDsPtr);
}
if(metaDataTree->FindBranch(poolNames::moduleDescriptionMapBranchName().c_str()) != 0) {
if(metaDataTree->GetBranch(poolNames::moduleDescriptionMapBranchName().c_str())->GetSplitLevel() != 0) {
metaDataTree->SetBranchStatus((poolNames::moduleDescriptionMapBranchName() + ".*").c_str(), 0);
} else {
metaDataTree->SetBranchStatus(poolNames::moduleDescriptionMapBranchName().c_str(), 0);
}
}
// Here we read the metadata tree
roottree::getEntry(metaDataTree.get(), 0);
checkReleaseVersion();
eventProcessHistoryIter_ = eventProcessHistoryIDs_.begin();
// Here we read the event history tree, if we have one.
readEventHistoryTree();
ParameterSetConverter::ParameterSetIdConverter psetIdConverter;
if(!fileFormatVersion().triggerPathsTracked()) {
ParameterSetConverter converter(psetMap, psetIdConverter, fileFormatVersion().parameterSetsByReference());
} else {
// Merge into the parameter set registry.
pset::Registry& psetRegistry = *pset::Registry::instance();
for(PsetMap::const_iterator i = psetMap.begin(), iEnd = psetMap.end(); i != iEnd; ++i) {
ParameterSet pset(i->second.pset());
pset.setID(i->first);
psetRegistry.insertMapped(pset);
}
}
if(!fileFormatVersion().splitProductIDs()) {
// Old provenance format input file. Create a provenance adaptor.
provenanceAdaptor_.reset(new ProvenanceAdaptor(
inputProdDescReg, pHistMap, pHistVector, processConfigurations_, psetIdConverter, true));
// Fill in the branchIDLists branch from the provenance adaptor
branchIDLists_ = provenanceAdaptor_->branchIDLists();
} else {
if(!fileFormatVersion().triggerPathsTracked()) {
// New provenance format, but change in ParameterSet Format. Create a provenance adaptor.
provenanceAdaptor_.reset(new ProvenanceAdaptor(
inputProdDescReg, pHistMap, pHistVector, processConfigurations_, psetIdConverter, false));
}
// New provenance format input file. The branchIDLists branch was read directly from the input file.
if(metaDataTree->FindBranch(poolNames::branchIDListBranchName().c_str()) == 0) {
throw Exception(errors::EventCorruption)
<< "Failed to find branchIDLists branch in metaData tree.\n";
}
branchIDLists_.reset(branchIDListsAPtr.release());
}
// Merge into the hashed registries.
ProcessHistoryRegistry::instance()->insertCollection(pHistVector);
ProcessConfigurationRegistry::instance()->insertCollection(processConfigurations_);
eventTree_.trainCache(BranchTypeToAuxiliaryBranchName(InEvent).c_str());
validateFile(inputType, usingGoToEvent);
// Read the parentage tree. Old format files are handled internally in readParentageTree().
readParentageTree();
if(eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
whyNotFastClonable_ += FileBlock::EventsOrLumisSelectedByID;
}
initializeDuplicateChecker(indexesIntoFiles, currentIndexIntoFile);
indexIntoFileIter_ = indexIntoFileBegin_ = indexIntoFile_.begin(noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder);
indexIntoFileEnd_ = indexIntoFile_.end(noEventSort ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder);
forcedRunOffset_ = forcedRunOffset(forcedRunNumber, indexIntoFileBegin_, indexIntoFileEnd_);
eventProcessHistoryIter_ = eventProcessHistoryIDs_.begin();
// Set product presence information in the product registry.
ProductRegistry::ProductList const& pList = inputProdDescReg.productList();
for(ProductRegistry::ProductList::const_iterator it = pList.begin(), itEnd = pList.end();
it != itEnd; ++it) {
BranchDescription const& prod = it->second;
treePointers_[prod.branchType()]->setPresence(prod);
}
fillProductRegistryTransients(processConfigurations_, inputProdDescReg);
std::auto_ptr<ProductRegistry> newReg(new ProductRegistry);
// Do the translation from the old registry to the new one
{
ProductRegistry::ProductList const& prodList = inputProdDescReg.productList();
for(ProductRegistry::ProductList::const_iterator it = prodList.begin(), itEnd = prodList.end();
it != itEnd; ++it) {
BranchDescription const& prod = it->second;
std::string newFriendlyName = friendlyname::friendlyName(prod.className());
if(newFriendlyName == prod.friendlyClassName()) {
newReg->copyProduct(prod);
} else {
if(fileFormatVersion().splitProductIDs()) {
throw Exception(errors::UnimplementedFeature)
<< "Cannot change friendly class name algorithm without more development work\n"
<< "to update BranchIDLists. Contact the framework group.\n";
}
BranchDescription newBD(prod);
newBD.updateFriendlyClassName();
newReg->copyProduct(newBD);
newBranchToOldBranch_.insert(std::make_pair(newBD.branchName(), prod.branchName()));
}
}
dropOnInput(*newReg, groupSelectorRules, dropDescendants, inputType);
// freeze the product registry
newReg->setFrozen(inputType != InputType::Primary);
productRegistry_.reset(newReg.release());
}
// Set up information from the product registry.
ProductRegistry::ProductList const& prodList = productRegistry()->productList();
for(ProductRegistry::ProductList::const_iterator it = prodList.begin(), itEnd = prodList.end();
it != itEnd; ++it) {
BranchDescription const& prod = it->second;
treePointers_[prod.branchType()]->addBranch(it->first, prod,
newBranchToOldBranch(prod.branchName()));
}
// Event Principal cache for secondary input source
if(inputType == InputType::SecondarySource) {
secondaryEventPrincipal_.reset(new EventPrincipal(productRegistry(), processConfiguration));
}
// Determine if this file is fast clonable.
setIfFastClonable(remainingEvents, remainingLumis);
// Update the branch id info.
if(inputType == InputType::Primary) {
branchListIndexesUnchanged_ = BranchIDListHelper::updateFromInput(*branchIDLists_, file_);
}
setRefCoreStreamer(true); // backward compatibility
// We are done with our initial reading of EventAuxiliary.
indexIntoFile_.doneFileInitialization();
// Tell the event tree to begin training at the next read.
eventTree_.resetTraining();
// Train the run and lumi trees.
runTree_.trainCache("*");
lumiTree_.trainCache("*");
}
RootFile::~RootFile() {
}
| edm::RootFile::~RootFile | ( | ) |
| BranchIDListRegistry::collection_type const& edm::RootFile::branchIDLists | ( | ) | [inline] |
| bool edm::RootFile::branchListIndexesUnchanged | ( | ) | const [inline] |
Definition at line 97 of file RootFile.h.
References branchListIndexesUnchanged_.
{return branchListIndexesUnchanged_;}
| void edm::RootFile::checkReleaseVersion | ( | ) | [private] |
Definition at line 1499 of file RootFile.cc.
References Exception, file(), edm::errors::FormatIncompatibility, edm::getReleaseVersion(), and edm::releaseversion::isEarlierRelease().
Referenced by RootFile().
{
if(releaseversion::isEarlierRelease(currentRelease, it->releaseVersion())) {
throw Exception(errors::FormatIncompatibility)
<< "The release you are using, " << getReleaseVersion() << " , predates\n"
<< "a release (" << it->releaseVersion() << ") used in writing the input file, " << file() <<".\n"
<< "Forward compatibility cannot be supported.\n";
}
}
}
void
RootFile::initializeDuplicateChecker(
| EventPrincipal * edm::RootFile::clearAndReadCurrentEvent | ( | EventPrincipal & | cache, |
| boost::shared_ptr< LuminosityBlockPrincipal > | lb = boost::shared_ptr<LuminosityBlockPrincipal>() |
||
| ) |
Definition at line 1297 of file RootFile.cc.
{
| void edm::RootFile::close | ( | void | ) |
Definition at line 1018 of file RootFile.cc.
{
(*it)->close();
(*it) = 0;
}
filePtr_->Close();
filePtr_.reset();
}
void
RootFile::fillThisEventAuxiliary() {
| boost::shared_ptr< FileBlock > edm::RootFile::createFileBlock | ( | ) | const |
Definition at line 546 of file RootFile.cc.
{
| void edm::RootFile::dropOnInput | ( | ProductRegistry & | reg, |
| GroupSelectorRules const & | rules, | ||
| bool | dropDescendants, | ||
| InputType::InputType | inputType | ||
| ) | [private] |
Definition at line 1530 of file RootFile.cc.
References branchChildren_, edm::BranchDescription::branchID(), and parseEventContent::prod.
Referenced by RootFile().
{
BranchDescription const& prod = it->second;
if(!groupSelector.selected(prod)) {
if(dropDescendants) {
branchChildren_->appendToDescendants(prod.branchID(), branchesToDrop);
} else {
branchesToDrop.insert(prod.branchID());
}
}
}
// On this pass, actually drop the branches.
std::set<BranchID>::const_iterator branchesToDropEnd = branchesToDrop.end();
for(ProductRegistry::ProductList::iterator it = prodList.begin(), itEnd = prodList.end(); it != itEnd;) {
BranchDescription const& prod = it->second;
bool drop = branchesToDrop.find(prod.branchID()) != branchesToDropEnd;
if(drop) {
if(groupSelector.selected(prod)) {
LogWarning("RootFile")
<< "Branch '" << prod.branchName() << "' is being dropped from the input\n"
<< "of file '" << file_ << "' because it is dependent on a branch\n"
<< "that was explicitly dropped.\n";
}
treePointers_[prod.branchType()]->dropBranch(newBranchToOldBranch(prod.branchName()));
hasNewlyDroppedBranch_[prod.branchType()] = true;
ProductRegistry::ProductList::iterator icopy = it;
++it;
prodList.erase(icopy);
} else {
++it;
}
}
// Drop on input mergeable run and lumi products, this needs to be invoked for secondary file input
if(inputType == InputType::SecondaryFile) {
TString tString;
for(ProductRegistry::ProductList::iterator it = prodList.begin(), itEnd = prodList.end(); it != itEnd;) {
BranchDescription const& prod = it->second;
if(prod.branchType() != InEvent) {
TClass *cp = gROOT->GetClass(prod.wrappedName().c_str());
WrapperOwningHolder edp(cp->New(), prod.getInterface());
if(edp.isMergeable()) {
treePointers_[prod.branchType()]->dropBranch(newBranchToOldBranch(prod.branchName()));
ProductRegistry::ProductList::iterator icopy = it;
++it;
prodList.erase(icopy);
} else {
++it;
}
}
else ++it;
}
}
}
// backward compatibility
| EventAuxiliary const& edm::RootFile::eventAux | ( | ) | const [inline] |
Definition at line 86 of file RootFile.h.
References eventAux_.
Referenced by eventID(), fillHistory(), initializeDuplicateChecker(), readLuminosityBlockAuxiliary_(), and readRunAuxiliary_().
{return eventAux_;}
| EventID const& edm::RootFile::eventID | ( | ) | const [inline] |
Definition at line 90 of file RootFile.h.
References eventAux(), and edm::EventAuxiliary::id().
{return eventAux().id();}
| RootTree const& edm::RootFile::eventTree | ( | ) | const [inline] |
| std::string const& edm::RootFile::file | ( | ) | const [inline] |
Definition at line 83 of file RootFile.h.
References file_.
Referenced by checkReleaseVersion().
{return file_;}
| FileFormatVersion edm::RootFile::fileFormatVersion | ( | ) | const [inline] |
Definition at line 94 of file RootFile.h.
References fileFormatVersion_.
Referenced by edm::ReducedProvenanceBranchMapperWithReader::reset_(), RootFile(), and ~RootFile().
{return fileFormatVersion_;}
| void edm::RootFile::fillEventAuxiliary | ( | ) | [private] |
Definition at line 1049 of file RootFile.cc.
{
| void edm::RootFile::fillHistory | ( | ) | [private] |
Definition at line 1055 of file RootFile.cc.
References event(), eventAux(), eventAux_, eventProcessHistoryIDs_, eventProcessHistoryIter_, edm::lower_bound_all(), DTTTrigCorrFirst::run, edm::EventAuxiliary::setProcessHistoryID(), and filterCSVwithJSON::target.
{
// Lumi block number was not in EventID for the relevant releases.
EventID id(eventAux().id().run(), 0, eventAux().id().event());
if(eventProcessHistoryIter_->eventID() != id) {
EventProcessHistoryID target(id, ProcessHistoryID());
eventProcessHistoryIter_ = lower_bound_all(eventProcessHistoryIDs_, target);
assert(eventProcessHistoryIter_->eventID() == id);
}
eventAux_.setProcessHistoryID(eventProcessHistoryIter_->processHistoryID());
++eventProcessHistoryIter_;
} else if(fileFormatVersion().eventHistoryTree()) {
// for backward compatibility.
History* pHistory = history_.get();
TBranch* eventHistoryBranch = eventHistoryTree_->GetBranch(poolNames::eventHistoryBranchName().c_str());
if(!eventHistoryBranch) {
throw Exception(errors::EventCorruption)
<< "Failed to find history branch in event history tree.\n";
}
eventHistoryBranch->SetAddress(&pHistory);
roottree::getEntry(eventHistoryTree_, eventTree_.entryNumber());
eventAux_.setProcessHistoryID(history_->processHistoryID());
eventSelectionIDs_.reset(&history_->eventSelectionIDs(), do_nothing_deleter());
branchListIndexes_.reset(&history_->branchListIndexes(), do_nothing_deleter());
} else if(fileFormatVersion().noMetaDataTrees()) {
// Current format
EventSelectionIDVector* pESV = eventSelectionIDs_.get();
TBranch* eventSelectionIDBranch = eventTree_.tree()->GetBranch(poolNames::eventSelectionsBranchName().c_str());
assert(eventSelectionIDBranch != 0);
eventTree_.fillBranchEntry(eventSelectionIDBranch, pESV);
BranchListIndexes* pBLI = branchListIndexes_.get();
TBranch* branchListIndexesBranch = eventTree_.tree()->GetBranch(poolNames::branchListIndexesBranchName().c_str());
assert(branchListIndexesBranch != 0);
eventTree_.fillBranchEntry(branchListIndexesBranch, pBLI);
}
if(provenanceAdaptor_) {
eventAux_.setProcessHistoryID(provenanceAdaptor_->convertID(eventAux().processHistoryID()));
for(EventSelectionIDVector::iterator i = eventSelectionIDs_->begin(), e = eventSelectionIDs_->end(); i != e; ++i) {
(*i) = provenanceAdaptor_->convertID(*i);
}
}
if(!fileFormatVersion().splitProductIDs()) {
// old format. branchListIndexes_ must be filled in from the ProvenanceAdaptor.
provenanceAdaptor_->branchListIndexes(*branchListIndexes_);
}
}
boost::shared_ptr<LuminosityBlockAuxiliary>
RootFile::fillLumiAuxiliary() {
| void edm::RootFile::fillIndexIntoFile | ( | ) | [private] |
Definition at line 747 of file RootFile.cc.
{
bool newRun = false;
bool newLumi = false;
fillThisEventAuxiliary();
fillHistory();
// Save the event numbers as we loop through the event auxiliary to avoid
// having to read through the event auxiliary again later. These event numbers
// are not actually used in this function, but could be needed elsewhere.
indexIntoFile_.unsortedEventNumbers().push_back(eventAux().event());
if(prevPhid != eventAux().processHistoryID() || prevRun != eventAux().run()) {
newRun = newLumi = true;
} else if(prevLumi != eventAux().luminosityBlock()) {
newLumi = true;
}
prevPhid = eventAux().processHistoryID();
prevRun = eventAux().run();
prevLumi = eventAux().luminosityBlock();
if(newLumi) {
lumis.push_back(LumiItem(eventAux().processHistoryID(),
eventAux().run(), eventAux().luminosityBlock(), eventTree_.entryNumber())); // (insert 1)
runLumiSet.insert(LuminosityBlockID(eventAux().run(), eventAux().luminosityBlock())); // (insert 2)
} else {
LumiItem& currentLumi = lumis.back();
assert(currentLumi.lastEventEntry_ == eventTree_.entryNumber());
++currentLumi.lastEventEntry_;
}
if(newRun) {
// Insert run in list if it is not already there.
RunItem item(eventAux().processHistoryID(), eventAux().run());
if(runItemSet.insert(item).second) { // (check 3, insert 3)
runs.push_back(item); // (insert 5)
runSet.insert(eventAux().run()); // (insert 4)
phidMap.insert(std::make_pair(eventAux().run(), eventAux().processHistoryID()));
}
}
}
// now clean up.
eventTree_.setEntryNumber(-1);
eventAux_ = EventAuxiliary();
lastEventEntryNumberRead_ = -1LL;
// Loop over run entries and fill information.
typedef std::map<RunNumber_t, EntryNumber_t> RunMap;
RunMap runMap; // (declare 11)
typedef std::vector<RunItem> RunVector;
RunVector emptyRuns; // (declare 12)
if(runTree_.isValid()) {
while(runTree_.next()) {
// Note: adjacent duplicates will be skipped without an explicit check.
boost::shared_ptr<RunAuxiliary> runAux = fillRunAuxiliary();
if(runSet.insert(runAux->run()).second) { // (check 4, insert 4)
// This run was not assciated with any events or lumis.
emptyRuns.push_back(RunItem(runAux->processHistoryID(), runAux->run())); // (insert 12)
}
runMap.insert(std::make_pair(runAux->run(), runTree_.entryNumber())); // (insert 11)
phidMap.insert(std::make_pair(runAux->run(), runAux->processHistoryID()));
}
// now clean up.
runTree_.setEntryNumber(-1);
}
// Insert the ordered empty runs into the run list.
RunItemSortByRun runItemSortByRun;
stable_sort_all(emptyRuns, runItemSortByRun);
RunList::iterator itRuns = runs.begin(), endRuns = runs.end();
for(RunVector::const_iterator i = emptyRuns.begin(), iEnd = emptyRuns.end(); i != iEnd; ++i) {
for(; itRuns != endRuns; ++itRuns) {
if(runItemSortByRun(*i, *itRuns)) {
break;
}
}
runs.insert(itRuns, *i);
}
// Loop over luminosity block entries and fill information.
typedef std::vector<LumiItem> LumiVector;
LumiVector emptyLumis; // (declare 7)
typedef std::map<LuminosityBlockID, EntryNumber_t> RunLumiMap;
RunLumiMap runLumiMap; // (declare 6)
if(lumiTree_.isValid()) {
while(lumiTree_.next()) {
// Note: adjacent duplicates will be skipped without an explicit check.
boost::shared_ptr<LuminosityBlockAuxiliary> lumiAux = fillLumiAuxiliary();
LuminosityBlockID lumiID = LuminosityBlockID(lumiAux->run(), lumiAux->luminosityBlock());
if(runLumiSet.insert(lumiID).second) { // (check 2, insert 2)
// This lumi was not associated with any events.
// Use the process history ID from the corresponding run. In cases of practical
// importance, this should be the correct process history ID, but it is possible
// to construct files where this is not the correct process history ID ...
PHIDMap::const_iterator iPhidMap = phidMap.find(lumiAux->run());
assert(iPhidMap != phidMap.end());
emptyLumis.push_back(LumiItem(iPhidMap->second, lumiAux->run(), lumiAux->luminosityBlock(), -1LL)); // (insert 7)
}
runLumiMap.insert(std::make_pair(lumiID, lumiTree_.entryNumber()));
}
// now clean up.
lumiTree_.setEntryNumber(-1);
}
// Insert the ordered empty lumis into the lumi list.
LumiItemSortByRunLumi lumiItemSortByRunLumi;
stable_sort_all(emptyLumis, lumiItemSortByRunLumi);
LumiList::iterator itLumis = lumis.begin(), endLumis = lumis.end();
for(LumiVector::const_iterator i = emptyLumis.begin(), iEnd = emptyLumis.end(); i != iEnd; ++i) {
for(; itLumis != endLumis; ++itLumis) {
if(lumiItemSortByRunLumi(*i, *itLumis)) {
break;
}
}
lumis.insert(itLumis, *i);
}
// Create a map of RunItems that gives the order of first appearance in the list.
// Also fill in the vector of process history IDs
typedef std::map<RunItem, int, RunItemSortByRunPhid> RunCountMap;
RunCountMap runCountMap; // Declare (17)
std::vector<ProcessHistoryID>& phids = indexIntoFile_.setProcessHistoryIDs();
assert(phids.empty());
std::vector<IndexIntoFile::RunOrLumiEntry>& entries = indexIntoFile_.setRunOrLumiEntries();
assert(entries.empty());
int rcount = 0;
for(RunList::iterator it = runs.begin(), itEnd = runs.end(); it != itEnd; ++it) {
RunCountMap::const_iterator countMapItem = runCountMap.find(*it);
if(countMapItem == runCountMap.end()) {
countMapItem = runCountMap.insert(std::make_pair(*it, rcount)).first; // Insert (17)
assert(countMapItem != runCountMap.end());
++rcount;
}
std::vector<ProcessHistoryID>::const_iterator phidItem = find_in_all(phids, it->phid_);
if(phidItem == phids.end()) {
phids.push_back(it->phid_);
phidItem = phids.end() - 1;
}
entries.push_back(IndexIntoFile::RunOrLumiEntry(
countMapItem->second, // use (17)
-1LL,
runMap[it->run_], // use (11)
phidItem - phids.begin(),
it->run_,
0U,
-1LL,
-1LL));
}
// Create a map of LumiItems that gives the order of first appearance in the list.
typedef std::map<LumiItem, int, LumiItemSortByRunLumiPhid> LumiCountMap;
LumiCountMap lumiCountMap; // Declare (19)
int lcount = 0;
for(LumiList::iterator it = lumis.begin(), itEnd = lumis.end(); it != itEnd; ++it) {
RunCountMap::const_iterator runCountMapItem = runCountMap.find(RunItem(it->phid_, it->run_));
assert(runCountMapItem != runCountMap.end());
LumiCountMap::const_iterator countMapItem = lumiCountMap.find(*it);
if(countMapItem == lumiCountMap.end()) {
countMapItem = lumiCountMap.insert(std::make_pair(*it, lcount)).first; // Insert (17)
assert(countMapItem != lumiCountMap.end());
++lcount;
}
std::vector<ProcessHistoryID>::const_iterator phidItem = find_in_all(phids, it->phid_);
assert(phidItem != phids.end());
entries.push_back(IndexIntoFile::RunOrLumiEntry(
runCountMapItem->second,
countMapItem->second,
runLumiMap[LuminosityBlockID(it->run_, it->lumi_)],
phidItem - phids.begin(),
it->run_,
it->lumi_,
it->firstEventEntry_,
it->lastEventEntry_));
}
stable_sort_all(entries);
}
void
RootFile::validateFile(InputType::InputType inputType, bool usingGoToEvent) {
| boost::shared_ptr< LuminosityBlockAuxiliary > edm::RootFile::fillLumiAuxiliary | ( | ) | [private] |
Definition at line 1107 of file RootFile.cc.
{
LuminosityBlockAux lumiAux;
LuminosityBlockAux *pLumiAux = &lumiAux;
lumiTree_.fillAux<LuminosityBlockAux>(pLumiAux);
conversion(lumiAux, *lumiAuxiliary);
}
if(provenanceAdaptor_) {
lumiAuxiliary->setProcessHistoryID(provenanceAdaptor_->convertID(lumiAuxiliary->processHistoryID()));
}
if(lumiAuxiliary->luminosityBlock() == 0 && !fileFormatVersion().runsAndLumis()) {
lumiAuxiliary->id() = LuminosityBlockID(RunNumber_t(1), LuminosityBlockNumber_t(1));
}
return lumiAuxiliary;
}
boost::shared_ptr<RunAuxiliary>
RootFile::fillRunAuxiliary() {
| boost::shared_ptr< RunAuxiliary > edm::RootFile::fillRunAuxiliary | ( | ) | [private] |
Definition at line 1128 of file RootFile.cc.
{
RunAux runAux;
RunAux *pRunAux = &runAux;
runTree_.fillAux<RunAux>(pRunAux);
conversion(runAux, *runAuxiliary);
}
if(provenanceAdaptor_) {
runAuxiliary->setProcessHistoryID(provenanceAdaptor_->convertID(runAuxiliary->processHistoryID()));
}
return runAuxiliary;
}
bool
RootFile::skipEvents(int& offset) {
| void edm::RootFile::fillThisEventAuxiliary | ( | ) | [private] |
Definition at line 1030 of file RootFile.cc.
Referenced by initializeDuplicateChecker(), readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), and skipEvents().
{
EventAuxiliary *pEvAux = &eventAux_;
eventTree_.fillAux<EventAuxiliary>(pEvAux);
} else {
// for backward compatibility.
EventAux eventAux;
EventAux *pEvAux = &eventAux;
eventTree_.fillAux<EventAux>(pEvAux);
conversion(eventAux, eventAux_);
}
lastEventEntryNumberRead_ = eventTree_.entryNumber();
}
void
RootFile::fillEventAuxiliary() {
| IndexIntoFile::EntryType edm::RootFile::getEntryTypeWithSkipping | ( | ) | [private] |
Definition at line 625 of file RootFile.cc.
{
indexIntoFileIter_.advanceToNextLumiOrRun();
}
else {
++indexIntoFileIter_;
}
}
return indexIntoFileIter_.getEntryType();
}
bool
RootFile::isDuplicateEvent() {
| IndexIntoFile::EntryType edm::RootFile::getNextEntryTypeWanted | ( | ) |
Definition at line 652 of file RootFile.cc.
{
return IndexIntoFile::kRun;
} else if(processingMode_ == InputSource::Runs) {
indexIntoFileIter_.advanceToNextRun();
return getNextEntryTypeWanted();
}
if(entryType == IndexIntoFile::kLumi) {
return IndexIntoFile::kLumi;
} else if(processingMode_ == InputSource::RunsAndLumis) {
indexIntoFileIter_.advanceToNextLumiOrRun();
return getNextEntryTypeWanted();
}
if(isDuplicateEvent()) {
++indexIntoFileIter_;
return getNextEntryTypeWanted();
}
return IndexIntoFile::kEvent;
}
bool
RootFile::wasLastEventJustRead() const {
| bool edm::RootFile::goToEvent | ( | EventID const & | eventID | ) |
Definition at line 1217 of file RootFile.cc.
References duplicateChecker_.
{
duplicateChecker_->disable();
}
IndexIntoFile::SortOrder sortOrder = IndexIntoFile::numericalOrder;
if(noEventSort_) sortOrder = IndexIntoFile::firstAppearanceOrder;
IndexIntoFile::IndexIntoFileItr iter =
indexIntoFile_.findPosition(sortOrder, eventID.run(), eventID.luminosityBlock(), eventID.event());
if(iter == indexIntoFile_.end(sortOrder)) {
return false;
}
indexIntoFileIter_ = iter;
return true;
}
// readEvent() is responsible for creating, and setting up, the
// EventPrincipal.
| boost::array<bool, NumBranchTypes> const& edm::RootFile::hasNewlyDroppedBranch | ( | ) | const [inline] |
Definition at line 96 of file RootFile.h.
References hasNewlyDroppedBranch_.
{return hasNewlyDroppedBranch_;}
| IndexIntoFile::IndexIntoFileItr edm::RootFile::indexIntoFileIter | ( | ) | const |
Definition at line 571 of file RootFile.cc.
References edm::IndexIntoFile::IndexIntoFileItr::copyPosition(), and indexIntoFileIter_.
{
| boost::shared_ptr<IndexIntoFile> edm::RootFile::indexIntoFileSharedPtr | ( | ) | const [inline] |
Definition at line 121 of file RootFile.h.
References indexIntoFileSharedPtr_.
{
return indexIntoFileSharedPtr_;
}
| void edm::RootFile::initializeDuplicateChecker | ( | std::vector< boost::shared_ptr< IndexIntoFile > > const & | indexesIntoFiles, |
| std::vector< boost::shared_ptr< IndexIntoFile > >::size_type | currentIndexIntoFile | ||
| ) | [private] |
Definition at line 1514 of file RootFile.cc.
References duplicateChecker_, eventAux(), eventTree_, fillThisEventAuxiliary(), indexIntoFile_, edm::RootTree::next(), and edm::RootTree::setEntryNumber().
Referenced by RootFile().
{
if(eventTree_.next()) {
fillThisEventAuxiliary();
duplicateChecker_->inputFileOpened(eventAux().isRealData(),
indexIntoFile_,
indexesIntoFiles,
currentIndexIntoFile);
}
eventTree_.setEntryNumber(-1);
}
}
void
RootFile::dropOnInput (ProductRegistry& reg, GroupSelectorRules const& rules, bool dropDescendants, InputType::InputType inputType) {
| bool edm::RootFile::isDuplicateEvent | ( | ) | [private] |
Definition at line 641 of file RootFile.cc.
{
| RootTree const& edm::RootFile::lumiTree | ( | ) | const [inline] |
| boost::shared_ptr< BranchMapper > edm::RootFile::makeBranchMapper | ( | RootTree & | rootTree, |
| BranchType const & | type | ||
| ) | const [private] |
Definition at line 1729 of file RootFile.cc.
References eventBranchMapper_, and parentageIDLookup_.
{
eventBranchMapper_ = boost::shared_ptr<BranchMapper>(new ReducedProvenanceBranchMapperWithReader(&rootTree, parentageIDLookup_));
}
eventBranchMapper_->reset();
return eventBranchMapper_;
}
return boost::shared_ptr<BranchMapper>(new ReducedProvenanceBranchMapperWithReader(&rootTree, parentageIDLookup_)); } else if(fileFormatVersion().splitProductIDs()) {
if(type == InEvent) {
if(!eventBranchMapper_) {
eventBranchMapper_ = makeBranchMapperInRelease300(rootTree);
}
eventBranchMapper_->reset();
return eventBranchMapper_;
}
return makeBranchMapperInRelease300(rootTree);
} else if(fileFormatVersion().perEventProductIDs()) {
eventBranchMapper_.reset();
return makeBranchMapperInRelease210(rootTree, type);
} else if(fileFormatVersion().eventHistoryTree()) {
eventBranchMapper_.reset();
return makeBranchMapperInRelease200(rootTree, type, *productRegistry_);
} else {
eventBranchMapper_.reset();
return makeBranchMapperInRelease180(rootTree, type, *productRegistry_);
}
}
// end backward compatibility
}
| std::string const & edm::RootFile::newBranchToOldBranch | ( | std::string const & | newBranch | ) | const [private] |
| bool edm::RootFile::nextEventEntry | ( | ) | [inline] |
Definition at line 119 of file RootFile.h.
References eventTree_, and edm::RootTree::next().
{return eventTree_.next();}
| void edm::RootFile::overrideRunNumber | ( | LuminosityBlockID & | id | ) | [private] |
Definition at line 1463 of file RootFile.cc.
{
| void edm::RootFile::overrideRunNumber | ( | RunID & | id | ) | [private] |
Definition at line 1455 of file RootFile.cc.
Referenced by readLuminosityBlockAuxiliary_(), and readRunAuxiliary_().
{
| void edm::RootFile::overrideRunNumber | ( | EventID & | id, |
| bool | isRealData | ||
| ) | [private] |
Definition at line 1471 of file RootFile.cc.
{
id = EventID(RunID::firstValidRun().run(), LuminosityBlockID::firstValidLuminosityBlock().luminosityBlock(), id.event());
}
}
void
| boost::shared_ptr<ProductRegistry const> edm::RootFile::productRegistry | ( | ) | const [inline] |
Definition at line 84 of file RootFile.h.
References productRegistry_.
Referenced by RootFile().
{return productRegistry_;}
| EventPrincipal * edm::RootFile::readCurrentEvent | ( | EventPrincipal & | cache, |
| boost::shared_ptr< LuminosityBlockPrincipal > | lb = boost::shared_ptr<LuminosityBlockPrincipal>() |
||
| ) |
Definition at line 1269 of file RootFile.cc.
{
//ugly, but will disappear when the backward compatibility is done with schema evolution.
const_cast<EventID&>(eventAux_.id()).setLuminosityBlockNumber(eventAux_.oldLuminosityBlock());
eventAux_.resetObsoleteInfo();
}
fillHistory();
overrideRunNumber(eventAux_.id(), eventAux().isRealData());
// We're not done ... so prepare the EventPrincipal
cache.fillEventPrincipal(eventAux(),
lb,
eventSelectionIDs_,
branchListIndexes_,
makeBranchMapper(eventTree_, InEvent),
eventTree_.rootDelayedReader());
// report event read from file
filePtr_->eventReadFromFile(eventID().run(), eventID().event());
return &cache;
}
EventPrincipal*
RootFile::clearAndReadCurrentEvent(EventPrincipal& cache,
| void edm::RootFile::readEntryDescriptionTree | ( | ) | [private] |
Definition at line 424 of file RootFile.cc.
References edm::poolNames::entryDescriptionTreeName(), Exception, and edm::errors::FileReadError.
{
throw Exception(errors::FileReadError) << "Could not find tree " << poolNames::entryDescriptionTreeName()
<< " in the input file.\n";
}
EntryDescriptionID idBuffer;
EntryDescriptionID* pidBuffer = &idBuffer;
entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionIDBranchName().c_str(), &pidBuffer);
EntryDescriptionRegistry& oldregistry = *EntryDescriptionRegistry::instance();
EventEntryDescription entryDescriptionBuffer;
EventEntryDescription *pEntryDescriptionBuffer = &entryDescriptionBuffer;
entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionBranchName().c_str(), &pEntryDescriptionBuffer);
// Fill in the parentage registry.
ParentageRegistry& registry = *ParentageRegistry::instance();
for(Long64_t i = 0, numEntries = entryDescriptionTree->GetEntries(); i < numEntries; ++i) {
roottree::getEntry(entryDescriptionTree.get(), i);
if(idBuffer != entryDescriptionBuffer.id()) {
throw Exception(errors::EventCorruption) << "Corruption of EntryDescription tree detected.\n";
}
oldregistry.insertMapped(entryDescriptionBuffer);
Parentage parents;
parents.parents() = entryDescriptionBuffer.parents();
registry.insertMapped(parents);
}
entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionIDBranchName().c_str(), 0);
entryDescriptionTree->SetBranchAddress(poolNames::entryDescriptionBranchName().c_str(), 0);
}
void
RootFile::readParentageTree() {
| EventPrincipal * edm::RootFile::readEvent | ( | EventPrincipal & | cache, |
| boost::shared_ptr< LuminosityBlockPrincipal > | lb = boost::shared_ptr<LuminosityBlockPrincipal>() |
||
| ) |
Definition at line 1252 of file RootFile.cc.
| void edm::RootFile::readEventHistoryTree | ( | ) | [private] |
Definition at line 1486 of file RootFile.cc.
References edm::errors::EventCorruption, and Exception.
Referenced by RootFile().
{
throw Exception(errors::EventCorruption)
<< "Failed to find the event history tree.\n";
}
}
}
void
RootFile::checkReleaseVersion() {
| boost::shared_ptr< LuminosityBlockPrincipal > edm::RootFile::readLumi | ( | boost::shared_ptr< LuminosityBlockPrincipal > | lbCache | ) |
Definition at line 1412 of file RootFile.cc.
References indexIntoFileIter_.
{
++indexIntoFileIter_;
return lbCache;
}
// End code for backward compatibility before the existence of lumi trees.
lumiTree_.setEntryNumber(indexIntoFileIter_.entry());
lbCache->fillLuminosityBlockPrincipal(makeBranchMapper(lumiTree_, InLumi),
lumiTree_.rootDelayedReader());
// Read in all the products now.
lbCache->readImmediate();
++indexIntoFileIter_;
return lbCache;
}
bool
RootFile::setEntryAtEvent(RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) {
| boost::shared_ptr< LuminosityBlockAuxiliary > edm::RootFile::readLuminosityBlockAuxiliary_ | ( | ) |
Definition at line 1368 of file RootFile.cc.
References eventAux(), eventTree_, fillThisEventAuxiliary(), indexIntoFileIter_, edm::Timestamp::invalidTimestamp(), edm::IndexIntoFile::IndexIntoFileItr::lumi(), edm::LuminosityBlockID::luminosityBlock(), edm::RootTree::next(), overrideRunNumber(), edm::RootTree::previous(), edm::LuminosityBlockID::run(), edm::IndexIntoFile::IndexIntoFileItr::run(), and edm::EventAuxiliary::time().
{
if(eventTree_.next()) {
fillThisEventAuxiliary();
// back up, so event will not be skipped.
eventTree_.previous();
}
LuminosityBlockID lumi = LuminosityBlockID(indexIntoFileIter_.run(), indexIntoFileIter_.lumi());
overrideRunNumber(lumi);
return boost::shared_ptr<LuminosityBlockAuxiliary>(new LuminosityBlockAuxiliary(lumi.run(), lumi.luminosityBlock(), eventAux().time(), Timestamp::invalidTimestamp()));
}
// End code for backward compatibility before the existence of lumi trees.
lumiTree_.setEntryNumber(indexIntoFileIter_.entry());
boost::shared_ptr<LuminosityBlockAuxiliary> lumiAuxiliary = fillLumiAuxiliary();
assert(lumiAuxiliary->run() == indexIntoFileIter_.run());
assert(lumiAuxiliary->luminosityBlock() == indexIntoFileIter_.lumi());
overrideRunNumber(lumiAuxiliary->id());
filePtr_->reportInputLumiSection(lumiAuxiliary->run(), lumiAuxiliary->luminosityBlock());
if(lumiAuxiliary->beginTime() == Timestamp::invalidTimestamp()) {
// LuminosityBlockAuxiliary did not contain a timestamp. Take it from the next event.
if(eventTree_.next()) {
fillThisEventAuxiliary();
// back up, so event will not be skipped.
eventTree_.previous();
}
lumiAuxiliary->setBeginTime(eventAux().time());
lumiAuxiliary->setEndTime(Timestamp::invalidTimestamp());
}
if(fileFormatVersion().processHistorySameWithinRun()) {
ProcessHistoryID phid = indexIntoFile_.processHistoryID(indexIntoFileIter_.processHistoryIDIndex());
assert(lumiAuxiliary->processHistoryID() == phid);
} else {
ProcessHistoryID phid = indexIntoFile_.processHistoryID(indexIntoFileIter_.processHistoryIDIndex());
lumiAuxiliary->setProcessHistoryID(phid);
}
return lumiAuxiliary;
}
boost::shared_ptr<LuminosityBlockPrincipal>
RootFile::readLumi(boost::shared_ptr<LuminosityBlockPrincipal> lbCache) {
| void edm::RootFile::readParentageTree | ( | ) | [private] |
Definition at line 462 of file RootFile.cc.
Referenced by RootFile().
{
throw Exception(errors::FileReadError) << "Could not find tree " << poolNames::parentageTreeName()
<< " in the input file.\n";
}
Parentage parentageBuffer;
Parentage *pParentageBuffer = &parentageBuffer;
parentageTree->SetBranchAddress(poolNames::parentageBranchName().c_str(), &pParentageBuffer);
ParentageRegistry& registry = *ParentageRegistry::instance();
parentageIDLookup_.reserve(parentageTree->GetEntries());
for(Long64_t i = 0, numEntries = parentageTree->GetEntries(); i < numEntries; ++i) {
roottree::getEntry(parentageTree.get(), i);
registry.insertMapped(parentageBuffer);
parentageIDLookup_.push_back(parentageBuffer.id());
}
parentageTree->SetBranchAddress(poolNames::parentageBranchName().c_str(), 0);
}
void
RootFile::setIfFastClonable(int remainingEvents, int remainingLumis) {
| boost::shared_ptr< RunPrincipal > edm::RootFile::readRun_ | ( | boost::shared_ptr< RunPrincipal > | rpCache | ) |
Definition at line 1351 of file RootFile.cc.
References indexIntoFileIter_.
{
++indexIntoFileIter_;
return rpCache;
}
// End code for backward compatibility before the existence of run trees.
rpCache->fillRunPrincipal(makeBranchMapper(runTree_, InRun), runTree_.rootDelayedReader());
// Read in all the products now.
rpCache->readImmediate();
++indexIntoFileIter_;
return rpCache;
}
boost::shared_ptr<LuminosityBlockAuxiliary>
RootFile::readLuminosityBlockAuxiliary_() {
| boost::shared_ptr< RunAuxiliary > edm::RootFile::readRunAuxiliary_ | ( | ) |
Definition at line 1309 of file RootFile.cc.
References eventAux(), eventTree_, fillThisEventAuxiliary(), indexIntoFileIter_, edm::Timestamp::invalidTimestamp(), edm::RootTree::next(), overrideRunNumber(), edm::RootTree::previous(), edm::IndexIntoFile::IndexIntoFileItr::run(), edm::RunID::run(), and edm::EventAuxiliary::time().
{
// prior to the support of run trees.
// RunAuxiliary did not contain a valid timestamp. Take it from the next event.
if(eventTree_.next()) {
fillThisEventAuxiliary();
// back up, so event will not be skipped.
eventTree_.previous();
}
RunID run = RunID(indexIntoFileIter_.run());
overrideRunNumber(run);
return boost::shared_ptr<RunAuxiliary>(new RunAuxiliary(run.run(), eventAux().time(), Timestamp::invalidTimestamp()));
}
// End code for backward compatibility before the existence of run trees.
runTree_.setEntryNumber(indexIntoFileIter_.entry());
boost::shared_ptr<RunAuxiliary> runAuxiliary = fillRunAuxiliary();
assert(runAuxiliary->run() == indexIntoFileIter_.run());
overrideRunNumber(runAuxiliary->id());
filePtr_->reportInputRunNumber(runAuxiliary->run());
if(runAuxiliary->beginTime() == Timestamp::invalidTimestamp()) {
// RunAuxiliary did not contain a valid timestamp. Take it from the next event.
if(eventTree_.next()) {
fillThisEventAuxiliary();
// back up, so event will not be skipped.
eventTree_.previous();
}
runAuxiliary->setBeginTime(eventAux().time());
runAuxiliary->setEndTime(Timestamp::invalidTimestamp());
}
ProcessHistoryID phid = indexIntoFile_.processHistoryID(indexIntoFileIter_.processHistoryIDIndex());
if(fileFormatVersion().processHistorySameWithinRun()) {
assert(runAuxiliary->processHistoryID() == phid);
} else {
runAuxiliary->setProcessHistoryID(phid);
}
return runAuxiliary;
}
boost::shared_ptr<RunPrincipal>
RootFile::readRun_(boost::shared_ptr<RunPrincipal> rpCache) {
| void edm::RootFile::reportOpened | ( | std::string const & | inputType | ) |
Definition at line 1004 of file RootFile.cc.
{
| void edm::RootFile::rewind | ( | ) | [inline] |
Definition at line 107 of file RootFile.h.
References eventTree_, indexIntoFileBegin_, indexIntoFileIter_, lumiTree_, edm::RootTree::rewind(), and runTree_.
{
indexIntoFileIter_ = indexIntoFileBegin_;
eventTree_.rewind();
lumiTree_.rewind();
runTree_.rewind();
}
| RootTree const& edm::RootFile::runTree | ( | ) | const [inline] |
| EventPrincipal& edm::RootFile::secondaryEventPrincipal | ( | ) | [inline] |
Definition at line 128 of file RootFile.h.
References secondaryEventPrincipal_.
{
return *secondaryEventPrincipal_;
}
| void edm::RootFile::setAtEventEntry | ( | IndexIntoFile::EntryNumber_t | entry | ) |
Definition at line 1304 of file RootFile.cc.
References edm::IndexIntoFile::IndexIntoFileItr::getEntryType(), indexIntoFileEnd_, indexIntoFileIter_, and edm::IndexIntoFile::kRun.
{
| bool edm::RootFile::setEntryAtEvent | ( | RunNumber_t | run, |
| LuminosityBlockNumber_t | lumi, | ||
| EventNumber_t | event | ||
| ) |
| bool edm::RootFile::setEntryAtItem | ( | RunNumber_t | run, |
| LuminosityBlockNumber_t | lumi, | ||
| EventNumber_t | event | ||
| ) | [inline] |
Definition at line 99 of file RootFile.h.
References setEntryAtEvent(), setEntryAtLumi(), and setEntryAtRun().
{
return event ? setEntryAtEvent(run, lumi, event) : (lumi ? setEntryAtLumi(run, lumi) : setEntryAtRun(run));
}
| bool edm::RootFile::setEntryAtLumi | ( | RunNumber_t | run, |
| LuminosityBlockNumber_t | lumi | ||
| ) |
| bool edm::RootFile::setEntryAtRun | ( | RunNumber_t | run | ) |
| void edm::RootFile::setIfFastClonable | ( | int | remainingEvents, |
| int | remainingLumis | ||
| ) | [private] |
Definition at line 492 of file RootFile.cc.
Referenced by RootFile().
{
whyNotFastClonable_ += FileBlock::FileTooOld;
return;
}
if(processingMode_ != InputSource::RunsLumisAndEvents) {
whyNotFastClonable_ += FileBlock::NotProcessingEvents;
return;
}
// Find entry for first event in file
IndexIntoFile::IndexIntoFileItr it = indexIntoFileBegin_;
while(it != indexIntoFileEnd_ && it.getEntryType() != IndexIntoFile::kEvent) {
++it;
}
if(it == indexIntoFileEnd_) {
whyNotFastClonable_ += FileBlock::NoEventsInFile;
return;
}
// From here on, record all reasons we can't fast clone.
IndexIntoFile::SortOrder sortOrder = (noEventSort_ ? IndexIntoFile::firstAppearanceOrder : IndexIntoFile::numericalOrder);
if(!indexIntoFile_.iterationWillBeInEntryOrder(sortOrder)) {
whyNotFastClonable_ += (noEventSort_ ? FileBlock::RunOrLumiNotContiguous : FileBlock::EventsToBeSorted);
}
if(skipAnyEvents_) {
whyNotFastClonable_ += FileBlock::InitialEventsSkipped;
}
if(remainingEvents >= 0 && eventTree_.entries() > remainingEvents) {
whyNotFastClonable_ += FileBlock::MaxEventsTooSmall;
}
if(remainingLumis >= 0 && lumiTree_.entries() > remainingLumis) {
whyNotFastClonable_ += FileBlock::MaxLumisTooSmall;
}
// We no longer fast copy the EventAuxiliary branch, so there
// is no longer any need to disable fast copying because the run
// number is being modified. Also, this check did not work anyway
// because this function is called before forcedRunOffset_ is set.
// if(forcedRunOffset_ != 0) {
// whyNotFastClonable_ += FileBlock::RunNumberModified;
// }
if(duplicateChecker_ &&
!duplicateChecker_->checkDisabled() &&
!duplicateChecker_->noDuplicatesInFile()) {
whyNotFastClonable_ += FileBlock::DuplicateEventsRemoved;
}
}
boost::shared_ptr<FileBlock>
RootFile::createFileBlock() const {
| void edm::RootFile::setPosition | ( | IndexIntoFile::IndexIntoFileItr const & | position | ) |
| void edm::RootFile::setToLastEntry | ( | ) | [inline] |
Definition at line 113 of file RootFile.h.
References indexIntoFileEnd_, and indexIntoFileIter_.
| bool edm::RootFile::skipEvents | ( | int & | offset | ) |
Definition at line 1146 of file RootFile.cc.
References edm::EventID::event(), eventAux_, eventSkipperByID_, eventTree_, fillThisEventAuxiliary(), edm::EventAuxiliary::id(), and edm::RootTree::setEntryNumber().
{
eventTree_.setEntryNumber(skippedEventEntry);
fillThisEventAuxiliary();
if(eventSkipperByID_->skipIt(runOfSkippedEvent, lumiOfSkippedEvent, eventAux_.id().event())) {
continue;
}
}
if(duplicateChecker_ &&
!duplicateChecker_->checkDisabled() &&
!duplicateChecker_->noDuplicatesInFile()) {
eventTree_.setEntryNumber(skippedEventEntry);
fillThisEventAuxiliary();
if(duplicateChecker_->isDuplicateAndCheckActive(phIndexOfSkippedEvent,
runOfSkippedEvent,
lumiOfSkippedEvent,
eventAux_.id().event(),
file_)) {
continue;
}
}
--offset;
}
while(offset < 0) {
if(duplicateChecker_) {
duplicateChecker_->disable();
}
int phIndexOfEvent = IndexIntoFile::invalidIndex;
RunNumber_t runOfEvent = IndexIntoFile::invalidRun;
LuminosityBlockNumber_t lumiOfEvent = IndexIntoFile::invalidLumi;
EntryNumber_t eventEntry = IndexIntoFile::invalidEntry;
indexIntoFileIter_.skipEventBackward(phIndexOfEvent,
runOfEvent,
lumiOfEvent,
eventEntry);
if(eventEntry == IndexIntoFile::invalidEntry) break;
if(eventSkipperByID_ && eventSkipperByID_->somethingToSkip()) {
eventTree_.setEntryNumber(eventEntry);
fillEventAuxiliary();
if(eventSkipperByID_->skipIt(runOfEvent, lumiOfEvent, eventAux_.id().event())) {
continue;
}
}
++offset;
}
return(indexIntoFileIter_ == indexIntoFileEnd_);
}
bool
RootFile::goToEvent(EventID const& eventID) {
| bool edm::RootFile::skipThisEntry | ( | ) | [private] |
Definition at line 581 of file RootFile.cc.
{
// See first if the entire lumi or run is skipped, so we won't have to read the event Auxiliary in that case.
if(eventSkipperByID_->skipIt(indexIntoFileIter_.run(), indexIntoFileIter_.lumi(), 0U)) {
return true;
}
// The Lumi is not skipped. If this is an event, see if the event is skipped.
if(indexIntoFileIter_.getEntryType() == IndexIntoFile::kEvent) {
fillEventAuxiliary();
if(eventSkipperByID_->skipIt(indexIntoFileIter_.run(),
indexIntoFileIter_.lumi(),
eventAux_.id().event())) {
return true;
}
}
// Skip runs with no lumis if either lumisToSkip or lumisToProcess have been set to select lumis
if(indexIntoFileIter_.getEntryType() == IndexIntoFile::kRun &&
eventSkipperByID_->skippingLumis()) {
IndexIntoFile::IndexIntoFileItr iterLumi = indexIntoFileIter_;
// There are no lumis in this run, not even ones we will skip
if(iterLumi.peekAheadAtLumi() == IndexIntoFile::invalidLumi) {
return true;
}
// If we get here there are lumis in the run, check to see if we are skipping all of them
do {
if(!eventSkipperByID_->skipIt(iterLumi.run(), iterLumi.peekAheadAtLumi(), 0U)) {
return false;
}
}
while(iterLumi.skipLumiInRun());
return true;
}
}
return false;
}
IndexIntoFile::EntryType
RootFile::getEntryTypeWithSkipping() {
| RootTreePtrArray& edm::RootFile::treePointers | ( | ) | [inline, private] |
| void edm::RootFile::validateFile | ( | InputType::InputType | inputType, |
| bool | usingGoToEvent | ||
| ) | [private] |
Definition at line 966 of file RootFile.cc.
Referenced by RootFile().
{
throw Exception(errors::EventCorruption) <<
"'Events' tree is corrupted or not present\n" << "in the input file.\n";
}
if(fileFormatVersion().hasIndexIntoFile()) {
if(runTree().entries() > 0) {
assert(!indexIntoFile_.empty());
}
}
else {
assert(indexIntoFile_.empty());
fillIndexIntoFile();
}
indexIntoFile_.fixIndexes(orderedProcessHistoryIDs_);
indexIntoFile_.setNumberOfEvents(eventTree_.entries());
indexIntoFile_.setEventFinder(boost::shared_ptr<IndexIntoFile::EventFinder>(new RootFileEventFinder(eventTree_)));
// We fill the event numbers explicitly if we need to find events in closed files,
// such as for secondary files (or secondary sources) or if duplicate checking across files.
bool needEventNumbers = false;
bool needIndexesForDuplicateChecker = duplicateChecker_ && duplicateChecker_->checkingAllFiles() && !duplicateChecker_->checkDisabled();
if(inputType != InputType::Primary || needIndexesForDuplicateChecker || usingGoToEvent) {
needEventNumbers = true;
}
bool needEventEntries = false;
if(inputType != InputType::Primary || !noEventSort_) {
// We need event entries for sorting or for secondary files or sources.
needEventEntries = true;
}
indexIntoFile_.fillEventNumbersOrEntries(needEventNumbers, needEventEntries);
}
void
RootFile::reportOpened(std::string const& inputType) {
| bool edm::RootFile::wasFirstEventJustRead | ( | ) | const |
Definition at line 684 of file RootFile.cc.
{
typedef IndexIntoFile::EntryNumber_t EntryNumber_t;
| bool edm::RootFile::wasLastEventJustRead | ( | ) | const |
Definition at line 677 of file RootFile.cc.
{
| int edm::RootFile::whyNotFastClonable | ( | ) | const [inline] |
Definition at line 95 of file RootFile.h.
References whyNotFastClonable_.
{return whyNotFastClonable_;}
boost::shared_ptr<BranchChildren> edm::RootFile::branchChildren_ [private] |
Definition at line 196 of file RootFile.h.
Referenced by dropOnInput(), and RootFile().
boost::shared_ptr<BranchIDListRegistry::collection_type const> edm::RootFile::branchIDLists_ [private] |
Definition at line 188 of file RootFile.h.
Referenced by branchIDLists(), and RootFile().
boost::shared_ptr<BranchListIndexes> edm::RootFile::branchListIndexes_ [private] |
Definition at line 194 of file RootFile.h.
bool edm::RootFile::branchListIndexesUnchanged_ [private] |
Definition at line 180 of file RootFile.h.
Referenced by branchListIndexesUnchanged(), and RootFile().
boost::shared_ptr<DuplicateChecker> edm::RootFile::duplicateChecker_ [private] |
Definition at line 197 of file RootFile.h.
Referenced by goToEvent(), and initializeDuplicateChecker().
EventAuxiliary edm::RootFile::eventAux_ [private] |
Definition at line 181 of file RootFile.h.
Referenced by eventAux(), fillHistory(), and skipEvents().
boost::shared_ptr<BranchMapper> edm::RootFile::eventBranchMapper_ [mutable, private] |
Definition at line 200 of file RootFile.h.
Referenced by makeBranchMapper().
TTree* edm::RootFile::eventHistoryTree_ [private] |
Definition at line 192 of file RootFile.h.
std::vector<EventProcessHistoryID> edm::RootFile::eventProcessHistoryIDs_ [private] |
Definition at line 174 of file RootFile.h.
Referenced by fillHistory(), and RootFile().
std::vector<EventProcessHistoryID>::const_iterator edm::RootFile::eventProcessHistoryIter_ [private] |
Definition at line 175 of file RootFile.h.
Referenced by fillHistory(), and RootFile().
boost::shared_ptr<EventSelectionIDVector> edm::RootFile::eventSelectionIDs_ [private] |
Definition at line 193 of file RootFile.h.
boost::shared_ptr<EventSkipperByID> edm::RootFile::eventSkipperByID_ [private] |
Definition at line 165 of file RootFile.h.
Referenced by RootFile(), and skipEvents().
RootTree edm::RootFile::eventTree_ [private] |
Definition at line 182 of file RootFile.h.
Referenced by eventTree(), initializeDuplicateChecker(), nextEventEntry(), readLuminosityBlockAuxiliary_(), readRunAuxiliary_(), rewind(), RootFile(), and skipEvents().
FileID edm::RootFile::fid_ [private] |
Definition at line 167 of file RootFile.h.
Referenced by RootFile().
std::string const edm::RootFile::file_ [private] |
Definition at line 160 of file RootFile.h.
Referenced by file(), and RootFile().
Definition at line 166 of file RootFile.h.
Referenced by fileFormatVersion(), and RootFile().
boost::shared_ptr<InputFile> edm::RootFile::filePtr_ [private] |
Definition at line 164 of file RootFile.h.
Referenced by RootFile().
int edm::RootFile::forcedRunOffset_ [private] |
Definition at line 190 of file RootFile.h.
Referenced by RootFile().
boost::array<bool, NumBranchTypes> edm::RootFile::hasNewlyDroppedBranch_ [private] |
Definition at line 179 of file RootFile.h.
Referenced by hasNewlyDroppedBranch(), and RootFile().
boost::scoped_ptr<History> edm::RootFile::history_ [private] |
Definition at line 195 of file RootFile.h.
IndexIntoFile& edm::RootFile::indexIntoFile_ [private] |
Definition at line 169 of file RootFile.h.
Referenced by initializeDuplicateChecker(), and RootFile().
Definition at line 171 of file RootFile.h.
Referenced by rewind(), and RootFile().
Definition at line 172 of file RootFile.h.
Referenced by RootFile(), setAtEventEntry(), setPosition(), and setToLastEntry().
Definition at line 173 of file RootFile.h.
Referenced by indexIntoFileIter(), readLumi(), readLuminosityBlockAuxiliary_(), readRun_(), readRunAuxiliary_(), rewind(), RootFile(), setAtEventEntry(), setPosition(), and setToLastEntry().
boost::shared_ptr<IndexIntoFile> edm::RootFile::indexIntoFileSharedPtr_ [private] |
Definition at line 168 of file RootFile.h.
Referenced by indexIntoFileSharedPtr().
Definition at line 186 of file RootFile.h.
std::string const edm::RootFile::logicalFile_ [private] |
Definition at line 161 of file RootFile.h.
RootTree edm::RootFile::lumiTree_ [private] |
Definition at line 183 of file RootFile.h.
Referenced by lumiTree(), rewind(), and RootFile().
std::map<std::string, std::string> edm::RootFile::newBranchToOldBranch_ [private] |
Definition at line 191 of file RootFile.h.
Referenced by RootFile().
bool edm::RootFile::noEventSort_ [private] |
Definition at line 177 of file RootFile.h.
std::vector<ProcessHistoryID>& edm::RootFile::orderedProcessHistoryIDs_ [private] |
Definition at line 170 of file RootFile.h.
std::vector<ParentageID> edm::RootFile::parentageIDLookup_ [private] |
Definition at line 201 of file RootFile.h.
Referenced by makeBranchMapper().
ProcessConfiguration const& edm::RootFile::processConfiguration_ [private] |
Definition at line 162 of file RootFile.h.
Definition at line 163 of file RootFile.h.
Referenced by RootFile().
Definition at line 189 of file RootFile.h.
boost::shared_ptr<ProductRegistry const> edm::RootFile::productRegistry_ [private] |
Definition at line 187 of file RootFile.h.
Referenced by productRegistry(), and RootFile().
boost::scoped_ptr<ProvenanceAdaptor> edm::RootFile::provenanceAdaptor_ [private] |
Definition at line 198 of file RootFile.h.
Referenced by RootFile().
RootTree edm::RootFile::runTree_ [private] |
Definition at line 184 of file RootFile.h.
Referenced by rewind(), RootFile(), and runTree().
boost::scoped_ptr<EventPrincipal> edm::RootFile::secondaryEventPrincipal_ [mutable, private] |
Definition at line 199 of file RootFile.h.
Referenced by RootFile(), and secondaryEventPrincipal().
bool edm::RootFile::skipAnyEvents_ [private] |
Definition at line 176 of file RootFile.h.
RootTreePtrArray edm::RootFile::treePointers_ [private] |
Definition at line 185 of file RootFile.h.
Referenced by RootFile(), and treePointers().
int edm::RootFile::whyNotFastClonable_ [private] |
Definition at line 178 of file RootFile.h.
Referenced by RootFile(), and whyNotFastClonable().
1.7.3