TYCalculManager.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <qcursor.h>
#include <qmessagebox.h>
#include <QTemporaryFile>
 
#include "Tympan/core/config.h"
#include "Tympan/core/chrono.h"
#include "Tympan/core/defines.h"
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/models/business/xml_project_util.h"
#include "Tympan/models/business/subprocess_util.h"
#include "Tympan/gui/app/os.h"
#include "Tympan/gui/app/TYApplication.h"
#include "Tympan/gui/app/TYProjetFrame.h"
#include "Tympan/gui/app/TYSiteFrame.h"
#include "Tympan/gui/app/TYModelerFrame.h"
#include "Tympan/gui/app/TYSiteModelerFrame.h"
#include "Tympan/gui/app/TYMessageManager.h"
#include "Tympan/gui/app/TYMainWindow.h"
#include "TYCalculManager.h"
 
#define TR(id) OLocalizator::getString("TYCalculManager", (id))
 
// using namespace tympan;
 
TYCalculManager::TYCalculManager()
{
    _pCurrentCalcul = NULL;
}
 
TYCalculManager::~TYCalculManager()
{
    _pCurrentCalcul = NULL;
}
 
void TYCalculManager::setCurrent(LPTYCalcul pCalcul)
{
    _pCurrentCalcul = pCalcul;
}
 
bool TYCalculManager::launchCurrent()
{
    return launch(_pCurrentCalcul);
}
 
