bool initializeModelTempDir(const openstudio::path& osmPath, const openstudio::path& modelTempDir)
{
bool result = true;
if( osmPath.empty() || !boost::filesystem::exists(osmPath)){
LOG_FREE(Debug, "initializeModelTempDir", "OSM path '" << toString(osmPath) << "' is empty or does not exist");
result = false;
}else{
LOG_FREE(Debug, "initializeModelTempDir", "Copying '" << toString(osmPath) << "' to '" << toString(modelTempDir / toPath("in.osm")) << "'");
// copy osm file
bool test = QFile::copy(toQString(osmPath), toQString(modelTempDir / toPath("in.osm")));
if (!test){
LOG_FREE(Error, "initializeModelTempDir", "Could not copy '" << toString(osmPath) << "' to '" << toString(modelTempDir / toPath("in.osm")) << "'");
}
// Copy all files from existing resources dir into temp dir when opening
openstudio::path sourceDir = osmPath.parent_path() / osmPath.stem();
openstudio::path destDir = modelTempDir / toPath("resources");
if (boost::filesystem::exists(sourceDir)){
LOG_FREE(Debug, "initializeModelTempDir", "Copying '" << toString(sourceDir) << "' to '" << toString(destDir) << "'");
test = copyDir(toQString(sourceDir), toQString(destDir));
if (!test){
LOG_FREE(Error, "initializeModelTempDir", "Could not copy '" << toString(sourceDir) << "' to '" << toString(destDir) << "'");
result = false;
}
}
}
return result;
}
openstudio::path MainWindow::getOutDir(const openstudio::path &t_file, const openstudio::runmanager::Workflow &t_wf, const std::string &t_jobstring, bool t_simpleName)
{
openstudio::path outpath = m_runmanager.getConfigOptions().getOutputLocation();
openstudio::path parentdir = t_file.parent_path();
openstudio::path jobname;
openstudio::path tailpathname = toPath("workflow-" + (t_simpleName?t_jobstring:t_wf.key()));
QString jobstring = toQString(t_jobstring);
jobstring.remove(">");
if (openstudio::toString(t_file.stem()) == "in")
{
// The file is called "in", let's use the parent path's name as our job name
jobname = openstudio::toPath(parentdir.filename());
} else {
// Let's use the stem of the file name to create a working dir, since it's a meaningful name
jobname = openstudio::toPath(t_file.stem());
}
std::string workflowkey = "workflow-" + t_wf.key();
if (outpath.empty())
{
if (openstudio::toString(t_file.stem()) == "in")
{
return parentdir / tailpathname; // if we are running in the parent dir, and our name is "in" no reason to make a subdir
} else {
return parentdir / jobname / tailpathname; // we are either reconstructing the path it was already in, or making a new one based on the file name
}
} else {
return outpath / jobname / tailpathname; // use the outpath
}
}
SimFile::SimFile(openstudio::path path)
{
m_hasLfr = false;
m_hasNfr = false;
m_hasNcr = false;
// For now, we need to cheat and assume that the .lfr etc. actually exist
// This means that simread has to have been run for this to work
openstudio::path lfrPath = path.replace_extension(openstudio::toPath("lfr").string());
m_hasLfr = readLfr(openstudio::toQString(lfrPath));
openstudio::path nfrPath = path.replace_extension(openstudio::toPath("nfr").string());
m_hasNfr = readNfr(openstudio::toQString(nfrPath));
}
openstudio::path ScriptFolderListView::iterateFileName(const openstudio::path &t_path)
{
struct BuildFileName
{
static openstudio::path doit(const openstudio::path &t_root,
const std::string &t_stem,
const std::string &t_extension,
int iteration)
{
std::stringstream numportion;
if (iteration > 0)
{
numportion << "-";
if (iteration < 10)
{
numportion << "0";
}
numportion << iteration;
}
return t_root / openstudio::toPath(t_stem + numportion.str() + t_extension);
}
};
std::string stem = openstudio::toString(t_path.stem());
if (boost::regex_match(openstudio::toString(stem), boost::regex(".*-[0-9][0-9]")))
{
stem = stem.substr(0, stem.size() - 3);
}
int num = 99;
openstudio::path p;
openstudio::path last;
do
{
last = p;
p = BuildFileName::doit(t_path.parent_path(), openstudio::toString(stem), openstudio::toString(t_path.extension()), num);
--num;
} while (!boost::filesystem::exists(p) && num > -1);
if (!boost::filesystem::exists(p))
{
return p;
} else {
return last;
}
}
void MainWindow::rootPathChanged(const openstudio::path &p)
{
if (toPath(ui.txtRootPath->text()) != p)
{
ui.txtRootPath->setText(toQString(p.external_file_string()));
}
}
ScriptItem::ScriptItem(const openstudio::path& path,
OSItemType type,
QWidget * parent)
: OSItem(scriptToItemId(path), type, parent),
m_removed(false),
m_scriptInfo(path, true, false)
{
setText(openstudio::toQString(path.filename()));
setLeftPixmap(QPixmap(":/images/icon_scripts.png"));
if (boost::regex_search(toString(itemId().sourceId()),boost::regex("resource"))) {
m_scriptInfo.isUserScript = false;
}
else {
try {
m_scriptInfo = runmanager::RubyJobBuilder::updateArgumentsFromDb(m_scriptInfo);
} catch (const runmanager::ScriptDetectionError &e) {
// Nothing to display here in the constructor
m_scriptInfo = e.scriptInfo;
}
}
std::shared_ptr<OSDocument> osDoc = OSAppBase::instance()->currentDocument();
connect(this, &ScriptItem::argChanged, osDoc.get(), &OSDocument::markAsModified);
}
boost::optional<EpwFile> WeatherFile_Impl::file(const openstudio::path& dir) const {
boost::optional<EpwFile> result;
// get current path
boost::optional<openstudio::path> currentPath = this->path();
if (currentPath){
// try to load absolute path
if (currentPath->is_complete() && boost::filesystem::exists(*currentPath)) {
try {
result = EpwFile(*currentPath);
return result;
}catch (...) {}
// loading absolute path failed, try as relative path
currentPath = toPath(currentPath->filename());
}
// try relative path
if (!dir.empty()){
openstudio::path newPath = boost::filesystem::complete(*currentPath, dir);
if (boost::filesystem::exists(newPath)) {
try {
result = EpwFile(newPath);
return result;
}catch (...) {}
}
}
}
return boost::none;
}
Job JobFactory::createEnergyPlusJob(
ToolInfo t_energyPlusTool,
const openstudio::path &t_idd,
const openstudio::path &t_idf,
const openstudio::path &t_epw,
const openstudio::path &t_outdir,
const boost::optional<openstudio::UUID> &t_uuid)
{
JobParams params;
params.append("outdir", toString(t_outdir));
Tools tools;
t_energyPlusTool.name = "energyplus";
tools.append(t_energyPlusTool);
Files files;
FileInfo idf(t_idf, "idf");
if (!t_idd.empty())
{
idf.addRequiredFile(t_idd,toPath("Energy+.idd"));
}
idf.addRequiredFile(t_epw, toPath("in.epw"));
files.append(idf);
return createEnergyPlusJob(tools, params, files, std::vector<openstudio::URLSearchPath>(), t_uuid);
}
Job JobFactory::createEnergyPlusJob(
const openstudio::runmanager::Tools &t_tools,
const openstudio::path &t_idd,
const openstudio::path &t_idf,
const openstudio::path &t_epw,
const openstudio::path &t_outdir,
const boost::optional<openstudio::UUID> &t_uuid)
{
JobParams params;
params.append("outdir", toString(t_outdir));
Files files;
FileInfo idf(t_idf, "idf");
if (!t_idd.empty())
{
idf.addRequiredFile(t_idd,toPath("Energy+.idd"));
}
if (boost::filesystem::is_directory(t_epw))
{
params.append("epwdir", toString(t_epw));
} else {
idf.addRequiredFile(t_epw, toPath("in.epw"));
}
files.append(idf);
return createEnergyPlusJob(t_tools, params, files, std::vector<openstudio::URLSearchPath>(), t_uuid);
}
boost::optional<TimeDependentValuationFile> TimeDependentValuation_Impl::file(const openstudio::path& dir) const {
if (!m_file) {
// get current path
boost::optional<openstudio::path> currentPath = this->path();
if (currentPath){
// try to load absolute path
if (currentPath->is_complete() && boost::filesystem::exists(*currentPath)) {
m_file = TimeDependentValuationFile::load(*currentPath);
// loading absolute path failed, try as relative path
if (!m_file){
currentPath = toPath(currentPath->filename());
}
}
// try relative path
if (!m_file){
if (!dir.empty()){
openstudio::path newPath = boost::filesystem::complete(*currentPath, dir);
if (boost::filesystem::exists(newPath)) {
m_file = TimeDependentValuationFile::load(*currentPath);
}
}
}
}
}
return m_file;
}
openstudio::path NormalizeURLs::getFilename(const QUrl &t_url, const openstudio::path &t_filename)
{
const std::map<QUrl, openstudio::path>::const_iterator itr = m_url_map.find(t_url);
if (itr != m_url_map.end())
{
// we've already mapped this url, let's return the same one
return itr->second;
}
const size_t existingcount = m_filenames.count(t_filename);
if (existingcount == 0)
{
m_filenames.insert(t_filename);
m_url_map[t_url] = t_filename;
return t_filename;
} else {
openstudio::path newfilename
= toPath(t_filename.stem().string() + toPath("-" + boost::lexical_cast<std::string>(existingcount)).string() + t_filename.extension().string());
// Make sure both the newly generated file name and the passed in file name are tracked for counting purposes
m_filenames.insert(newfilename);
m_filenames.insert(t_filename);
m_url_map[t_url] = newfilename;
return newfilename;
}
}
void saveModelTempDir(const openstudio::path& modelTempDir, const openstudio::path& osmPath)
{
bool test = true;
// must remove file, QFile::copy does not overwrite
QFileInfo osmInfo(toQString(osmPath));
if (osmInfo.exists() && osmInfo.isFile()){
test = QFile::remove(toQString(osmPath));
if (!test){
LOG_FREE(Error, "saveModelTempDir", "Could not remove previous osm at '" << toString(osmPath) << "'");
}
}
// copy osm file
openstudio::path srcPath = modelTempDir / toPath("in.osm");
test = QFile::copy(toQString(srcPath), toQString(osmPath));
if (!test){
LOG_FREE(Error, "saveModelTempDir", "Could not copy osm from '" << toString(srcPath) << "' to '" << toString(osmPath) << "'");
}
if( QFileInfo(toQString(osmPath)).exists() ) {
// copy resources
openstudio::path srcDir = modelTempDir / toPath("resources");
openstudio::path dstDir = osmPath.parent_path() / osmPath.stem();
openstudio::path srcproject = srcDir / toPath("project.osp");
openstudio::path destproject = dstDir / toPath("project.osp");
// LOG_FREE(Debug, "saveModelTempDir", "copying project file: " << toString(srcproject) << " to " << toString(destproject));
// QFile::copy(toQString(srcproject), toQString(destproject));
LOG_FREE(Debug, "saveModelTempDir", "Copying " << toString(srcDir) << " to " << toString(dstDir));
test = copyDir(toQString(srcDir), toQString(dstDir));
if (!test){
LOG_FREE(Error, "saveModelTempDir", "Could not copy '" << toString(srcDir) << "' to '" << toString(dstDir) << "'");
}
// TODO: Open all osps just copied over to make the stored paths look reasonable.
}
}
ScriptsVectorController::ScriptsVectorController(const openstudio::path &t_path,
const std::shared_ptr<QFileSystemWatcher> &t_fswatcher)
: m_path(t_path), m_fswatcher(t_fswatcher)
{
connect(m_fswatcher.get(), &QFileSystemWatcher::directoryChanged, this, &ScriptsVectorController::directoryChanged);
if (boost::filesystem::exists(t_path))
{
m_fswatcher->addPath(openstudio::toQString(t_path));
}
if (boost::filesystem::exists(t_path.parent_path()))
{
m_fswatcher->addPath(openstudio::toQString(t_path.parent_path()));
}
directoryChanged(openstudio::toQString(m_path));
LOG(Debug, "Created ScriptVectorController " << m_path);
}
FileInfo FileInfo::complete(const openstudio::path &t_basePath) const
{
if (t_basePath.empty() || fullPath.empty())
{
return *this;
} else {
FileInfo fi = *this;
fi.fullPath = boost::filesystem::complete(fullPath, t_basePath);
return fi;
}
}
void MainWindow::queueSimulation(const openstudio::path &t_input, const openstudio::path &t_epw)
{
try {
// Build list of jobs to create
std::string jobsstring = toString(ui.cbWorkflow->currentText());
if (jobsstring == "<Custom>")
{
openstudio::path expecteddb = t_input.parent_path() / t_input.stem() / openstudio::toPath("run.db");
if (!boost::filesystem::exists(expecteddb))
{
QMessageBox::critical(this, "Unable to launch job", "Db containing custom workflow for OpenStudio UI created OSM not found at the expected location: " + openstudio::toQString(expecteddb));
} else {
try {
m_runmanager.loadJobs(expecteddb);
statusBar()->showMessage("Job Queued - " + openstudio::toQString(t_input));
} catch (const std::exception &e) {
QMessageBox::critical(this, "Unable to launch job", e.what());
}
}
} else {
// parse the string list with the workflow constructor
openstudio::runmanager::Workflow workflow(jobsstring);
// Build list of tools
openstudio::runmanager::Tools tools;
ConfigOptions co = m_runmanager.getConfigOptions();
tools.append(co.getTools());
workflow.add(tools);
workflow.setInputFiles(t_input, t_epw);
openstudio::runmanager::Job job = workflow.create(getOutDir(t_input, workflow, jobsstring, co.getSimpleName()));
m_runmanager.enqueue(job, false);
statusBar()->showMessage("Job Queued - " + openstudio::toQString(job.description()));
}
} catch (const std::exception &e) {
QMessageBox::critical(this, "Unable to launch job", e.what());
}
}
bool ForwardTranslator::modelToSDD(const openstudio::model::Model& model, const openstudio::path& path, ProgressBar* progressBar)
{
m_progressBar = progressBar;
m_translatedObjects.clear();
m_ignoreTypes.clear();
m_ignoreObjects.clear();
m_logSink.setThreadId(QThread::currentThread());
m_logSink.resetStringStream();
model::Model modelCopy = model.clone().cast<model::Model>();
// remove unused resource objects
modelCopy.purgeUnusedResourceObjects();
boost::optional<QDomDocument> doc = this->translateModel(modelCopy);
logUntranslatedObjects(modelCopy);
if (!doc){
return false;
}
if (exists(path)){
remove(path);
}
if (!exists(path.parent_path())){
create_directory(path.parent_path());
}
QFile file(toQString(path));
if (file.open(QFile::WriteOnly)){
QTextStream textStream(&file);
textStream.setCodec("UTF-8");
textStream << doc->toString(2);
file.close();
return true;
}
return false;
}
void ScriptFolderListView::addScriptToFolder(const openstudio::path &t_path, const openstudio::path& folder_name)
{
openstudio::path folder = m_rootPath / folder_name;
boost::filesystem::create_directories(folder);
openstudio::path filename = folder / t_path.filename();
filename = iterateFileName(filename);
boost::filesystem::copy_file(t_path, filename, boost::filesystem::copy_option::overwrite_if_exists);
ScriptsListView *lv = m_scriptsListViews[folder];
if (lv)
{
lv->updateData();
}
}
bool FileReference::makePathRelative(const openstudio::path& basePath) {
openstudio::path newPath;
if (basePath.empty()) {
newPath = path().filename();
}
else {
newPath = relativePath(path(),basePath);
}
if (newPath.empty()) {
return false;
}
m_path = newPath;
m_versionUUID = createUUID();
return true;
}
bool WeatherFile_Impl::makeUrlRelative(const openstudio::path& basePath) {
boost::optional<openstudio::path> currentPath = this->path();
if (currentPath){
openstudio::path newPath;
if (basePath.empty()) {
newPath = toPath(currentPath->filename());
} else {
newPath = relativePath(*currentPath,basePath);
}
if (!newPath.empty()) {
std::string weatherFileUrl = toString(toURL(newPath));
LOG(Debug,"Setting weather file url to " << weatherFileUrl);
return setString(OS_WeatherFileFields::Url,weatherFileUrl);
}
}
return false;
}
std::vector<openstudio::path> ProjectVersioningFixture::projectDatabasePaths(
openstudio::path basePath)
{
std::vector<openstudio::path> result;
if (basePath.empty()) {
basePath = toPath("ProjectVersioningFixtureData") / toPath(toString(uuid));
}
for (boost::filesystem::directory_iterator it(basePath), itend; it != itend; ++it)
{
if (getFileExtension(it->path()) == "osp") {
result.push_back(it->path());
}
}
return result;
}
FileReference::FileReference(const openstudio::path& p)
: m_uuid(createUUID()),
m_versionUUID(createUUID()),
m_name(toString(p)),
m_displayName(toString(p.filename())),
m_path(completeAndNormalize(p)),
m_timestampLast(),
m_checksumCreate(checksum(m_path)),
m_checksumLast(m_checksumCreate)
{
try {
m_fileType = FileReferenceType(getFileExtension(p));
}
catch (...) {
m_fileType = FileReferenceType::Unknown;
}
update(openstudio::path());
}
boost::optional<openstudio::path> WorkflowJSON_Impl::findFile(const openstudio::path& file) const
{
// if absolute check if exists
if (file.is_absolute()){
if (boost::filesystem::exists(file)){
return file;
}
// absolute path does not exist
return boost::none;
}
for (const auto& path : absoluteFilePaths()){
openstudio::path p = path / file;
if (boost::filesystem::exists(p) && boost::filesystem::is_regular_file(p)){
return canonicalOrAbsolute(p);
}
}
return boost::none;
}
boost::optional<openstudio::path> WorkflowJSON_Impl::findMeasure(const openstudio::path& measureDir) const
{
// if absolute check if exists
if (measureDir.is_absolute()){
if (boost::filesystem::exists(measureDir)){
return measureDir;
}
// absolute path does not exist
return boost::none;
}
for (const auto& path : absoluteMeasurePaths()){
openstudio::path p = path / measureDir;
if (boost::filesystem::exists(p) && boost::filesystem::is_directory(p)){
return canonicalOrAbsolute(p);
}
}
return boost::none;
}
bool FileReference::makePathAbsolute(const openstudio::path& searchDirectory) {
// trivial completion
openstudio::path currentPath = path();
if (currentPath.is_complete() && openstudio::filesystem::exists(currentPath)) {
return true;
}
openstudio::path workingPath(currentPath);
// if currentPath is complete but does not exist, go to extreme measures
if (currentPath.is_complete()) {
workingPath = currentPath.filename();
}
if (searchDirectory.empty()) {
return false;
}
openstudio::path newPath = openstudio::filesystem::complete(workingPath,searchDirectory);
if (newPath.empty() || !openstudio::filesystem::exists(newPath)) {
return false;
}
m_path = completeAndNormalize(newPath);
m_versionUUID = createUUID();
return true;
}
void FileInfo::addRequiredFile(const openstudio::path &t_location)
{
addRequiredFile(QUrl::fromLocalFile(toQString(t_location.native_file_string())));
}
OSItemId scriptToItemId(const openstudio::path &t_path)
{
return OSItemId(openstudio::toQString(t_path), openstudio::toQString(t_path.parent_path().filename()), false, "");
}
bool AnalysisDriverTestLibrarySingleton::pathStemEquals(const openstudio::path& p, const std::string& str) {
return (toString(p.stem()) == str);
}
