void ARehabMainWindow::slot_actionRutaFichero(void) { if (!dirFiles.exists()) { dirFiles.mkdir("./ARehabFiles"); } if (fileDialog) { fileDialog->setFileMode(QFileDialog::AnyFile); fileDialog->setDefaultSuffix(".arehab"); if (fileDialog->exec()) { QString arehabFileMetadataURL = fileDialog->selectedFiles().first(); if (arehabFileMetadataURL != "") { QFile metadataFile(arehabFileMetadataURL); if (!metadataFile.open(QIODevice::WriteOnly)) { qWarning() << "Error abriendo el fichero para guardar." << endl; return; } this->arehabFileMetadata.arehabFileURL = QUrl::fromLocalFile(arehabFileMetadataURL).toLocalFile(); ui.txARehabFile->setText(QUrl::fromLocalFile(arehabFileMetadataURL).toLocalFile()); this->validateARehabFileURL(); } } } }
bool SphinxControl::initializeRecognition(const QString &modelPath) { kDebug() << "Initializing to " << modelPath << m_lastModel; if (modelPath != m_lastModel) { //already initialized / tried to initialize with this exact model m_lastModel = modelPath; kDebug() << "Initializing"; uninitialize(); m_startRequests = 0; QString path = KStandardDirs::locateLocal("tmp", "/simond/"+username+"/sphinx/"); if(!QDir(path).entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden | QDir::AllDirs | QDir::Files, QDir::DirsFirst).isEmpty()) { kDebug() << "Removing old data from working dir"; FileUtils::removeDirRecursive(path); path = KStandardDirs::locateLocal("tmp", "/simond/"+username+"/sphinx/"); } kDebug() << "Unpacking model to working dir"; if (!FileUtils::unpackAll(modelPath, path)) { return false; } QFile metadataFile(path+QLatin1String("metadata.xml")); if(!metadataFile.open(QIODevice::ReadOnly)) { emit recognitionError(i18n("Failed to read metadata from \"%1\"", path+QLatin1String("metadata.xml")), getBuildLog()); return NULL; } ModelMetadata metadata; QDomDocument DomDocument; DomDocument.setContent(&metadataFile); metadata.deserializeXml(DomDocument.documentElement()); metadataFile.close(); modelName = metadata.name(); } kDebug() << "Emitting recognition ready"; emit recognitionReady(); return true; }
//************************************************************************************************* //! Initializes the support data member with metadata file info. Returns TRUE if successful //************************************************************************************************* bool rspfQuickbirdRpcModel::parseMetaData(const rspfFilename& base_name) { rspfFilename metadataFile (base_name); metadataFile.setExtension("IMD"); if (!findSupportFile(metadataFile)) return false; if ( !theSupportData.valid() ) theSupportData = new rspfQuickbirdMetaData(); if(!theSupportData->open(metadataFile)) { theSupportData = 0; // rspfRefPtr rspfNotify(rspfNotifyLevel_WARN) << "rspfQuickbirdRpcModel::parseNitfFile WARNING:" << "\nCould not open IMD file. Sensor ID unknown." << std::endl; return false; } theSensorID = theSupportData->getSatID(); return true; }
bool WriteMetadataFile(TraceMetadata* inMetadata, const std::string& inMetadataFilepath, std::string& outMetadataXML) { bool bWriteSuccessful = false; gtString fullMetadataFilepathAsGTString; fullMetadataFilepathAsGTString.fromASCIIString(inMetadataFilepath.c_str()); osFile metadataFile(fullMetadataFilepathAsGTString); bool bMetadataFileOpened = metadataFile.open(osChannel::OS_ASCII_TEXT_CHANNEL, osFile::OS_OPEN_TO_WRITE); if (bMetadataFileOpened) { // Write the metadata xml into the output file. gtASCIIString metadataXMLString; inMetadata->WriteToXML(metadataXMLString); // Now, just for fun, convert the gtASCIIString to a gtString. gtString metadataXMLAsGTString; metadataXMLAsGTString.fromASCIIString(metadataXMLString.asCharArray()); // Write the metadata XML into the file, and close. metadataFile.writeString(metadataXMLAsGTString); metadataFile.close(); // The client will receive the full metadata XML string to parse. outMetadataXML.assign(metadataXMLString.asCharArray()); Log(logMESSAGE, "Wrote XML metadata file to '%s'.\n", inMetadataFilepath.c_str()); bWriteSuccessful = true; } else { Log(logERROR, "Failed to open trace metadata file for writing: '%s'\n", inMetadataFilepath.c_str()); } return bWriteSuccessful; }
//-------------------------------------------------------------------------- /// Write a trace's metadata file and return the contenst through the out-param. /// \param inFullResponseString The full response string for a collected linked trace request. /// \param outMetadataXML The XML metadata string to return to the client. /// \returns True if writing the metadata file was successful. //-------------------------------------------------------------------------- bool MultithreadedTraceAnalyzerLayer::WriteTraceAndMetadataFiles(const std::stringstream& inFullResponseString, std::string& outMetadataXML) { bool bWrittenSuccessfully = false; // Empty out the incoming path to the metadata file. We'll know the exact path later. outMetadataXML.assign(""); osModuleArchitecture moduleArchitecture; osRuntimePlatform currentPlatform; gtString executablePath; gtString commandLine; gtString workingDirectory; // Retrieve the name of the instrumented application. Construct a metadata filename which references it. if (osGetProcessLaunchInfo(osGetCurrentProcessId(), moduleArchitecture, currentPlatform, executablePath, commandLine, workingDirectory) == true) { osFilePath executableFilepath; executableFilepath.setFullPathFromString(executablePath); gtString appName; if (executableFilepath.getFileName(appName) == true) { osTime currentTime; currentTime.setFromCurrentTime(); tm timeStruct; currentTime.timeAsTmStruct(timeStruct, osTime::LOCAL); // Need to add 1900, since tm contains "years since 1900". int year = timeStruct.tm_year + 1900; // Need to add 1, since tm contains "months since January". int month = timeStruct.tm_mon + 1; int day = timeStruct.tm_mday; int hour = timeStruct.tm_hour; int minute = timeStruct.tm_min; int second = timeStruct.tm_sec; gtASCIIString metadataFilename; // ExecutableFilename-YEAR-MM-DD-HOUR-MINUTE-SECOND metadataFilename.appendFormattedString("description-%s-%d-%d-%d-%d-%d-%d.xml", appName.asASCIICharArray(), year, month, day, hour, minute, second); // Build a path to the GPS folder within the Temp directory. osFilePath systemTempDirectory; systemTempDirectory.setPath(osFilePath::OS_TEMP_DIRECTORY); gtString toolDirectory; #ifdef CODEXL_GRAPHICS toolDirectory.fromASCIIString("CodeXL"); #else toolDirectory.fromASCIIString(GetPerfStudioDirName()); #endif // @TODO: Construct a path from the temp + tool directory. systemTempDirectory.appendSubDirectory(toolDirectory); gtList<osFilePath> toolDirectoryPaths; osDirectory d; d.setDirectoryPath(systemTempDirectory); // @TODO: Find a better way to create the "Session" directory. We shouldn't need to search through existing session directories. int maxSessionIndex = 0; bool bGotSubDirectories = d.getSubDirectoriesPaths(osDirectory::SORT_BY_NAME_DESCENDING, toolDirectoryPaths); if (bGotSubDirectories) { // Step through each directory, and look for "Session" folders. gtList<osFilePath>::iterator subdirectoryIter; for (subdirectoryIter = toolDirectoryPaths.begin(); subdirectoryIter != toolDirectoryPaths.end(); ++subdirectoryIter) { gtString subdirString; osFilePath subdir = *subdirectoryIter; subdir.getFileName(subdirString); if (subdir.isDirectory() && subdirString.startsWith(L"Session")) { // Remove the "Session" part of the string. We're only interested in the number at the end. subdirString.replace(L"Session", L"", true); const char* sessionIndexAsString = subdirString.asASCIICharArray(); int thisSessionId = atoi(sessionIndexAsString); if (thisSessionId > maxSessionIndex) { maxSessionIndex = thisSessionId; } } } } gtASCIIString pathToDataDirectory = systemTempDirectory.asString().asASCIICharArray(); // Metadata files will be saved to the temp directory with the following filename scheme: // "%TEMP%/ToolDirectory/Session[Index]/ApplicationBinaryName/Frame[Index]/description.xml" int frameIndex = GetInterceptor()->GetParentLayerManager()->GetFrameCount(); // Generate a "Session" folder with a number at the end. Compute the correct number by looking at the // Session folders that already exist gtASCIIString sessionString; sessionString.appendFormattedString("Session%d", maxSessionIndex + 1); pathToDataDirectory.appendFormattedString("\\%s\\%s\\Frame%d\\", sessionString.asCharArray(), appName.asASCIICharArray(), frameIndex); // Create the data directory if it doesn't already exist. gtString fullPathToDataDirectoryAsGTString; fullPathToDataDirectoryAsGTString.fromASCIIString(pathToDataDirectory.asCharArray()); osDirectory dir; dir.setDirectoryFullPathFromString(fullPathToDataDirectoryAsGTString); if (!dir.exists()) { bool bDirectoryCreated = dir.create(); if (!bDirectoryCreated) { Log(logERROR, "Failed to create data directory for traced frame: '%s'.\n", fullPathToDataDirectoryAsGTString.asASCIICharArray()); } } gtASCIIString pathToMetadataFile = pathToDataDirectory; pathToMetadataFile.appendFormattedString("%s", metadataFilename.asCharArray()); gtString fullMetadataFilepathAsGTString; fullMetadataFilepathAsGTString.fromASCIIString(pathToMetadataFile.asCharArray()); osFile metadataFile(fullMetadataFilepathAsGTString); bool bMetadataFileOpened = metadataFile.open(osChannel::OS_ASCII_TEXT_CHANNEL, osFile::OS_OPEN_TO_WRITE); // If we've successfully opened the metadata file, we'll also attempt to write the trace file. if (bMetadataFileOpened) { osFilePath traceFileDirectory; traceFileDirectory.setPath(osFilePath::OS_TEMP_DIRECTORY); traceFileDirectory.appendSubDirectory(toolDirectory); // Construct a filename for the cached trace response. gtASCIIString fullTraceFilename; fullTraceFilename.appendFormattedString("LinkedTrace-%s-%d-%d-%d-%d-%d-%d.ltr", appName.asASCIICharArray(), year, month, day, hour, minute, second); gtASCIIString fullTraceFilePath = pathToDataDirectory; fullTraceFilePath.appendFormattedString("%s", fullTraceFilename.asCharArray()); gtString fullTraceResponseFilepathGTString; fullTraceResponseFilepathGTString.fromASCIIString(fullTraceFilePath.asCharArray()); // Write the contents of the trace response file. osFile traceResponseFile(fullTraceResponseFilepathGTString); bool bTraceResponseFileOpened = traceResponseFile.open(osChannel::OS_ASCII_TEXT_CHANNEL, osFile::OS_OPEN_TO_WRITE); if (bTraceResponseFileOpened) { // Dump the response into an ASCII string. std::string responseAsString = inFullResponseString.str(); // Now put the ASCII string into a gtString so we can write it to the open file. gtString gtStringResponse; std::wstring wideString; wideString.assign(responseAsString.begin(), responseAsString.end()); gtStringResponse.appendFormattedString(L"%s", wideString.c_str()); traceResponseFile.writeString(gtStringResponse); traceResponseFile.close(); } else { Log(logERROR, "Failed to write trace response to file: '%s'\n", fullTraceResponseFilepathGTString.asASCIICharArray()); } // Write the filename for the associated trace response that was just collected. std::string traceFilepathAsString; traceFilepathAsString.assign(fullTraceResponseFilepathGTString.asASCIICharArray()); TraceMetadata metadata; // Insert the location of the metadata file being written out. metadata.mMetadataFilepath = pathToMetadataFile.asCharArray(); // Insert the path to the cached trace file. metadata.mPathToTraceFile = fullTraceFilePath.asCharArray(); // @TODO: When we have a framebuffer image system working, assign the path-to-image here. metadata.mPathToFrameBufferImage = "UNKNOWNPATH"; ModernAPILayerManager* layerManager = GetInterceptor()->GetParentLayerManager(); FrameInfo frameInfo; layerManager->GetFrameInfo(frameInfo); // Populate the metadata structure with the values stored in the LayerManager. metadata.mFrameInfo = frameInfo; metadata.mFrameIndex = frameIndex; metadata.mArchitecture = moduleArchitecture; // Write the metadata xml into the output file. gtASCIIString metadataXMLString; metadata.WriteToXML(metadataXMLString); gtString metadataXMLAsGTString; metadataXMLAsGTString.fromASCIIString(metadataXMLString.asCharArray()); // Write the metadata XML into the file, and close. metadataFile.writeString(metadataXMLAsGTString); metadataFile.close(); // The client will receive the full metadata XML string to parse. outMetadataXML.assign(metadataXMLString.asCharArray()); bWrittenSuccessfully = true; } else { Log(logERROR, "Failed to open trace metadata file for writing: '%s'\n", metadataFilename); } } else { Log(logERROR, "Failed to retrieve the instrumented process's application filename.\n"); } } else { Log(logERROR, "Failed to retrieve process launch info for target application.\n"); } return bWrittenSuccessfully; }
bool Deck::importMnemosyne(QString fileName) { QFileInfo fi(fileName); QString baseName = fi.baseName().toLower(); QString tempFolder = utils::combinePaths(tempPath(), baseName); QString metadataPath = utils::combinePaths(tempFolder, "METADATA"); QString cardsPath = utils::combinePaths(tempFolder, "cards.xml"); utils::createDirectory(tempFolder); Compressor c; if(!c.decompressFolder(fileName, tempFolder)) { return false; } /// import metadata /// QTextStream s; QFile metadataFile(metadataPath); metadataFile.open(QIODevice::ReadOnly | QIODevice::Text); if(!metadataFile.isOpen()) return false; s.setDevice(&metadataFile); s.setCodec("UTF-8"); QStringList sl; QString l = s.readLine(); while (!s.atEnd()) { sl = l.split(":"); if(sl.size()>1) { if(sl[0]=="tags") setTags(sl[1]); else if(sl[0]=="notes") setDesc(sl[1]); else if(sl[0]=="author_name") setAuthor(sl[1]); else if(sl[0]=="card_set_name") setName(sl[1]); } l = s.readLine(); } /// read cards QDomDocument domDocument; QString errorStr; int errorLine; int errorColumn; QString front, back, level; QFile cardsFile(cardsPath); cardsFile.open(QIODevice::ReadOnly | QIODevice::Text); if(!cardsFile.isOpen()) return false; if (!domDocument.setContent(&cardsFile, true, &errorStr, &errorLine, &errorColumn)) { qDebug() << QString("Parse error at line %1, column %2:\n%3") .arg(errorLine) .arg(errorColumn) .arg(errorStr); return false; } QDomElement root = domDocument.documentElement(); QString rootName = root.tagName().toLower(); if (rootName == "opensm2sync") { QDomNodeList nodes = root.elementsByTagName("log"); QDomNode node; QDomElement elnode; int count = nodes.count(); for(int no = 0; no < count; no++) { node = nodes.at(no); if(node.attributes().namedItem("type").nodeValue()=="16") { elnode = node.firstChildElement("f"); front = elnode.text(); elnode = node.firstChildElement("b"); back = elnode.text(); if(!front.isEmpty()) { Card *card = new Card(); card->updateFront(front); card->updateBack(back); addCard(card); } } } } metadataFile.close(); cardsFile.close(); utils::removeFile(metadataPath); utils::removeFile(cardsPath); utils::copyDirectory(getDeckPath(), tempFolder); return true; }
ControllerMetadata loadControllerMetadata(string path, string packageName, bool formatName) { string line; string key; string value; ControllerMetadata result; if (formatName) result.name = cleanUpPackageName(packageName); else result.name = packageName; result.description = string("No description"); result.version = string("Unknown version"); result.author = string("Unknown author"); result.startScriptPath = path + "/start.ops"; result.stopScriptPath = path + "/stop.ops"; result.guiLibPath = path + "/lib/libcontroller_gui.so"; result.guiDescriptionPath = path + "/controller_gui.glade"; result.guiConfigPath = path + "/gui_config.yaml"; result.guiTabWidgetName = string("controller_tab"); result.loadSuccessful = false; ifstream metadataFile((path + "/controller.txt").c_str(), ios::in); if (metadataFile.is_open()) { while (metadataFile.good()) { getline(metadataFile, line); key = getKey(line); trim(key); toLowercase(&key); if (key == "name") { value = getValue(line); trim(value); result.name = value; } else if (key == "description") { value = getValue(line); trim(value); result.description = value; } else if (key == "version") { value = getValue(line); trim(value); result.version = value; } else if (key == "author") { value = getValue(line); trim(value); result.author = value; } else if (key == "startscriptpath") { value = getValue(line); trim(value); result.startScriptPath = value; } else if (key == "stopscriptpath") { value = getValue(line); trim(value); result.stopScriptPath = value; } else if (key == "guilibpath") { value = getValue(line); trim(value); result.guiLibPath = value; } else if (key == "guitabwidgetname") { value = getValue(line); trim(value); result.guiTabWidgetName = value; } else if (key == "guidescriptionpath") { value = getValue(line); trim(value); result.guiDescriptionPath = value; } } metadataFile.close(); result.loadSuccessful = true; } return result; }
int main(int argc, char* argv[]) { OpenAB::OpenAB_init(); OpenAB::Logger::OutLevel() = OpenAB::Logger::Debug; std::map<std::string, std::string> availablePlugins = OpenAB::PluginManager::getInstance().PluginManager::getListOfPlugins(); std::string pluginsDescription = "Available plugins: "; std::map<std::string, std::string>::const_iterator it; for (it = availablePlugins.begin(); it != availablePlugins.end();++it) { pluginsDescription += (*it).first + " "; } const char* syncType = NULL; const char* localPlugin = NULL; const char* remotePlugin = NULL; const char* localParams = NULL; const char* remoteParams = NULL; poptContext optCon; struct poptOption optionsTable[] = { {"syncType", ' ', POPT_ARG_STRING, &syncType, ' ', "Available Synchronization type: OneWay or TwoWay", "Type of synchronization to be performed"}, {"localPlugin", ' ', POPT_ARG_STRING, &localPlugin, ' ', pluginsDescription.c_str(), "Name of plugin to be used for local storage"}, {"remotePlugin", ' ', POPT_ARG_STRING, &remotePlugin, ' ', pluginsDescription.c_str(), "Name of plugin to be used for remote source/storage"}, {"localParams", ' ', POPT_ARG_STRING, &localParams, ' ', "Please refer to OpenAB plugins documentation for parameters specific to given plugin", "JSON encoded parameters for local plugin"}, {"remoteParams", ' ', POPT_ARG_STRING, &remoteParams, ' ', "Please refer to OpenAB plugins documentation for parameters specific to given plugin", "JSON encoded parameters for remote plugin"}, POPT_AUTOHELP POPT_TABLEEND }; optCon = poptGetContext(NULL, argc, (const char **) argv, optionsTable, 0); char opt; while ((opt = (char)poptGetNextOpt(optCon)) >= 0) { } poptFreeContext(optCon); if (syncType == NULL || localPlugin == NULL || remotePlugin == NULL || localParams == NULL || remoteParams == NULL) { LOG_ERROR()<<"Please provide all required parameters"<<std::endl; return 1; } OpenAB_Sync::Parameters params; params.setValue("remote_plugin", remotePlugin); if (!params.remoteSourcePluginParams.fromJSON(remoteParams)) { LOG_ERROR()<<"Cannot parse remote plugin parameters: "<<remoteParams<<std::endl; return 1; } params.remoteStoragePluginParams = params.remoteSourcePluginParams; params.setValue("local_plugin", localPlugin); if (!params.localSourcePluginParams.fromJSON(localParams)) { LOG_ERROR()<<"Cannot parse local plugin parameters: "<<localParams<<std::endl; return 1; } params.localStoragePluginParams = params.localSourcePluginParams; params.setValue("callback", &cb); std::string metadata; std::string line; std::ifstream metadataFile (".metadata"); if (metadataFile.is_open()) { while (std::getline(metadataFile, line)) { metadata += line; } metadataFile.close(); unlink(".metadata"); params.setValue("metadata", metadata); } OpenAB_Sync::Sync* s = OpenAB::PluginManager::getInstance().getPluginInstance<OpenAB_Sync::Sync>(syncType, params); if (NULL == s) { LOG_ERROR()<<"Cannot initialize synchronization plugin"<<std::endl; return 1; } std::vector<std::string> ignore; s->addPhase("empty", ignore); if ( s->eInitOk != s->init() ) { LOG_ERROR()<<"Initialization failed"<<std::endl; OpenAB::PluginManager::getInstance().freePluginInstance(s); return 1; } s->synchronize(); /* while(std::getline(std::cin, line) && !finished) { if(line.compare("p") == 0) { s->suspend(); printf("Suspend\n"); } if(line.compare("r") == 0) { s->resume(); printf("Resume\n"); } if(line.compare("c") == 0) { s->cancel(); printf("Cancel\n"); } if(line.compare("e") == 0) { break; } }*/ while(!finished) usleep(100000); unsigned int lAdd, lMod, lRem, rAdd, rMod, rRem; s->getStats(lAdd, lMod, lRem, rAdd, rMod, rRem); LOG_DEBUG()<<"Synchronization statistics:"<<std::endl; LOG_DEBUG()<<"Locally added items: "<<lAdd<<std::endl; LOG_DEBUG()<<"Locally modified items: "<<lMod<<std::endl; LOG_DEBUG()<<"Locally removed items: "<<lRem<<std::endl; LOG_DEBUG()<<std::endl; LOG_DEBUG()<<"Remotely added items: "<<rAdd<<std::endl; LOG_DEBUG()<<"Remotely modified items: "<<rMod<<std::endl; LOG_DEBUG()<<"Remotely removed items: "<<rRem<<std::endl; OpenAB::PluginManager::getInstance().freePluginInstance(s); }
void metadataUpdated(const std::string& metadata) { std::ofstream metadataFile (".metadata"); metadataFile<<metadata; metadataFile.close(); }
LLGAnalysis::LLGAnalysis( char *configFileName ) { // Setup the default values for the cuts: JET_PT_CUT_SV = 30; JET_PT_CUT_PV = 75; JET_ETA_CUT = 5.0; LEADING_SV_JET_CUT = 10000.; MJJ_CUT = 10000; MUON_PT_CUT = 15.; ELECTRON_PT_CUT = 15.; MET_CUT = 210.; PROC_XSEC = 1.; PROC_NTOT = 1.; applyEventWeights = false; TARGET_LUMI = 1000.; //SELECTION = "SignalRegion"; SELECTION = "TTJetsCR"; metadataFileName = "Configuration/DatasetMetadata.txt"; datasetName = "Signal_500_60"; _writeOutputTree = true; ifstream configFile( configFileName, ios::in ); while( configFile.good() ) { string key, value; configFile >> key >> ws >> value; if( configFile.eof() ) break; if( key == "InputFile" ) _inputFileNames.push_back( value ); if( key == "InputTree" ) _inputTreeName = value; if( key == "JET_PT_CUT_SV" ) JET_PT_CUT_SV = atof(value.c_str()); if( key == "JET_PT_CUT_PV" ) JET_PT_CUT_PV = atof(value.c_str()); if( key == "JET_ETA_CUT" ) JET_ETA_CUT = atof(value.c_str()); if( key == "MUON_PT_CUT" ) MUON_PT_CUT = atof(value.c_str()); if( key == "ELECTRON_PT_CUT" ) ELECTRON_PT_CUT = atof(value.c_str()); if( key == "MET_CUT" ) MET_CUT = atof(value.c_str()); //if( key == "PROC_XSEC" ) PROC_XSEC = atof(value.c_str()); //if( key == "PROC_NTOT" ) PROC_NTOT = atof(value.c_str()); if( key == "TARGET_LUMI" ) TARGET_LUMI = atof(value.c_str()); if( key == "ApplyEventWeights" ) applyEventWeights = ( atoi(value.c_str()) == 1 ); if( key == "Selection" ) SELECTION = value; if( key == "MetadataFileName" ) metadataFileName = value; if( key == "DatasetName" ) datasetName = value; if( key == "WriteOutputTree" ) _writeOutputTree = (bool)(atoi(value.c_str())); if( key == "LEADING_SV_JET_CUT" ) LEADING_SV_JET_CUT = atof(value.c_str()); if( key == "MJJ_CUT" ) MJJ_CUT = atof(value.c_str()); } outputHistos = datasetName + "_histos.root"; //_outputHistos = datasetName + "_histos.root"; _outputFileName = datasetName + "_tree.root"; _outputFile = new TFile( _outputFileName.c_str(), "RECREATE" ); _outputTree = new TTree( _inputTreeName.c_str(), _inputTreeName.c_str() ); bool foundMetadata = false; ifstream metadataFile( metadataFileName.c_str(), ios::in ); while( metadataFile.good() ) { string name, xs, ntot; metadataFile >> name >> ws >> xs >> ws >> ntot; if( metadataFile.eof() ) break; if( name == datasetName ) { PROC_XSEC = atof( xs.c_str() ); PROC_NTOT = atof( ntot.c_str() ); foundMetadata = true; break; } } if( !foundMetadata ) { cout << "Did not find dataset " << datasetName << " in " << metadataFileName << ". Using standard values for xsec and ntot: " << PROC_XSEC << " " << PROC_NTOT << endl; } evtWeight = applyEventWeights ? PROC_XSEC/PROC_NTOT * TARGET_LUMI : 1.; std::cout << "evtWeight is " << evtWeight << std::endl; }
//-------------------------------------------------------------------------- /// Write a trace's metadata file and return the contenst through the out-param. /// \param inHeaderString The full response string for a collected linked trace request. /// \param inResponseString Response string /// \param outMetadataXML The XML metadata string to return to the client. /// \returns True if writing the metadata file was succesful. //-------------------------------------------------------------------------- bool MultithreadedTraceAnalyzerLayer::WriteTraceAndMetadataFiles(const gtASCIIString& inHeaderString, const gtASCIIString& inResponseString, std::string& outMetadataXML) { bool bWrittenSuccessfully = false; // Empty out the incoming path to the metadata file. We'll know the exact path later. outMetadataXML.assign(""); // Use this object to pass data into and out of the GetSessionManagaerData() method. SessionManagerData smd; smd.frameIndex = GetParentLayerManager()->GetFrameCount(); bool result = SessionManager::Instance()->GetSessionManagerData(smd); if (result == false) { return result; } gtASCIIString pathToMetadataFile = smd.pathToDataDirectory; //pathToDataDirectory; pathToMetadataFile.appendFormattedString("%s", smd.metadataFilename.asCharArray()); gtString fullMetadataFilepathAsGTString; fullMetadataFilepathAsGTString.fromASCIIString(pathToMetadataFile.asCharArray()); osFile metadataFile(fullMetadataFilepathAsGTString); bool bMetadataFileOpened = metadataFile.open(osChannel::OS_ASCII_TEXT_CHANNEL, osFile::OS_OPEN_TO_WRITE); // If we've successfully opened the metadata file, we'll also attempt to write the trace file. if (bMetadataFileOpened == false) { Log(logERROR, "Failed to open trace metadata file for writing: '%s'\n", smd.metadataFilename.asCharArray()); return false; } osFilePath traceFileDirectory; traceFileDirectory.setPath(osFilePath::OS_TEMP_DIRECTORY); traceFileDirectory.appendSubDirectory(smd.toolDirectory); // Construct a filename for the cached trace response. gtASCIIString fullTraceFilename; fullTraceFilename.appendFormattedString("LinkedTrace-%s-%d-%d-%d-%d-%d-%d.ltr", smd.appName.asASCIICharArray(), smd.year, smd.month, smd.day, smd.hour, smd.minute, smd.second); gtASCIIString fullTraceFilePath = smd.pathToDataDirectory; fullTraceFilePath.appendFormattedString("%s", fullTraceFilename.asCharArray()); gtString fullTraceResponseFilepathGTString; fullTraceResponseFilepathGTString.fromASCIIString(fullTraceFilePath.asCharArray()); // Write the contents of the trace response file. osFile traceResponseFile(fullTraceResponseFilepathGTString); bool bTraceResponseFileOpened = traceResponseFile.open(osChannel::OS_ASCII_TEXT_CHANNEL, osFile::OS_OPEN_TO_WRITE); if (bTraceResponseFileOpened) { traceResponseFile.writeString(inHeaderString); traceResponseFile.writeString(inResponseString); traceResponseFile.close(); } else { Log(logERROR, "Failed to write trace response to file: '%s'\n", fullTraceResponseFilepathGTString.asASCIICharArray()); } // Write the filename for the associated trace response that was just collected. std::string traceFilepathAsString; traceFilepathAsString.assign(fullTraceResponseFilepathGTString.asASCIICharArray()); TraceMetadata metadataToWrite; // Insert the location of the metadata file being written out. metadataToWrite.mMetadataFilepath = pathToMetadataFile.asCharArray(); // Insert the path to the cached trace file. metadataToWrite.mPathToTraceFile = fullTraceFilePath.asCharArray(); // Write object files info. It is currently assumed trace and object data will exists simultaneously. metadataToWrite.mPathToObjectTreeFile = smd.pathToDataDirectory.asCharArray(); metadataToWrite.mPathToObjectTreeFile.append("ObjectTree.xml"); metadataToWrite.mPathToObjectDatabaseFile = smd.pathToDataDirectory.asCharArray(); metadataToWrite.mPathToObjectDatabaseFile.append("FullObjectDatabase.xml"); ModernAPIFrameDebuggerLayer* frameDebugger = GetParentLayerManager()->GetFrameDebuggerLayer(); unsigned char* pngData = NULL; unsigned int numBytes = 0; // NOTE: Passing in 0 for the width and height will cause the renderer to render the PNG image at the same resolution as the applications frame buffer (i.e full resolution). bool bCapturedSuccessfully = frameDebugger->CaptureFrameBuffer(0, 0, &pngData, &numBytes, true); if (bCapturedSuccessfully) { gtASCIIString fullImageFilename; fullImageFilename.appendFormattedString("%s_FrameBuffer%d.png", smd.appName.asASCIICharArray(), smd.frameIndex); gtASCIIString imageFilepath = smd.pathToDataDirectory; imageFilepath.appendFormattedString("%s", fullImageFilename.asCharArray()); FILE* frameBufferImageFile = fopen(imageFilepath.asCharArray(), "wb"); if (frameBufferImageFile != NULL) { fwrite(pngData, sizeof(unsigned char), numBytes, frameBufferImageFile); fclose(frameBufferImageFile); // Add the captured image's path into the XML metadata. metadataToWrite.mPathToFrameBufferImage = imageFilepath.asCharArray(); } else { Log(logERROR, "Failed to write frame buffer image file.\n"); } SAFE_DELETE_ARRAY(pngData); } else { metadataToWrite.mPathToFrameBufferImage = "ERROR - Failed to capture frame buffer image."; Log(logERROR, "Failed to capture frame buffer for captured frame.\n"); } // @TODO: This is placeholder for now to get a prototype working. // We should also be able to set this to "Capture". metadataToWrite.mTraceType = kTraceType_Linked; // @TODO: This is temporary until TraceMetadata generation is moved to the LayerManager. FrameInfo frameInfo; frameDebugger->GetFrameInfo(&frameInfo); // Populate the metadata structure with the values stored in the LayerManager. metadataToWrite.mFrameInfo = &frameInfo; metadataToWrite.mArchitecture = smd.moduleArchitecture; metadataToWrite.mAPICallCount = GetNumTracedAPICalls(); metadataToWrite.mDrawCallCount = GetNumTracedDrawCalls(); bool bMetadataWriteSuccessful = WriteMetadataFile(&metadataToWrite, pathToMetadataFile.asCharArray(), outMetadataXML); if (bMetadataWriteSuccessful) { bWrittenSuccessfully = true; } return bWrittenSuccessfully; }