bool TYCalculManager::launch(LPTYCalcul pCalcul)
{
    if (!pCalcul)
    {
        return false;
    }
 
    if (pCalcul->getState() == TYCalcul::Locked)
    {
        OMessageManager::get()->info("+++ UN RESULTAT MESURE NE PEUX FAIRE L'OBJET D'UN CALCUL +++");
        return true; // Si le calcul est bloque, il ne peut etre execute
    }
    // Keep track of old objects in order to clean them at best
    // Issue #226
    LPTYProjet oldProjet = pCalcul->getProjet();
    LPTYSiteNode oldSite = oldProjet->getSite();
    LPTYCalcul oldCalcul = oldProjet->getCurrentCalcul();
 
    TYProjet* pProject = pCalcul->getProjet();
 
    // Clear "calcul" result data before computing (avoid problems when removing some elements)
    pCalcul->clearResult();
 
    OMessageManager& logger = *OMessageManager::get();
 
    // Is the debug option "TYMPAN_DEBUG=keep_tmp_files" enabled?
    bool keep_tmp_files = must_keep_tmp_files();
    // Temporary XML files to give the current acoustic problem to the python
    // script and get the results
    QTemporaryFile problemfile;
    problemfile.setFileTemplate(QDir::tempPath() + QString("/XXXXXX.xml"));
    QTemporaryFile resultfile;
    resultfile.setFileTemplate(QDir::tempPath() + QString("/XXXXXX.xml"));
 
    QFileInfo fileInfo(getTYApp()->getCurrentFileName());
    QString meshFilePath =
        fileInfo.path().replace("\\", "/") + "/" + fileInfo.completeBaseName() + "." + "ply";
 
    if (!init_tmp_file(problemfile, keep_tmp_files) || !init_tmp_file(resultfile, keep_tmp_files))
    {
        logger.error(
            "Creation de fichier temporaire impossible. Veuillez verifier l'espace disque disponible.");
        return false;
    }
    // Serialize current project
    try
    {
        tympan::save_project(problemfile.fileName().toUtf8().data(), pProject);
    }
    catch (const tympan::invalid_data& exc)
    {
        std::ostringstream msg;
        msg << boost::diagnostic_information(exc);
        logger.error("Could not export current project. Computation won't be done");
        logger.debug(msg.str().c_str());
        return false;
    }
    if (keep_tmp_files)
    {
        logger.debug("Le calcul va s'executer en mode debug.\nLes fichiers temporaires ne seront pas "
                     "supprimes une fois le calcul termine.\nProjet courant non calcule: %s. Projet avec les "
                     "resultats du calcul: %s.",
                     problemfile.fileName().toStdString().c_str(),
                     resultfile.fileName().toStdString().c_str());
    }
 
    // Call python script "solve_tympan_project.py" with: the name of the file
    // containing the problem, the name of the file where to record
    // the result and the directory containing the solver plugin to use
    // to solve the acoustic problem
    QStringList args;
    QString absolute_plugins_path(QCoreApplication::applicationDirPath());
    absolute_plugins_path.append("/");
    absolute_plugins_path.append(PLUGINS_PATH);
    QString absolute_pyscript_path(QCoreApplication::applicationDirPath());
    absolute_pyscript_path.append("/");
    absolute_pyscript_path.append(SOLVE_PYSCRIPT);
    args << absolute_pyscript_path << problemfile.fileName() << resultfile.fileName() << meshFilePath
         << absolute_plugins_path;
 
    // Altimetry parameters
 
    QString parameters = pCalcul->solverParams;
    QRegularExpression altimetry_size_criterion_reg("(MeshElementSizeMax\\s?=\\s?)([0-9]+.[0-9]*)");
    QRegularExpression altimetry_refine_mesh_reg("(RefineMesh\\s?=\\s?)(True|False)");
    QRegularExpression altimetry_use_volumes_landtakes_reg("(UseVolumesLandtake\\s?=\\s?)(True|False)");
    QRegularExpressionMatch match_size = altimetry_size_criterion_reg.match(parameters);
    QRegularExpressionMatch match_refi = altimetry_refine_mesh_reg.match(parameters);
    QRegularExpressionMatch match_land = altimetry_use_volumes_landtakes_reg.match(parameters);
 
    bool altiIsOK = oldSite->getAltimetry()->isUpToDate();
 
    if (match_size.hasMatch() && match_refi.hasMatch() && match_land.hasMatch())
    {
        QString altimetry_size_criterion = match_size.captured(2);
        QString altimetry_refine_mesh = match_refi.captured(2);
        QString altimetry_use_volumes_landtakes = match_land.captured(2);
        QString altimetry_update = (altiIsOK) ? QString("False") : QString("True");
 
        args << altimetry_size_criterion << altimetry_refine_mesh << altimetry_use_volumes_landtakes
             << altimetry_update;
    }
    logger.info(TR("id_msg_go_calcul"));
 
    if (!python_gui(args))
    {
        return false;
    }
    // Then read the result to update the internal model
    LPTYProjet result;
    try
    {
        // Before loading result project, set current working directory of the application to working
        // directory to ensure correct loading of topographic file.
        TYApplication::setCurrentQtDir();
        result = tympan::load_project(resultfile.fileName().toUtf8().data());
    }
    catch (const tympan::invalid_data& exc)
    {
        std::ostringstream msg;
        msg << boost::diagnostic_information(exc);
        logger.error("Could not import computed project. No results available.");
        logger.debug(msg.str().c_str());
        QMessageBox msgBox;
        msgBox.setText("Le fichier de resultats n'a pas pu etre lu.");
        msgBox.exec();
        return false;
    }
    // Update the current project with the results of the current acoustic
    // problem
    pProject = result.getRealPointer();
    pCalcul = pProject->getCurrentCalcul();
    getTYApp()->setCurProjet(result);
    getTYMainWnd()->getProjetFrame()->setProjet(pProject);
    // Update site altimetry with the mesh retrieved from the ply file
    LPTYSiteNode pSite = pProject->getSite();
    std::deque<OPoint3D> points;
    std::deque<OTriangle> triangles;
    std::deque<LPTYSol> materials;
    pSite->readMesh(points, triangles, materials, meshFilePath);
    pSite->setMeshFilePath(meshFilePath);
    pSite->getAltimetry()->plugBackTriangulation(points, triangles, materials);
    // If altimetry was already up to date, it is loaded from .ply
    if (!altiIsOK)
    {
        // One global altimetry update for all the sites
        pSite->updateAltimetrie(meshFilePath);
    }
    pSite->getAltimetry()->setIsUpToDate(true);
    pSite->updateAltiInfra();
    pSite->updateAcoustique();
    pProject->updateAltiRecepteurs();
    // Update graphics
    pCalcul->getParent()->updateGraphicTree();
    pCalcul->updateGraphicTree();
 
    // Update modeler frames after computation
    getTYMainWnd()->updateModelersAfterComputation(result);
 
    // Clean at best old project, site and calcul by removing references on them
    oldCalcul->setSite(NULL);
    oldSite->setProjet(NULL);
    oldProjet->remAllCalcul();
    oldProjet->remAllMaillage();
    oldProjet->remAllPointControl();
    oldProjet->unsetSite();
 
    getTYMainWnd()->updateModelers(false, false);
    TYElement::setIsSavedOk(true);
    // Update projet frame
    getTYMainWnd()->getProjetFrame()->setCalculDone(true);
    // Reset ActionManager
    // TODO Reset ActionManager for all modelers
    if (getTYMainWnd()->getCurrentModeler())
        getTYMainWnd()->getCurrentModeler()->getActionManager()->reset();
    // Computation achieved with success
    logger.info(TR("id_msg_calcul_done"));
    return true;
}
 
void TYCalculManager::launchAltiComputation(LPTYSiteNode pRootSite)
{
    if (!pRootSite)
    {
        return;
    }
 
    TYApplication::setOverrideCursor(Qt::WaitCursor);
 
    writeOutputMsg(TR("id_msg_calculalti"));
 
    QFileInfo fileInfo(getTYApp()->getCurrentFileName());
    QString resultMeshFilePath =
        fileInfo.path().replace("\\", "/") + "/" + fileInfo.completeBaseName() + "." + "ply";
    TYApplication::setCurrentQtDir();
    pRootSite->updateAltimetrie(resultMeshFilePath);
    // Check altimetry update went well before using it
    if (pRootSite->getAltimetry()->containsData())
    {
        // This method uses the altimetry above-computed to update the infrastructure
        // as well as the receptors and sources and recurses on the current site and
        // all its subsites
        pRootSite->update();
        LPTYProjet pProjet = pRootSite->getProjet();
        if (pProjet)
        {
            writeOutputMsg(TR("id_msg_updatealtimaillages"));
            pProjet->updateAltiRecepteurs();
        }
        pRootSite->getAltimetry()->setIsUpToDate(true);
        getTYMainWnd()->updateModelers();
    }
 
    pRootSite->updateGraphicTree();
    TYApplication::restoreOverrideCursor();
}
 
bool TYCalculManager::askForResetResultat()
{
    bool ret = true;
    TYCalcul* pCalcul = NULL;
    TYProjet* pProjet = getTYApp()->getCurProjet().getRealPointer();
    if (pProjet)
    {
        pCalcul = pProjet->getCurrentCalcul();
    }
    else
    {
        return true;
    }
 
    if (pCalcul)
    {
        ret = true;
        getTYMainWnd()->getProjetFrame()->setCalculDone(false);
 
        /*// Question
        int del = QMessageBox::Yes;
        if (pCalcul->getIsAcousticModified())
        {
            del = QMessageBox::warning(getTYMainWnd(), getTYMainWnd()->windowTitle(),
        TR("id_msg_del_resultat"), QMessageBox::Yes, QMessageBox::No);
        }
        if (del == QMessageBox::Yes)
        {
            // Ok pour effacer les resultats (uniquement si c'est un resultat calcule);
            if (pCalcul->getState() == TYCalcul::Actif)
            {
            // Reset du resultat
            pCalcul->getResultat()->purge();
            for (unsigned int i=0 ; i<pProjet->getPointsControl().size() ; i++)
            {
                pProjet->getPointsControl()[i]->purge(pCalcul);
            }
 
                pCalcul->setIsAcousticModified(false); // La calcul est a jour
            }
 
            ret = true;
        }
        else
        {
            ret = false;
        }*/
    }
 
    return ret;
}
 
bool TYCalculManager::updateAcoustic(TYElement* pElement)
{
    bool ret = false;
    TYSiteNode* pSite = dynamic_cast<TYSiteNode*>(pElement);
    if (pSite != nullptr)
    {
        pSite->updateAcoustique();
    }
    LPTYAcousticVolumeNode pAccVolNode = dynamic_cast<TYAcousticVolumeNode*>(pElement);
    if (pAccVolNode._pObj != nullptr)
    {
        TYMessageManager::get()->info(TR("id_msg_go_updateacoustic"));
 
        TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
        // Calcul acoustique
        ret = pAccVolNode->updateAcoustic();
 
        if (ret)
        {
            TYMessageManager::get()->info(TR("id_msg_updateacoustic_done"));
        }
        else
        {
            TYMessageManager::get()->info(TR("id_msg_updateacoustic_failed"));
        }
 
        // MaJ graphique
        pAccVolNode->getGraphicObject()->update(true);
        getTYMainWnd()->updateModelers(false, false);
 
        TYApplication::restoreOverrideCursor();
    }
    else
    {
        LPTYAcousticLine pLine = dynamic_cast<TYAcousticLine*>(pElement);
        if (pLine._pObj != nullptr)
        {
            TYMessageManager::get()->info(TR("id_msg_go_updateacoustic"));
 
            TYApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
            // Calcul acoustique
            ret = pLine->updateAcoustic();
 
            if (ret)
            {
                TYMessageManager::get()->info(TR("id_msg_updateacoustic_done"));
            }
            else
            {
                TYMessageManager::get()->info(TR("id_msg_updateacoustic_failed"));
            }
 
            // MaJ graphique
            pLine->getGraphicObject()->update(true);
            getTYMainWnd()->updateModelers(false, false);
 
            TYApplication::restoreOverrideCursor();
        }
    }
 
    return ret;
}