TYEtage.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 <vector>
 
#include "Tympan/core/defines.h"
#include "Tympan/core/logging.h"
#include "Tympan/models/common/3d.h"
#include "Tympan/models/common/atmospheric_conditions.h"
 
#include "Tympan/models/business/TYPreferenceManager.h"
#if TY_USE_IHM
    #include "Tympan/gui/widgets/TYEtageWidget.h"
    #include "Tympan/gui/gl/TYEtageGraphic.h"
#endif
#include "TYEtage.h"
 
#include <math.h>
 
TY_EXTENSION_INST(TYEtage);
TY_EXT_GRAPHIC_INST(TYEtage);
 
TYEtage::TYEtage() : _closed(false), _surfAbsorbante(0.0), _volumeLibre(0.0)
{
    _name = TYNameManager::get()->generateName(getClassName());
 
    _bPourCalculTrajet = false;
#if TY_USE_IHM
    if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "UseNewAlgoGeom"))
    {
        _bPourCalculTrajet = TYPreferenceManager::getBool(TYDIRPREFERENCEMANAGER, "UseNewAlgoGeom");
    }
    else
    {
        TYPreferenceManager::setBool(TYDIRPREFERENCEMANAGER, "UseNewAlgoGeom", _bPourCalculTrajet);
    }
#endif
 
    _pSol = new TYDalle();
    _pSol->setParent(this);
 
    // Floor does not radiate by default
    _pSol->setDensiteSrcs(0.0);
    _pSol->setIsRayonnant(false, false);
 
    _pParoi = new TYParoi();
 
    _pPlafond = new TYDalle();
    _pPlafond->setParent(this);
 
    _absoSabine = OSpectre::getEmptyLinSpectre();
 
    // Add an entry in the table associating the regimes
    TYMapPtrElementInt mapElmRegime;
    _tabRegimesMachines.push_back(mapElmRegime);
 
    TYMapPtrElementBool mapElmEtat;
    _tabEtatMachines.push_back(mapElmEtat);
 
    _volEnglob = volEnglob(); // (re)calculate the enclosing volume
}
 
TYEtage::~TYEtage() {}
 
TYEtage::TYEtage(const TYEtage& other)
{
    *this = other;
}
 
TYEtage& TYEtage::operator=(const TYEtage& other)
{
    TYAcousticVolume::operator=(other);
    _bPourCalculTrajet = other._bPourCalculTrajet;
    _closed = other._closed;
    _pParoi = other._pParoi;
    _tabMur = other._tabMur;
    _pSol = other._pSol;
    _pPlafond = other._pPlafond;
    _tabSources = other._tabSources;
    _tabMachine = other._tabMachine;
    _volEnglob = other._volEnglob;
 
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
 
    return *this;
}
 
bool TYEtage::operator==(const TYEtage& other) const
{
    if (this != &other)
    {
        if (TYAcousticVolume::operator!=(other))
        {
            return false;
        }
        if (_bPourCalculTrajet != (other._bPourCalculTrajet))
        {
            return false;
        }
        if (_closed != other._closed)
        {
            return false;
        }
        if (_pParoi != other._pParoi)
        {
            return false;
        }
        if (!(_tabMur == other._tabMur))
        {
            return false;
        }
        if (_pSol != other._pSol)
        {
            return false;
        }
        if (_pPlafond != other._pPlafond)
        {
            return false;
        }
        if (_tabSources != other._tabSources)
        {
            return false;
        }
        if (_tabMachine != other._tabMachine)
        {
            return false;
        }
    }
    return true;
}
 
bool TYEtage::operator!=(const TYEtage& other) const
{
    return !operator==(other);
}
 
bool TYEtage::deepCopy(const TYElement* pOther, bool copyId /*=true*/, bool pUseCopyTag /*=false*/)
{
    if (!TYAcousticVolume::deepCopy(pOther, copyId))
    {
        return false;
    }
 
    TYEtage* pOtherEtage = (TYEtage*)pOther;
 
    _bPourCalculTrajet = pOtherEtage->_bPourCalculTrajet;
    _closed = pOtherEtage->_closed;
 
    _pParoi->deepCopy(pOtherEtage->_pParoi, copyId);
 
    _pSol->deepCopy(pOtherEtage->_pSol, copyId);
    _pSol->setParent(this);
    _pPlafond->deepCopy(pOtherEtage->_pPlafond, copyId);
    _pPlafond->setParent(this);
 
    _tabMur.clear();
 
    // This map will allow to retrieve the copied machine or ponctual source
    // from the original one
    std::map<TYElement*, TYElement*> elementOriginToDest;
 
    unsigned int i = 0;
    for (i = 0; i < pOtherEtage->_tabMur.size(); i++)
    {
        LPTYMurGeoNode pMurGeoNode = new TYMurGeoNode(NULL, this);
        pMurGeoNode->deepCopy(pOtherEtage->_tabMur[i], copyId);
        pMurGeoNode->getElement()->setParent(this);
        pMurGeoNode->setParent(this);
        _tabMur.push_back(pMurGeoNode);
    }
 
    _tabSources.clear();
    LPTYUserSourcePonctuelle userSourcePontuelleOrigin = nullptr;
    LPTYUserSourcePonctuelle userSourcePontuelleDest = nullptr;
    for (i = 0; i < pOtherEtage->_tabSources.size(); i++)
    {
        LPTYSourcePonctuelleGeoNode pSourceGeoNode = new TYSourcePonctuelleGeoNode(new TYSourcePonctuelle);
        pSourceGeoNode->deepCopy(pOtherEtage->_tabSources[i], copyId);
        pSourceGeoNode->getElement()->setParent(this);
        pSourceGeoNode->setParent(this);
        userSourcePontuelleOrigin =
            TYUserSourcePonctuelle::safeDownCast(pOtherEtage->_tabSources[i]->getElement());
        userSourcePontuelleDest = TYUserSourcePonctuelle::safeDownCast(pSourceGeoNode->getElement());
 
        elementOriginToDest[userSourcePontuelleOrigin] = userSourcePontuelleDest;
        _tabSources.push_back(pSourceGeoNode);
    }
 
    _tabMachine.clear();
    LPTYMachine machineOrigin;
    LPTYMachine machineDest;
    for (i = 0; i < pOtherEtage->_tabMachine.size(); i++)
    {
        LPTYMachineGeoNode pMachineGeoNode = new TYMachineGeoNode(new TYMachine);
        pMachineGeoNode->deepCopy(pOtherEtage->_tabMachine[i], copyId);
        pMachineGeoNode->getElement()->setParent(this);
        pMachineGeoNode->setParent(this);
        machineOrigin = TYMachine::safeDownCast(pOtherEtage->_tabMachine[i]->getElement());
        machineDest = TYMachine::safeDownCast(pMachineGeoNode->getElement());
        elementOriginToDest[machineOrigin] = machineDest;
        _tabMachine.push_back(pMachineGeoNode);
    }
 
    // Build Regime and Etat tables
    int vectorIndex = 0;
    LPTYElement elementOrigin;
    LPTYElement elementDest;
    TYMapPtrElementInt mapSources;
    TYMapPtrElementBool mapEtats;
    _tabRegimesMachines.clear();
    _tabEtatMachines.clear();
 
    for (const auto& myMap : pOtherEtage->_tabRegimesMachines)
    {
        for (const auto& pair : myMap)
        {
            elementOrigin = pair.first;
            int value = pair.second;
            if (elementOrigin)
            {
                elementDest = elementOriginToDest[elementOrigin];
                mapSources[elementDest] = value;
            }
        }
        vectorIndex++;
    }
    _tabRegimesMachines.push_back(mapSources);
 
    vectorIndex = 0;
    for (const auto& myMap : pOtherEtage->_tabEtatMachines)
    {
        for (const auto& pair : myMap)
        {
            elementOrigin = pair.first;
            bool value = pair.second;
 
            if (elementOrigin)
            {
                elementDest = elementOriginToDest[elementOrigin];
                mapEtats[elementDest] = value;
            }
        }
        vectorIndex++;
    }
    _tabEtatMachines.push_back(mapEtats);
 
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
 
    return true;
}
 
std::string TYEtage::toString() const
{
    return "TYEtage";
}
 
DOM_Element TYEtage::toXML(DOM_Element& domElement)
{
    unsigned int i = 0;
 
    DOM_Element domNewElem = TYAcousticVolume::toXML(domElement);
 
    TYXMLTools::addElementIntValue(domNewElem, "closed", _closed);
 
    // Save the default wall of the building
    _pParoi->toXML(domNewElem);
 
    // Save the walls
    DOM_Document domDoc = domElement.ownerDocument();
    DOM_Element listMurNode = domDoc.createElement("ListMur");
    domNewElem.appendChild(listMurNode);
    for (i = 0; i < _tabMur.size(); i++)
    {
        // Add the wall
        _tabMur[i]->toXML(listMurNode);
    }
 
    _pSol->toXML(domNewElem);
    _pPlafond->toXML(domNewElem);
 
    // Save the machines
    DOM_Element listMachineNode = domDoc.createElement("ListMachine");
    domNewElem.appendChild(listMachineNode);
    for (i = 0; i < _tabMachine.size(); i++)
    {
        // Add machine if it is valid (i.e. contains volumes)
        LPTYAcousticVolumeNode pNode = TYAcousticVolumeNode::safeDownCast(_tabMachine[i]->getElement());
 
        if (pNode && pNode->getNbChild() > 0)
        {
            _tabMachine[i]->toXML(listMachineNode);
        }
    }
 
    DOM_Element listSourceNode = domDoc.createElement("ListSource");
    domNewElem.appendChild(listSourceNode);
    for (i = 0; i < _tabSources.size(); i++)
    {
        // Add the source
        _tabSources[i]->toXML(listSourceNode);
    }
 
    // Save the 'Etat' of the machines
    DOM_Element listEtatNode = domDoc.createElement("TabEtatElement");
    domNewElem.appendChild(listEtatNode);
 
    // Pour tous les regimes
    for (i = 0; i < _tabRegimes.size(); i++)
    {
        if (_tabEtatMachines.size() == 0)
        {
            break;
        }
 
        DOM_Element tmpNode = domDoc.createElement("Regime");
        listEtatNode.appendChild(tmpNode);
 
        tmpNode.setAttribute("num", intToStr(i).data());
 
        TYMapPtrElementBool::iterator iter;
        for (iter = _tabEtatMachines[i].begin(); iter != _tabEtatMachines[i].end(); iter++)
        {
            DOM_Element itemNode = domDoc.createElement("Element");
            tmpNode.appendChild(itemNode);
            itemNode.setAttribute("accVolNodeId", (*iter).first->getID().toString());
            itemNode.setAttribute("state", intToStr((*iter).second).c_str());
        }
    }
 
    // Save 'Regime' of the machines
    DOM_Element listRegimeNode = domDoc.createElement("TabRegimeElement");
    domNewElem.appendChild(listRegimeNode);
 
    // For all 'Regimes'
    for (i = 0; i < _tabRegimes.size(); i++)
    {
        if (_tabRegimesMachines.size() == 0)
        {
            break;
        }
 
        DOM_Element tmpNode = domDoc.createElement("Regime");
        listRegimeNode.appendChild(tmpNode);
 
        tmpNode.setAttribute("num", intToStr(i).data());
 
        TYMapPtrElementInt::iterator iter;
        for (iter = _tabRegimesMachines[i].begin(); iter != _tabRegimesMachines[i].end(); iter++)
        {
            DOM_Element itemNode = domDoc.createElement("Element");
            tmpNode.appendChild(itemNode);
            itemNode.setAttribute("accVolNodeId", (*iter).first->getID().toString());
            itemNode.setAttribute("regime", intToStr((*iter).second).c_str());
        }
    }
 
    return domNewElem;
}
 
int TYEtage::fromXML(DOM_Element domElement)
{
    TYAcousticVolume::fromXML(domElement);
 
    // Reset
    _tabMur.clear();
    _tabSources.clear();
    _tabMachine.clear();
    _tabRegimesMachines.clear();
    _tabEtatMachines.clear();
 
    bool closedOk = false;
    bool solFound = false;
    bool plafondFound = false;
    bool tabEtatElemFound = false;
    bool tabRegimeElemFound = false;
 
    LPTYMurGeoNode pMurGeoNode = new TYMurGeoNode(new TYMur, this);
    LPTYSourcePonctuelleGeoNode pSourceGeoNode = new TYSourcePonctuelleGeoNode(new TYSourcePonctuelle);
    LPTYMachineGeoNode pMachineGeoNode = new TYMachineGeoNode(new TYMachine, this);
    int retVal = -1;
    unsigned int i = 0, j = 0;
    DOM_Element elemCur;
 
    // Create a list of duplicates and a flag to detect duplicate (fix bug 0006019)
    std::map<TYUUID, TYUUID> mapDoublons;
    // Flag of existence of duplicate
    bool bDoublon = false;
 
    QDomNodeList childs = domElement.childNodes();
    for (i = 0; i < childs.length(); i++)
    {
        elemCur = childs.item(i).toElement();
        TYXMLTools::getElementBoolValue(elemCur, "closed", _closed, closedOk);
 
        _pParoi->callFromXMLIfEqual(elemCur);
 
        if (elemCur.nodeName() == "ListMur")
        {
            DOM_Element elemCur2;
            QDomNodeList childs2 = elemCur.childNodes();
 
            for (j = 0; j < childs2.length(); j++)
            {
                elemCur2 = childs2.item(j).toElement();
                if (pMurGeoNode->callFromXMLIfEqual(elemCur2, &retVal))
                {
                    if (retVal == 1)
                    {
                        _tabMur.push_back(pMurGeoNode);
                        pMurGeoNode = new TYMurGeoNode(NULL, this);
                    }
                }
            }
        }
 
        if (!solFound)
        {
            solFound = _pSol->callFromXMLIfEqual(elemCur);
        }
        else if (!plafondFound)
        {
            plafondFound = _pPlafond->callFromXMLIfEqual(elemCur);
        }
 
        if (elemCur.nodeName() == "ListMachine")
        {
            DOM_Element elemCur2;
            QDomNodeList childs2 = elemCur.childNodes();
 
            // Case of 'Batiment' holding machines, in order to preserve the link between 'Regime' 'Batiment'
            // and 'Regime' 'Machine'
            bool bBak = TYElement::getRegenerateID();
            TYElement::setRegenerateID(false);
 
            for (j = 0; j < childs2.length(); j++)
            {
                elemCur2 = childs2.item(j).toElement();
 
                if (pMachineGeoNode->callFromXMLIfEqual(elemCur2, &retVal))
                {
                    if (retVal == 1)
                    {
                        // Check the possible existence of a duplicate Id
                        TYElement* pElem = pMachineGeoNode->getElement();
                        TYUUID idOld = pElem->getID();
                        if (TYElement::testId(idOld, pElem))
                        {
                            // Change the Id of the element
                            pElem->regenerateID();
                            TYUUID idNew = pElem->getID();
                            // Add to the list of duplicates
                            mapDoublons[idOld] = idNew;
                            // Duplicate detected
                            bDoublon = true;
                        }
                        _tabMachine.push_back(pMachineGeoNode);
                        pMachineGeoNode = new TYMachineGeoNode(NULL, this);
                    }
                }
            }
 
            // Restoration of the previous state of ID regeneration
            TYElement::setRegenerateID(bBak);
        }
 
        if (elemCur.nodeName() == "ListSource")
        {
            DOM_Element elemCur2;
            QDomNodeList childs2 = elemCur.childNodes();
 
            // Case of 'Batiment' holding machines, in order to preserve the link between 'Regime' 'Batiment'
            // and 'Regime' 'Machine'
            bool bBak = TYElement::getRegenerateID();
            TYElement::setRegenerateID(false);
 
            for (j = 0; j < childs2.length(); j++)
            {
                elemCur2 = childs2.item(j).toElement();
 
                if (pSourceGeoNode->callFromXMLIfEqual(elemCur2, &retVal))
                {
                    if (retVal == 1)
                    {
                        // If file 3.1, need to convert TYSourcePonctuelle into TYUserSourcePonctuelle
                        if (pSourceGeoNode->getElement()->isA("TYSourcePonctuelle"))
                        {
                            TYSourcePonctuelle* pSP =
                                TYSourcePonctuelle::safeDownCast(pSourceGeoNode->getElement());
                            TYUserSourcePonctuelle* pUSP = new TYUserSourcePonctuelle(pSP);
                            pSourceGeoNode->setElement((TYElement*)pUSP);
                        }
 
                        // Check the possible existence of a duplicate Id
                        TYElement* pElem = pSourceGeoNode->getElement();
                        TYUUID idOld = pElem->getID();
                        if (TYElement::testId(idOld, pElem))
                        {
                            // Change the Id of the element
                            pElem->regenerateID();
                            TYUUID idNew = pElem->getID();
                            // Add to the list of duplicates
                            mapDoublons[idOld] = idNew;
                            // Duplicate detected
                            bDoublon = true;
                        }
 
                        pSourceGeoNode->getElement()->setParent(this);
                        _tabSources.push_back(pSourceGeoNode);
                        pSourceGeoNode = new TYUserSourcePonctuelleGeoNode(NULL, this);
                    }
                }
            }
 
            // Restoration of the previous state of ID regeneration
            TYElement::setRegenerateID(bBak);
        }
 
        if (elemCur.nodeName() == "TabEtatElement")
        {
            tabEtatElemFound = true;
            DOM_Element elemCur3;
            QDomNodeList childs3 = elemCur.childNodes();
            // Loop on the 'Regimes' of the 'Etage'
            for (j = 0; j < childs3.length(); j++)
            {
                elemCur3 = childs3.item(j).toElement();
                int regimeEtage = 0;
                bool regimeMachineOk = false;
 
                if (elemCur3.nodeName() == "Regime")
                {
                    TYMapPtrElementBool mapEtatRegime;
 
                    // Read again the number of the 'Regime'
                    TYXMLTools::getElementIntValue(elemCur3, "num", regimeEtage, regimeMachineOk);
 
                    DOM_Element elemCur4;
 
                    QDomNodeList childs4 = elemCur3.childNodes();
 
                    // Loop on all the elements
                    for (unsigned int k = 0; k < childs4.length(); k++)
                    {
                        //                        bool idOk = false;
                        //                        bool elemOk = false;
                        QString id, oldId;
                        bool etat = false;
                        elemCur4 = childs4.item(k).toElement();
 
                        if (elemCur4.nodeName() == "Element")
                        {
                            id = TYXMLTools::getElementAttributeToString(elemCur4, "accVolNodeId");
                            oldId = id;
                            etat = TYXMLTools::getElementAttributeToInt(elemCur4, "state");
                        }
 
                        // Get a pointer on the element
                        if (bDoublon) // Substitution in case of a detected duplicate
                        {
                            TYUUID id2 = TYElement::fromString(id);
                            id2 = mapDoublons[id2];
                            id = TYElement::toString(id2);
                        }
 
                        TYElement* pElement = TYElement::getInstance(id); // Try with the id
 
                        if (!pElement)
                        {
                            pElement = TYElement::getInstance(oldId);
                        } // If it works try with old one
 
                        // Add the element to the table of 'Etats'
                        if (pElement)
                        {
                            mapEtatRegime[pElement] = etat;
                        }
                    }
 
                    // Add map of the 'Etats' in the table of the 'Etage'
                    _tabEtatMachines.push_back(mapEtatRegime);
                }
            }
        }
 
        if (elemCur.nodeName() == "TabRegimeElement")
        {
            tabRegimeElemFound = true;
 
            DOM_Element elemCur3;
 
            QDomNodeList childs3 = elemCur.childNodes();
 
            // Loop on the 'Regimes' of the 'Etage'
            for (j = 0; j < childs3.length(); j++)
            {
                elemCur3 = childs3.item(j).toElement();
                int regimeEtage = 0;
                bool regimeMachineOk = false;
                if (elemCur3.nodeName() == "Regime")
                {
                    TYMapPtrElementInt mapRegimeMachine;
 
                    // Read again the number of the 'Regime'
                    TYXMLTools::getElementIntValue(elemCur3, "num", regimeEtage, regimeMachineOk);
 
                    DOM_Element elemCur4;
 
                    QDomNodeList childs4 = elemCur3.childNodes();
                    // Loop on all the elements
                    for (unsigned int k = 0; k < childs4.length(); k++)
                    {
                        elemCur4 = childs4.item(k).toElement();
                        //                        bool idOk = false;
                        //                        bool elemOk = false;
                        QString id, oldId;
                        int regimeMachine = 0;
 
                        if (elemCur4.nodeName() == "Element")
                        {
                            id = TYXMLTools::getElementAttributeToString(elemCur4, "accVolNodeId");
                            oldId = id;
                            regimeMachine = TYXMLTools::getElementAttributeToInt(elemCur4, "regime");
                        }
 
                        // Get a pointer on the element
                        if (bDoublon) // Substitution in case of a detected duplicate
                        {
                            TYUUID id2 = TYElement::fromString(id);
                            id2 = mapDoublons[id2];
                            id = TYElement::toString(id2);
                        }
 
                        TYElement* pElement = TYElement::getInstance(id);
 
                        if (!pElement)
                        {
                            pElement = TYElement::getInstance(oldId);
                        } // If it does not work, try the old one
 
                        // Add the element to the table of the 'Etats'
                        if (pElement)
                        {
                            mapRegimeMachine[pElement] = regimeMachine;
                        }
                    }
 
                    // Add the map of the 'Etats' to the table of the 'Etage'
                    _tabRegimesMachines.push_back(mapRegimeMachine);
                }
            }
        }
    }
 
    if (!(tabEtatElemFound && tabRegimeElemFound)) // Case old file format
    {
        // We start by clearing both arrays in case only one of them was found.
        _tabRegimesMachines.clear();
        _tabEtatMachines.clear();
 
        // Creation d'un map des etats et d'un map des regimes des machines
        // Create a map of the 'Etats' and a map of the 'Regimes' of the 'Machines'
        TYMapPtrElementBool mapEtatRegime;
        TYMapPtrElementInt mapRegimeMachine;
        _tabRegimesMachines.push_back(mapRegimeMachine);
        _tabEtatMachines.push_back(mapEtatRegime);
 
        // Sources (and machines) will be reaffected automatically by function
        // verifTabRegimeSources()
    }
 
    updateSolPlafond();
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
 
    if (_forceNormales)
    {
        inverseNormales();
    }
 
    verifTabRegimeSources();
 
    return 1;
}
 
void TYEtage::verifTabRegimeSources()
{
    bool bFound = false;
 
    for (unsigned int i = 0; i < getNbRegimes(); i++)
    {
        TYMapPtrElementBool& mapEtatRegime = _tabEtatMachines[i];
        TYMapPtrElementInt& mapRegimeMachine = _tabRegimesMachines[i];
 
        for (unsigned int j = 0; j < _tabSources.size(); j++) // For all the sources
        {
            bFound = false;
            TYElement* pElement = _tabSources[j]->getElement();
            TYSource* pSource = dynamic_cast<TYSource*>(pElement);
            if (pSource == nullptr)
            {
                continue;
            }
 
            std::map<TYElement*, bool>::iterator itEtat;
 
            for (itEtat = mapEtatRegime.begin(); itEtat != mapEtatRegime.end(); itEtat++)
            {
                if (itEtat->first == pElement)
                {
                    bFound = true;
                    break;
                }
            }
 
            if (!bFound)
            {
                mapEtatRegime[pElement] = false;
                mapRegimeMachine[pElement] = 0;
            }
        }
 
        for (unsigned int j = 0; j < _tabMachine.size(); j++) // For all the machines
        {
            bFound = false;
            TYElement* pElement = _tabMachine[j]->getElement();
            if (!pElement->isA("TYMachine"))
            {
                continue;
            }
 
            std::map<TYElement*, bool>::iterator itEtat;
 
            for (itEtat = mapEtatRegime.begin(); itEtat != mapEtatRegime.end(); itEtat++)
            {
                if (itEtat->first == pElement)
                {
                    bFound = true;
                    break;
                }
            }
 
            if (!bFound)
            {
                mapEtatRegime[pElement] = false;
                mapRegimeMachine[pElement] = 0;
            }
        }
    }
}
 
void TYEtage::exportCSV(std::ofstream& ofs)
{
    // Export name of the object
    ofs << _name.toStdString() << '\n';
 
    // Export acoustic data
    TYAcousticInterface::exportCSV(ofs);
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYMur* pMur = TYMur::safeDownCast(_tabMur[i]->getElement());
        pMur->exportCSV(ofs);
    }
 
    // Export floor and ceiling
    _pSol->exportCSV(ofs);
    _pPlafond->exportCSV(ofs);
 
    ofs << '\n';
}
 
void TYEtage::getChilds(LPTYElementArray& childs, bool recursif /*=true*/)
{
    TYAcousticVolume::getChilds(childs, recursif);
 
    unsigned int i = 0;
 
    for (i = 0; i < _tabMur.size(); i++)
    {
        childs.push_back(_tabMur[i]->getElement());
    }
 
    childs.push_back(_pSol);
    childs.push_back(_pPlafond);
 
    if (recursif)
    {
        for (i = 0; i < _tabMur.size(); i++)
        {
            _tabMur[i]->getChilds(childs, recursif);
        }
 
        _pSol->getChilds(childs, recursif);
        _pPlafond->getChilds(childs, recursif);
 
        for (i = 0; i < _tabMachine.size(); i++)
        {
            _tabMachine[i]->getChilds(childs, recursif);
        }
 
        for (i = 0; i < _tabSources.size(); i++)
        {
            _tabSources[i]->getChilds(childs, recursif);
        }
    }
}
 
bool TYEtage::addMur(LPTYMur pMur)
{
    assert(pMur);
 
    pMur->setParent(this);
    pMur->setParoi(_pParoi);
 
    _tabMur.push_back(new TYMurGeoNode((LPTYElement)pMur));
 
    updateSolPlafond();
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
 
    return true;
}
 
bool TYEtage::remMur(const LPTYMur pMur)
{
    assert(pMur);
    bool ret = false;
    TYTabMurGeoNode::iterator ite;
 
    for (ite = _tabMur.begin(); ite != _tabMur.end(); ite++)
    {
        if (TYMur::safeDownCast((*ite)->getElement()) == pMur)
        {
            _tabMur.erase(ite);
            ret = true;
            break;
        }
    }
 
    updateSolPlafond();
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
 
    return ret;
}
 
bool TYEtage::remMur(QString idMur)
{
    bool ret = false;
    TYTabMurGeoNode::iterator ite;
 
    for (ite = _tabMur.begin(); ite != _tabMur.end(); ite++)
    {
        if ((*ite)->getElement()->getID().toString() == idMur)
        {
            _tabMur.erase(ite);
            ret = true;
            break;
        }
    }
 
    updateSolPlafond();
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
 
    return ret;
}
 
void TYEtage::remMurs()
{
    _tabMur.clear();
    updateSolPlafond();
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
}
 
bool TYEtage::setMurs(const TYTabPoint& tabPts, double hauteur /*=2.0*/, bool close /*=true*/)
{
    TYPoint pt0, pt1;
    size_t count = tabPts.size();
    ORepere3D repMur;
 
    if ((count == 0) || (hauteur <= 0.0))
    {
        return false;
    }
 
    // Reset
    _tabMur.clear();
 
    // If there are at least 2 'Murs', then the 'Etage' cannot be closed
    if (tabPts.size() > 1)
    {
        // Preserve 'Etat'
        _closed = close;
    }
    else
    {
        _closed = false;
    }
 
    // We test if first and last point coincide with a tolerance
    if (tabPts[0].isEqual(tabPts[count - 1]))
    {
        // We do not reconsider the last point in the iteration
        count -= 1;
    }
    else if (!_closed)
    {
        // Stop before closing walls
        count -= 1;
    }
 
    // A face for each pair of consecutive points
    for (int i = 0; i < count; i++)
    {
        pt1 = tabPts[i];
        pt0 = tabPts[(i + 1) % tabPts.size()];
 
        // Vector for "length" of the face
        OVector3D vec01(pt0, pt1);
 
        // The wall for this face
        LPTYMur pMur = new TYMur();
 
        pMur->setParent(this);
        // Wall dimensions
        pMur->setSize(vec01.norme(), hauteur);
 
        // Wall position
        repMur._origin = OVector3D(pt0) + (vec01 * 0.5);
        repMur._origin._z = hauteur / 2.0;
 
        // Wall orientation
        vec01.normalize();
        repMur._vecI = vec01;
        repMur._vecJ = OVector3D(0.0, 0.0, 1.0);
        repMur._vecK = vec01.cross(repMur._vecJ);
 
        LPTYMurGeoNode pMurGeoNode = new TYMurGeoNode();
        pMurGeoNode->setRepere(repMur);
        pMurGeoNode->setElement((LPTYElement)pMur);
        _tabMur.push_back(pMurGeoNode);
    }
 
    updateSolPlafond();
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
 
    return true;
}
 
TYTabPoint TYEtage::getContour() const
{
    TYTabPoint res;
    size_t nbPts = _tabMur.size();
    size_t i = 0;
 
    if (!nbPts)
    {
        return res;
    }
 
    res.reserve(nbPts);
 
    for (i = 0; i < nbPts; i++)
    {
        // We retrieve the point
        TYPoint pt = TYMur::safeDownCast(_tabMur[i]->getElement())->getBoundingRect()->_pts[2];
 
        // We pass in the coordinate system of the 'Etage'
        pt = _tabMur[i]->getMatrix() * pt;
 
        // Add the point
        res.push_back(pt);
    }
 
    // If the 'Etage' is not closed (Ecran), we add last point manually
    if (!_closed)
    {
        // We retrieve the point
        TYPoint pt = TYMur::safeDownCast(_tabMur[i - 1]->getElement())->getBoundingRect()->_pts[3];
 
        // We pass in the coordinate system of the 'Etage'
        pt = _tabMur[i - 1]->getMatrix() * pt;
 
        // Add the point
        res.push_back(pt);
    }
 
    return res;
}
 
void TYEtage::setHauteur(double hauteur)
{
    size_t nbPts = _tabMur.size();
 
    if (nbPts <= 0)
    {
        return;
    }
 
    for (size_t i = 0; i < nbPts; i++)
    {
        // Apply new height
        TYMur::safeDownCast(_tabMur[i]->getElement())->setSizeY(hauteur);
 
        ORepere3D repere3D = _tabMur[i]->getORepere3D();
        // Set wall center at 1/2 height
        repere3D._origin._z = hauteur / 2.0;
        _tabMur[i]->setRepere(repere3D);
    }
 
    updateSolPlafond();
    _volEnglob = volEnglob();
    calculRayonSphere(_volEnglob);
    calculCentreGravite();
}
 
double TYEtage::getHauteur() const
{
    double res = 0.0;
 
    if (_tabMur.size() > 0)
    {
        res = TYMur::safeDownCast(_tabMur[0]->getElement())->getSizeY();
    }
 
    return res;
}
 
bool TYEtage::addMachine(LPTYMachineGeoNode pMachineGeoNode)
{
    assert(pMachineGeoNode);
 
    TYMachine* pMachine = TYMachine::safeDownCast(pMachineGeoNode->getElement());
 
    assert(pMachine);
 
    pMachineGeoNode->setParent(this);
    pMachine->setParent(this);
 
    _tabMachine.push_back(pMachineGeoNode);
 
    // For all the 'Regimes' of the 'Etage'
    TYElement* pElement = (TYElement*)pMachine;
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        // Add machine into the associative table of the regime
        _tabRegimesMachines[i][pElement] = 0;
 
        // Set the 'Etat' of the machine active for this regime
        _tabEtatMachines[i][pElement] = true;
    }
 
    setIsGeometryModified(true);
 
    return true;
}
 
bool TYEtage::addMachine(LPTYMachine pMachine, const TYRepere& pos)
{
    return addMachine(new TYMachineGeoNode(pos, (LPTYElement)pMachine));
}
 
bool TYEtage::addMachine(LPTYMachine pMachine)
{
    return addMachine(new TYMachineGeoNode((LPTYElement)pMachine));
}
 
bool TYEtage::remMachine(const LPTYMachineGeoNode pMachineGeoNode)
{
    assert(pMachineGeoNode);
    bool ret = false;
    TYTabMachineGeoNode::iterator ite;
 
    for (ite = _tabMachine.begin(); ite != _tabMachine.end(); ite++)
    {
        if ((*ite) == pMachineGeoNode)
        {
            _tabMachine.erase(ite);
            ret = true;
            break;
        }
    }
 
    // For all the regimes of the 'Etage'
    TYElement* pElement = pMachineGeoNode->getElement();
    TYMapPtrElementInt::iterator iter;
    TYMapPtrElementBool::iterator itb;
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        iter = _tabRegimesMachines[i].find(pElement);
        // Delete the machine from the associative table of the regime
        _tabRegimesMachines[i].erase(iter);
 
        itb = _tabEtatMachines[i].find(pElement);
        _tabEtatMachines[i].erase(itb);
    }
 
    setIsGeometryModified(true);
 
    return ret;
}
 
bool TYEtage::remMachine(const LPTYMachine pMachine)
{
    assert(pMachine);
    bool ret = false;
    TYTabMachineGeoNode::iterator ite;
 
    for (ite = _tabMachine.begin(); ite != _tabMachine.end(); ite++)
    {
        if (TYMachine::safeDownCast((*ite)->getElement()) == pMachine)
        {
            _tabMachine.erase(ite);
            ret = true;
            break;
        }
    }
 
    // For all the regimes of the 'Etage'
    TYElement* pElement = (TYElement*)pMachine;
    TYMapPtrElementInt::iterator iter;
    TYMapPtrElementBool::iterator itb;
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        iter = _tabRegimesMachines[i].find(pElement);
        // Delete the machine from the associative table of the regime
        _tabRegimesMachines[i].erase(iter);
 
        itb = _tabEtatMachines[i].find(pElement);
        _tabEtatMachines[i].erase(itb);
    }
 
    setIsGeometryModified(true);
 
    return ret;
}
 
bool TYEtage::remMachine(QString idMachine)
{
    bool ret = false;
    TYTabMachineGeoNode::iterator ite;
 
    for (ite = _tabMachine.begin(); ite != _tabMachine.end(); ite++)
    {
        if ((*ite)->getElement()->getID().toString() == idMachine)
        {
            _tabMachine.erase(ite);
            ret = true;
            break;
        }
    }
 
    // For all the regimes of the 'Etage'
    TYElement* pElement = (*ite)->getElement();
    TYMapPtrElementInt::iterator iter;
    TYMapPtrElementBool::iterator itb;
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        iter = _tabRegimesMachines[i].find(pElement);
        // Delete the machine from the associative table of the regime
        _tabRegimesMachines[i].erase(iter);
 
        itb = _tabEtatMachines[i].find(pElement);
        _tabEtatMachines[i].erase(itb);
    }
    setIsGeometryModified(true);
 
    return ret;
}
 
void TYEtage::remAllMachine()
{
    unsigned int i = 0, j = 0;
 
    TYMapPtrElementInt::iterator iter;
    for (i = 0; i < _tabRegimesMachines.size(); i++)
    {
        for (j = 0; j < _tabMachine.size(); j++)
        {
            TYElement* pElement = _tabMachine[j]->getElement();
            iter = _tabRegimesMachines[i].find(pElement);
            _tabRegimesMachines[i].erase(iter);
        }
    }
 
    TYMapPtrElementBool::iterator itb;
    for (i = 0; i < _tabEtatMachines.size(); i++)
    {
        for (j = 0; j < _tabMachine.size(); j++)
        {
            TYElement* pElement = _tabMachine[j]->getElement();
            itb = _tabEtatMachines[i].find(pElement);
            _tabEtatMachines[i].erase(itb);
        }
    }
 
    _tabMachine.clear();
    setIsGeometryModified(true);
}
 
LPTYMachineGeoNode TYEtage::findMachine(const LPTYMachine pMachine)
{
    assert(pMachine);
    TYTabMachineGeoNode::iterator ite;
 
    for (ite = _tabMachine.begin(); ite != _tabMachine.end(); ite++)
    {
        if (TYMachine::safeDownCast((*ite)->getElement()) == pMachine)
        {
            return (*ite);
        }
    }
 
    return NULL;
}
 
bool TYEtage::addSource(LPTYUserSourcePonctuelleGeoNode pSourceGeoNode)
{
    assert(pSourceGeoNode);
    assert(pSourceGeoNode->getElement());
 
    if (this->isA("TYAcousticCylinder"))
    {
        return false;
    }
 
    pSourceGeoNode->setParent(this);
    pSourceGeoNode->getElement()->setParent(this);
 
    _tabSources.push_back(pSourceGeoNode);
 
    // For all the regimes of the 'Etage'
    TYElement* pElement = pSourceGeoNode->getElement();
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        // Add the machine into the associative table of the regime
        _tabRegimesMachines[i][pElement] = 0;
        // Set the 'Etat' of the machine active for this regime
        _tabEtatMachines[i][pElement] = true;
    }
    setIsGeometryModified(true);
 
    return true;
}
 
bool TYEtage::addSource(LPTYUserSourcePonctuelle pSource, const TYRepere& pos)
{
    return addSource(new TYUserSourcePonctuelleGeoNode(pos, (LPTYElement)pSource));
}
 
bool TYEtage::addSource(LPTYUserSourcePonctuelle pSource)
{
    return addSource(new TYUserSourcePonctuelleGeoNode((LPTYElement)pSource));
}
 
bool TYEtage::remSource(const LPTYUserSourcePonctuelleGeoNode pSourceGeoNode)
{
    assert(pSourceGeoNode);
 
    bool ret = false;
    TYTabUserSourcePonctuelleGeoNode::iterator ite;
 
    for (ite = _tabSources.begin(); ite != _tabSources.end(); ite++)
    {
        if ((*ite) == pSourceGeoNode)
        {
            _tabSources.erase(ite);
            ret = true;
            break;
        }
    }
 
    // For all the regimes of the 'Etage'
    TYElement* pElement = (*ite)->getElement();
    TYMapPtrElementInt::iterator iter;
    TYMapPtrElementBool::iterator itb;
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        iter = _tabRegimesMachines[i].find(pElement);
        // Delete the machine from the associative table of the regime
        _tabRegimesMachines[i].erase(iter);
 
        itb = _tabEtatMachines[i].find(pElement);
        _tabEtatMachines[i].erase(itb);
    }
    setIsGeometryModified(true);
 
    return ret;
}
 
bool TYEtage::remSource(const LPTYUserSourcePonctuelle pSource)
{
    assert(pSource);
    bool ret = false;
    TYTabUserSourcePonctuelleGeoNode::iterator ite;
 
    for (ite = _tabSources.begin(); ite != _tabSources.end(); ite++)
    {
        if (TYUserSourcePonctuelle::safeDownCast((*ite)->getElement()) == pSource)
        {
            _tabSources.erase(ite);
            ret = true;
            break;
        }
    }
 
    // For all the regimes of the 'Etage'
    TYElement* pElement = (TYElement*)pSource;
    TYMapPtrElementInt::iterator iter;
    TYMapPtrElementBool::iterator itb;
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        iter = _tabRegimesMachines[i].find(pElement);
        // Delete the machine from the associative table of the regime
        _tabRegimesMachines[i].erase(iter);
 
        itb = _tabEtatMachines[i].find(pElement);
        _tabEtatMachines[i].erase(itb);
    }
 
    setIsGeometryModified(true);
 
    return ret;
}
 
bool TYEtage::remSource(QString idSource)
{
    bool ret = false;
    TYTabUserSourcePonctuelleGeoNode::iterator ite;
 
    for (ite = _tabSources.begin(); ite != _tabSources.end(); ite++)
    {
        if (TYUserSourcePonctuelle::safeDownCast((*ite)->getElement())->getID().toString() == idSource)
        {
            _tabSources.erase(ite);
            ret = true;
            break;
        }
    }
 
    TYElement* pElement = (*ite)->getElement();
    TYMapPtrElementInt::iterator iter;
    TYMapPtrElementBool::iterator itb;
    for (unsigned int i = 0; i < _tabRegimes.size(); i++)
    {
        iter = _tabRegimesMachines[i].find(pElement);
        // Delete the source from the associative table of the regime
        _tabRegimesMachines[i].erase(iter);
 
        itb = _tabEtatMachines[i].find(pElement);
        _tabEtatMachines[i].erase(itb);
    }
 
    setIsGeometryModified(true);
 
    return ret;
}
 
void TYEtage::remAllSources()
{
    unsigned int i = 0, j = 0;
 
    TYMapPtrElementInt::iterator iter;
    for (i = 0; i < _tabRegimesMachines.size(); i++)
    {
        for (j = 0; j < _tabSources.size(); j++)
        {
            TYElement* pElement = _tabSources[j]->getElement();
            iter = _tabRegimesMachines[i].find(pElement);
            _tabRegimesMachines[i].erase(iter);
        }
    }
 
    TYMapPtrElementBool::iterator itb;
    for (i = 0; i < _tabEtatMachines.size(); i++)
    {
        for (j = 0; j < _tabSources.size(); j++)
        {
            TYElement* pElement = _tabSources[j]->getElement();
            itb = _tabEtatMachines[i].find(pElement);
            _tabEtatMachines[i].erase(itb);
        }
    }
 
    _tabSources.clear();
 
    setIsGeometryModified(true);
}
 
LPTYUserSourcePonctuelleGeoNode TYEtage::findSource(const LPTYUserSourcePonctuelle pSource)
{
    assert(pSource);
    TYTabUserSourcePonctuelleGeoNode::iterator ite;
 
    for (ite = _tabSources.begin(); ite != _tabSources.end(); ite++)
    {
        if (TYUserSourcePonctuelle::safeDownCast((*ite)->getElement()) == pSource)
        {
            return (*ite);
        }
    }
 
    return NULL;
}
 
void TYEtage::setRegime(TYSpectre& Spectre, int regime /*=-1*/, bool recursif /*=true*/)
{
    if (recursif)
    {
        for (unsigned int i = 0; i < _tabMur.size(); i++)
        {
            TYMur::safeDownCast(_tabMur[i]->getElement())->setRegime(Spectre, regime, recursif);
        }
    }
 
    TYAcousticVolume::setRegime(Spectre, regime, recursif);
}
 
bool TYEtage::remRegime(int regime)
{
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYMur::safeDownCast(_tabMur[i]->getElement())->remRegime(regime);
    }
 
    _pSol->remRegime(regime);
    _pPlafond->remRegime(regime);
 
    // Delete the associative table 'Regime' / 'Regime Machine'
    _tabRegimesMachines.erase(_tabRegimesMachines.begin() + regime);
    _tabEtatMachines.erase(_tabEtatMachines.begin() + regime);
 
    return TYAcousticVolume::remRegime(regime);
}
 
void TYEtage::setCurRegime(int regime)
{
    if (regime >= (int)_tabRegimesMachines.size())
    {
        return;
    }
    if (regime < 0)
    {
        regime = (int)_tabRegimes.size() - 1;
    }
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYMur::safeDownCast(_tabMur[i]->getElement())->setCurRegime(regime);
    }
 
    _pSol->setCurRegime(regime);
    _pPlafond->setCurRegime(regime);
 
    // Set the machines to the corresponding regime
    TYMapPtrElementInt::iterator iter;
    for (iter = _tabRegimesMachines[regime].begin(); iter != _tabRegimesMachines[regime].end(); iter++)
    {
        TYElement* pElement = (*iter).first;
        if (pElement->isA("TYMachine"))
        {
            LPTYMachine pMachine = TYMachine::safeDownCast(pElement);
            assert(pMachine);
            pMachine->setCurRegime((*iter).second);
        }
        else
        {
            LPTYUserSourcePonctuelle pSource = TYUserSourcePonctuelle::safeDownCast(pElement);
            assert(pSource);
            pSource->setCurrentRegime((*iter).second);
        }
    }
 
    // Set the machines in the corresponding 'Etat' ('rayonnant' / ' non rayonnant')
    TYMapPtrElementBool::iterator iter2;
    for (iter2 = _tabEtatMachines[regime].begin(); iter2 != _tabEtatMachines[regime].end(); iter2++)
    {
        TYElement* pElement = (*iter2).first;
        if (pElement->isA("TYMachine"))
        {
            LPTYMachine pMachine = TYMachine::safeDownCast(pElement);
            assert(pMachine);
            bool etat = (*iter2).second;
            pMachine->setIsRayonnant(etat);
        }
        else
        {
            LPTYUserSourcePonctuelle pSource = TYUserSourcePonctuelle::safeDownCast(pElement);
            assert(pSource);
            pSource->setIsRayonnant((*iter2).second);
        }
    }
 
    TYAcousticVolume::setCurRegime(regime);
 
    setIsAcousticModified(true);
}
 
int TYEtage::addRegime(TYRegime regime)
{
    int value = TYAcousticInterface::addRegime(regime);
 
    TYMapPtrElementInt mapElmRegime = _tabRegimesMachines[0];
    _tabRegimesMachines.push_back(mapElmRegime);
 
    TYMapPtrElementBool mapElmBool = _tabEtatMachines[0];
    _tabEtatMachines.push_back(mapElmBool);
 
    // Creation of the new 'Regime' for all walls, as well as the floor and ceiling
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYMur::safeDownCast(_tabMur[i]->getElement())->addRegime();
    }
 
    _pSol->addRegime();
    _pPlafond->addRegime();
 
    return value;
}
 
int TYEtage::addRegime()
{
    int value = TYAcousticInterface::addRegime();
 
    TYMapPtrElementInt mapElmRegime = _tabRegimesMachines[0];
    _tabRegimesMachines.push_back(mapElmRegime);
 
    TYMapPtrElementBool mapElmBool = _tabEtatMachines[0];
    _tabEtatMachines.push_back(mapElmBool);
 
    // Creation of the new 'Regime' for all walls, as well as the floor and ceiling
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYMur::safeDownCast(_tabMur[i]->getElement())->addRegime();
    }
 
    _pSol->addRegime();
    _pPlafond->addRegime();
 
    return value;
}
 
void TYEtage::setNextRegimeNb(const int& next)
{
    _nextRegime = next;
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYMur::safeDownCast(_tabMur[i]->getElement())->setNextRegimeNb(next);
    }
 
    _pSol->setNextRegimeNb(next);
    _pPlafond->setNextRegimeNb(next);
}
 
void TYEtage::setRegimeName(const QString& name)
{
    bool status = true;
    TYRegime& reg = getRegimeNb(_curRegime, status);
    if (status)
    {
        reg.setRegimeName(name);
    }
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYMur::safeDownCast(_tabMur[i]->getElement())->setRegimeName(name);
    }
 
    _pSol->setRegimeName(name);
    _pPlafond->setRegimeName(name);
}
 
TYTabSourcePonctuelleGeoNode TYEtage::getSrcs() const
{
    TYTabSourcePonctuelleGeoNode tab;
    TYTabSourcePonctuelleGeoNode tabChild;
 
    // We retrieve only the sources of the walls
    // The 'Etage' is considered as any acoustic volume
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        LPTYMur pMur = TYMur::safeDownCast(_tabMur[i]->getElement());
        // Retreive all the sources of the child ...
        if (pMur->getIsRayonnant())
        {
            tabChild = pMur->getSrcs();
 
            // Matrix concatenation
            OMatrix matrix = _tabMur[i]->getMatrix();
            for (unsigned int j = 0; j < tabChild.size(); j++)
            {
                tabChild[j]->setMatrix(matrix * tabChild[j]->getMatrix());
            }
 
            //...and add into the table to be returned
            tab.insert(tab.end(), tabChild.begin(), tabChild.end());
        }
    }
 
    tabChild = _pSol->getSrcs();
    tab.insert(tab.end(), tabChild.begin(), tabChild.end());
 
    tabChild = _pPlafond->getSrcs();
    tab.insert(tab.end(), tabChild.begin(), tabChild.end());
 
    return tab;
}
 
TYSourcePonctuelle TYEtage::srcPonctEquiv() const
{
    return TYSourcePonctuelle();
}
 
void TYEtage::setDensiteSrcsH(double densite, bool recursif)
{
    TYAcousticVolume::setDensiteSrcsH(densite);
 
    if (recursif)
    {
        for (unsigned int i = 0; i < _tabMur.size(); i++)
        {
            TYMur::safeDownCast(_tabMur[i]->getElement())->setDensiteSrcsH(getDensiteSrcsH());
        }
        // Floor is inactive
        _pPlafond->setDensiteSrcsH(getDensiteSrcsH());
    }
}
 
void TYEtage::setDensiteSrcsV(double densite, bool recursif)
{
    TYAcousticVolume::setDensiteSrcsV(densite);
 
    if (recursif)
    {
        for (unsigned int i = 0; i < _tabMur.size(); i++)
        {
            TYMur::safeDownCast(_tabMur[i]->getElement())->setDensiteSrcsV(getDensiteSrcsV());
        }
        // Floor is inactive
        _pPlafond->setDensiteSrcsV(getDensiteSrcsV());
    }
}
 
void TYEtage::distriSrcs()
{
    unsigned int i = 0;
 
    // First remove the present sources
    for (i = 0; i < _tabMur.size(); i++)
    {
        TYMur::safeDownCast(_tabMur[i]->getElement())->remAllSrcs();
    }
 
    _pSol->getSrcSurf()->remAllSrc();
    _pPlafond->getSrcSurf()->remAllSrc();
 
    // Walls
    for (i = 0; i < _tabMur.size(); i++)
    {
        LPTYMur pMur = TYMur::safeDownCast(_tabMur[i]->getElement());
        if (pMur->getIsRayonnant())
        {
            pMur->distriSrcs();
        }
    }
 
    // Floor
    if (_pSol->getIsRayonnant())
    {
        _pSol->distriSrcs();
    }
 
    // Ceiling
    if (_pPlafond->getIsRayonnant())
    {
        _pPlafond->distriSrcs();
    }
}
 
bool TYEtage::setSrcsLw()
{
    bool ret = true;
 
    TYSpectre LWEtage = TYSpectre::getEmptyLinSpectre();
    LWEtage.setType(SPECTRE_TYPE_LW);
 
    TYSpectre LWElt = TYSpectre::getEmptyLinSpectre();
    TYSpectre LWMur = TYSpectre::getEmptyLinSpectre();
 
    // FIRST HANDLE THE WALLS
 
    // For all the walls
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        // Wall matrix
        OMatrix matMur = _tabMur[i]->getMatrix();
 
        // Current wall
        LPTYMur pCurrentMur = TYMur::safeDownCast(_tabMur[i]->getElement());
        LWMur = TYSpectre::getEmptyLinSpectre();
 
        // If the wall is radiating, wa compute its power
        if (pCurrentMur->getIsRayonnant())
        {
            // Power spectrum affected to the wall
            double surfMur = pCurrentMur->activeSurface();
 
            // If "Puissance calculée", then the power of the wall is set to 0
            if (pCurrentMur->getTypeDistribution() == TY_PUISSANCE_IMPOSEE)
            {
                LWMur = pCurrentMur->getCurrentSpectre().toGPhy();
            }
 
            LWMur.setType(SPECTRE_TYPE_LW);
 
            // For all the faces of the wall
            TYTabAcousticSurfaceGeoNode tabAcousticSurf = pCurrentMur->getTabAcousticSurf();
 
            LPTYParoi pMurParoi = TYMur::safeDownCast(_tabMur[i]->getElement())->getParoi();
 
            // For all the surfaces making up the wall
            for (unsigned int j = 0; j < tabAcousticSurf.size(); j++)
            {
                LPTYAcousticSurfaceGeoNode pSurfaceNode = tabAcousticSurf[j];
                OMatrix matSurf = matMur * pSurfaceNode->getMatrix();
 
                LPTYAcousticSurface pCurrentSurf =
                    TYAcousticSurface::safeDownCast(pSurfaceNode->getElement());
                assert(pCurrentSurf);
 
                if (pCurrentSurf->getIsSub() == true)
                {
                    if (pCurrentSurf->getTypeDistribution() == TY_PUISSANCE_CALCULEE)
                    {
                        LWElt = getPuissanceRayonnee(pCurrentSurf, matSurf, pMurParoi);
                        LWEtage = LWEtage.sum(LWElt);
                    }
                    else
                    {
                        LWEtage = LWEtage.sum(pCurrentSurf->getCurrentSpectre().toGPhy());
                    }
                }
                else
                {
                    if (pCurrentMur->getTypeDistribution() == TY_PUISSANCE_CALCULEE)
                    {
                        LWElt = getPuissanceRayonnee(pCurrentSurf, matSurf, pMurParoi);
                        LWMur = LWMur.sum(LWElt);
                    }
                    else
                    {
                        double surfElt = pCurrentSurf->surface();
                        LWElt = LWMur.mult(surfElt / surfMur);
                    }
                }
 
                // FIX ANOMALY 28 - test of the power assignment type ('calculée' / 'imposée' ou
                // 'mesurée')
                if (pCurrentSurf->getTypeDistribution() == TY_PUISSANCE_CALCULEE)
                {
                    TYSpectre aSpectre(LWElt.toDB());
                    pCurrentSurf->setRegime(aSpectre, -1, false);
                }
 
                ret &= pCurrentSurf->setSrcsLw();
            }
 
            // FIX ANOMALY 28 - test of the power assignment type ('calculée' / 'imposée' ou
            // 'mesurée')
            if (pCurrentMur->getTypeDistribution() == TY_PUISSANCE_CALCULEE)
            {
                TYSpectre aSpectre(LWMur.toDB());
                pCurrentMur->setRegime(aSpectre, -1, false);
            }
        }
        else // The wall is not radiating, so it is assigned a zero power
        {
            LWMur.setType(SPECTRE_TYPE_LW);
        }
 
        LWEtage = LWEtage.sum(LWMur);
    }
 
    // HANDLE THE 'DALLES'
    if (_closed) // If it is a 'Batiment' and not a simple 'Ecran'
    {
        OMatrix matDalle;
        if (_pSol->getIsRayonnant())
        {
            if (_pSol->getTypeDistribution() == TY_PUISSANCE_CALCULEE)
            {
                LPTYParoi pSolParoi = _pSol->getParoi();
                LWElt = getPuissanceRayonnee(_pSol, matDalle, pSolParoi);
                TYSpectre aTYSpectre(LWElt.toDB());
                _pSol->setRegime(aTYSpectre, -1, false);
                LWEtage = LWEtage.sum(LWElt);
            }
            else
            {
                LWEtage = LWEtage.sum(_pSol->getCurrentSpectre().toGPhy());
            }
 
            _pSol->setSrcsLw();
        }
 
        if (_pPlafond->getIsRayonnant())
        {
            if (_pPlafond->getTypeDistribution() == TY_PUISSANCE_CALCULEE)
            {
                LPTYParoi pPlafondParoi = _pPlafond->getParoi();
                LWElt = getPuissanceRayonnee(_pPlafond, matDalle, pPlafondParoi);
                TYSpectre aTYSpectre(LWElt.toDB());
                _pPlafond->setRegime(aTYSpectre, -1, false);
                LWEtage = LWEtage.sum(LWElt);
            }
            else
            {
                LWEtage = LWEtage.sum(_pPlafond->getCurrentSpectre().toGPhy());
            }
 
            _pPlafond->setSrcsLw();
        }
    }
    TYSpectre aTYSpectre(LWEtage.toDB());
    this->setRegime(aTYSpectre, -1, false);
    return ret;
}
 
double TYEtage::volume() const
{
    return _pSol->surface() * getHauteur();
}
 
double TYEtage::surface() const
{
    double res = 0.0;
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        res += TYMur::safeDownCast(_tabMur[i]->getElement())->surface();
    }
 
    res += _pSol->surface();
    res += _pPlafond->surface();
 
    return res;
}
 
TYTabVector TYEtage::normals() const
{
    TYTabVector tab;
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        OVector3D normale = TYMur::safeDownCast(_tabMur[i]->getElement())->normal();
        normale = _tabMur[i]->getMatrix() * normale;
        tab.push_back(normale);
    }
 
    tab.push_back(_pSol->normal());
    tab.push_back(_pPlafond->normal());
 
    return tab;
}
 
TYTabPoint TYEtage::sommets() const
{
    TYTabPoint tab;
    TYPoint pt;
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        for (int j = 0; j < 4; j++)
        {
            // Retrieve the vertex
            pt = TYMur::safeDownCast(_tabMur[i]->getElement())->getBoundingRect()->_pts[j];
 
            // We pass in the coordinate system of the 'Etage'
            pt = _tabMur[i]->getMatrix() * pt;
 
            // Add the vertex
            tab.push_back(pt);
        }
    }
 
    return tab;
}
 
TYTabLPPolygon TYEtage::faces() const
{
    TYTabLPPolygon tab;
 
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        // Polygon representing the face
        TYPolygon* pPolygon = TYMur::safeDownCast(_tabMur[i]->getElement())->getBoundingRect()->toPolygon();
 
        // Convert the polygon into the coordinate system of the 'Etage'
        OMatrix matrix = _tabMur[i]->getMatrix();
 
        pPolygon->transform(matrix);
 
        // Add the polygon
        tab.push_back(pPolygon);
    }
 
    tab.push_back(new TYPolygon(*_pSol->getPolygon()));
    tab.push_back(new TYPolygon(*_pPlafond->getPolygon()));
 
    return tab;
}
 
TYBox TYEtage::volEnglob() const
{
    return TYVolumeInterface::volEnglob();
}
 
TYPoint TYEtage::centreGravite() const
{
    TYPoint centre(0.0, 0.0, 0.0);
 
    // Points on the floor
    TYTabPoint pts = _pSol->getContour();
    size_t nbPts = pts.size();
 
    // We average in (X,Y) the points on the floor
    for (size_t i = 0; i < nbPts; i++)
    {
        centre._x += pts[i]._x;
        centre._y += pts[i]._y;
    }
 
    // Mean
    centre._x /= nbPts;
    centre._y /= nbPts;
 
    // The altitude is the mid-height of the 'Etage'
    centre._z = getHauteur() / 2.0;
 
    return centre;
}
 
int TYEtage::intersects(const OSegment3D& seg, TYTabPoint& ptList) const
{
    return TYVolumeInterface::intersects(seg, ptList);
}
 
int TYEtage::isInside(const TYPoint& pt) const
{
    int res = INTERS_NULLE;
    OPoint3D ptCopy(pt);
 
    // The test with the englobing volume allow to test if the point is situated between the planes of the
    // floor and the ceiling, thus avoiding useless computations
    if (_volEnglob.isInside(pt) == INTERS_NULLE)
    {
        return res;
    }
 
    TYTabPoint ptsSol = _pSol->getContour();
    size_t nbPts = ptsSol.size();
 
    if (_closed && (nbPts >= 3))
    {
        // Set everything on the floor
        ptCopy._z = 0.0;
 
        // We reduce to a plane (z=0) and test if the point is inside the polygon formed by the 'Etage'
        // contour
        OPoint3D* pts = new OPoint3D[nbPts];
 
        for (size_t i = 0; i < nbPts; i++)
        {
            // Creation of the polygon
            pts[i] = ptsSol[i];
 
            // ... everything on the floor
            pts[i]._z = 0.0;
        }
 
        OPoint3D ptMin, ptMax;
 
        OGeometrie::boundingBox(pts, static_cast<int>(nbPts), ptMin, ptMax);
 
        OBox box(ptMin, ptMax);
 
#if TY_USE_IHM
        res = OGeometrie::pointInPolygonRayCasting(ptCopy, pts, static_cast<int>(nbPts));
#else
        res = OGeometrie::pointInPolygonAngleSum(ptCopy, pts, nbPts);
#endif
 
        delete[] pts;
    }
 
    return res;
}
 
void TYEtage::setacousticFacesPourCalcul(bool bPourCalculTrajet)
{
    _bPourCalculTrajet = bPourCalculTrajet;
}
 
TYTabAcousticSurfaceGeoNode TYEtage::acousticFaces()
{
    TYTabAcousticSurfaceGeoNode tab;
 
    // Add the walls 'Murs'
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        // Sub-wall (MurElement) for this wall and its matrix
        TYTabAcousticSurfaceGeoNode tabTmp =
            TYMur::safeDownCast(_tabMur[i]->getElement())->getTabAcousticSurf();
        OMatrix matrixMur = _tabMur[i]->getMatrix();
 
        unsigned int j = 0;
 
        // For each sub-wall
        for (j = 0; j < tabTmp.size(); j++)
        {
            // The sub-wall
            LPTYAcousticSurface pAccSurf = TYAcousticSurface::safeDownCast(tabTmp[j]->getElement());
 
            // If the 'Etage' is an 'Ecran' then take into account thickness of the 'Paroi'
            if (!_closed && TYMurElement::safeDownCast(pAccSurf))
            {
                // For this, build 2 new GeoNodes associated to this same face to represent the thickness
                LPTYAcousticSurfaceGeoNode pAccSurfGeoNode1 =
                    new TYAcousticSurfaceGeoNode((LPTYElement)pAccSurf);
                LPTYAcousticSurfaceGeoNode pAccSurfGeoNode2 =
                    new TYAcousticSurfaceGeoNode((LPTYElement)pAccSurf);
 
                // Retrieve the half-thickness of parent 'Mur'
                double epaisseur =
                    TYMur::safeDownCast(_tabMur[i]->getElement())->getParoi()->getEpaisseur() / 2.0;
                if (_bPourCalculTrajet)
                {
                    epaisseur = 0; // this way, we get the same number of points than for a real contour, but
                                   // having only the skeleton of the 'Ecran'
                }
 
                // Adding an offset in the z-direction only, as the faces (planes) are defined on the x and y
                // axes
                ORepere3D rep = tabTmp[j]->getORepere3D();
                rep._origin._z = +epaisseur;
                pAccSurfGeoNode1->setRepere(rep);
                rep._origin._z = -epaisseur;
                pAccSurfGeoNode2->setRepere(rep);
 
                // Concatenation of the matrix
                pAccSurfGeoNode1->setMatrix(matrixMur * pAccSurfGeoNode1->getMatrix());
                pAccSurfGeoNode2->setMatrix(matrixMur * pAccSurfGeoNode2->getMatrix());
 
                // Adding the faces
                tab.push_back(pAccSurfGeoNode1);
                tab.push_back(pAccSurfGeoNode2);
            }
            // Else simply adding the sub-wall
            else
            {
                // M = M(wall) . M(sub-wall)
                OMatrix matrix = matrixMur * tabTmp[j]->getMatrix();
 
                // Adding
                tab.push_back(new TYAcousticSurfaceGeoNode((LPTYElement)pAccSurf, matrix));
            }
        }
    }
 
    // Adding floor and ceiling if necessary
    if (_closed)
    {
        tab.push_back(new TYAcousticSurfaceGeoNode((LPTYElement&)_pSol));
        tab.push_back(new TYAcousticSurfaceGeoNode((LPTYElement&)_pPlafond));
    }
 
    return tab;
}
 
bool TYEtage::findAcousticSurface(const TYAcousticSurface* pAccSurf, OMatrix* pMatrix /*=0*/)
{
    bool ret = false;
 
    for (unsigned int i = 0; (i < _tabMur.size()) && !ret; i++)
    {
        // Wall elements for this wall 'Mur'
        TYTabAcousticSurfaceGeoNode& tabTmp =
            TYMur::safeDownCast(_tabMur[i]._pObj->getElement())->getTabAcousticSurf();
 
        for (unsigned int j = 0; j < tabTmp.size(); j++)
        {
            if (TYAcousticSurface::safeDownCast(tabTmp[j]._pObj->getElement()) == pAccSurf)
            {
                if (pMatrix)
                {
                    // Matrix update
                    *pMatrix = *pMatrix * _tabMur[i]._pObj->getMatrix() * tabTmp[j]._pObj->getMatrix();
                }
 
                // Surface found
                break;
            }
        }
    }
 
    return ret;
}
 
void TYEtage::coeffSabine()
{
    OSpectre absoElem;
    _absoSabine.setDefaultValue(0.0); // On reinitialise le spectre de Sabine
 
    size_t i = 0, j = 0;
    TYTabAcousticSurfaceGeoNode elemMur;    // Elements making up the wall
    TYTabAcousticVolumeGeoNode elemMachine; // Elements making up the machine
    double surfElem = 0.0;                  // Elementary surface
    _surfAbsorbante = 0.0;                  // Initialisation of the surface
 
    _volumeLibre = this->volume(); // Retrieve the volume of the 'Etage'
 
    // Reading of the absorption of each face of the volume
    size_t nbFaces = this->getTabMur().size();
 
    for (i = 0; i < nbFaces; i++)
    {
        elemMur = TYMur::safeDownCast(_tabMur[i]->getElement())->getTabAcousticSurf();
 
        LPTYParoi pMurParoi = TYMur::safeDownCast(_tabMur[i]->getElement())->getParoi();
 
        for (j = 0; j < elemMur.size(); j++)
        {
            // A sub-face of a 'Mur' must be of type 'MurElement'
            LPTYMurElement pMurElt = TYMurElement::safeDownCast(elemMur[j]->getElement());
            assert(pMurElt);
 
            // Retreive the local features of the wall 'Mur'
            surfElem = pMurElt->surface();
 
            // Absorption of the 'Paroi' associated with the surface
            if (pMurElt->getIsSub())
            {
                // If the surface is a window 'Fenetre', then take its absorption
                absoElem = pMurElt->getParoi()->getMatFace1()->getSpectreAbso().mult(surfElem);
            }
            else
            {
                // Else take the material mading up the wall
                absoElem = pMurParoi->getMatFace1()->getSpectreAbso().mult(surfElem);
            }
 
            // Adding elementary alpha*S and elementary surfaces
            _absoSabine = _absoSabine.sum(absoElem);
            _surfAbsorbante = _surfAbsorbante + surfElem;
        }
    }
 
    // Taking into account floors and ceilings
 
    // Area occupied on the floor by the machines
    double aireTotMachinesSol = 0.0;
    for (i = 0; i < _facesMachineSol.size(); i++)
    {
        aireTotMachinesSol = aireTotMachinesSol +
                             TYAcousticSurface::safeDownCast(_facesMachineSol[i]->getElement())->surface();
    }
 
    // Surface free floor = total surface of the floor - occupied surface by the machines
    surfElem = _pSol->surface() - aireTotMachinesSol;
    _surfAbsorbante = _surfAbsorbante + surfElem;
 
    absoElem = _pSol->getParoi()->getMatFace1()->getSpectreAbso().mult(surfElem);
    _absoSabine = _absoSabine.sum(absoElem);
 
    surfElem = _pPlafond->surface();
    _surfAbsorbante = _surfAbsorbante + surfElem;
 
    absoElem = _pPlafond->getParoi()->getMatFace1()->getSpectreAbso().mult(surfElem);
    _absoSabine = _absoSabine.sum(absoElem);
 
    // Taking into accound the absorption of each of the machines
    size_t nbMachines = this->getTabMachine().size();
    TYTabAcousticSurfaceGeoNode tabPtrSurf;
 
    for (i = 0; i < nbMachines; i++)
    {
        elemMachine = TYMachine::safeDownCast(this->getTabMachine()[i]->getElement())->getTabAcousticVol();
 
        for (j = 0; j < elemMachine.size(); j++)
        {
            LPTYAcousticVolume pElemMachine = TYAcousticVolume::safeDownCast(elemMachine[j]->getElement());
 
            surfElem = pElemMachine->surface();
 
            // Considering that the volumes of the machine are made up with an homogeneous material
            // If we'd wish to pass to one material by face, we should put the two following lines
            // into a loop processing each face
            absoElem = pElemMachine->getMateriau()->getSpectreAbso().mult(surfElem);
 
            _absoSabine = _absoSabine.sum(absoElem);
            double volElem = pElemMachine->volume();
            _surfAbsorbante = _surfAbsorbante + surfElem;
            _volumeLibre = _volumeLibre - volElem;
        }
    }
 
    // The faces of the machines set on the floor do not contribute to the absorption of the machines
    for (i = 0; i < _facesMachineSol.size(); i++)
    {
        LPTYAcousticSurface pSurface = TYAcousticSurface::safeDownCast(_facesMachineSol[i]->getElement());
 
        surfElem = pSurface->surface();
        absoElem = pSurface->getMateriau()->getSpectreAbso().mult(surfElem);
 
        _surfAbsorbante = _surfAbsorbante - surfElem;
        _absoSabine = _absoSabine.subst(absoElem);
    }
 
    _absoSabine = _absoSabine.div(_surfAbsorbante); // Computing average alpha of the room
    _absoSabine = _absoSabine.sum(1.0E-6);          // In case of alpha would be zero, adding epsilon to it
}
 
void TYEtage::calculTempsReverb()
{
    _TR = TYSpectre::getEmptyLinSpectre(); // Represent a linear value wich is the time
 
    // Take into accound the atmospheric aborption
 
    // S * A
    _TR = _absoSabine.mult(_surfAbsorbante);
 
    // 0.16*V/(S * A)
    _TR = _TR.invMult(0.16 * _volumeLibre);
 
    _TR.setType(SPECTRE_TYPE_AUTRE); // unit = seconds
    _TR.setEtat(SPECTRE_ETAT_DB);    // To avoid an unintended transformation
}
 
void TYEtage::updateSolPlafond()
{
    int nbPts = static_cast<int>(_tabMur.size());
 
    TYTabPoint pointsSol;
    TYTabPoint pointsPlafond;
 
    // for (int i = 0; i < nbPts; i++)
    for (int i = nbPts - 1; i >= 0; --i)
    {
        // Creating the polygon for the floor
        TYPoint ptSol = TYMur::safeDownCast(_tabMur[i]->getElement())->getBoundingRect()->_pts[3];
        // Passing in the coordinate system of the 'Etage'
        ptSol = _tabMur[i]->getMatrix() * ptSol;
        // Adding the point
        pointsSol.push_back(ptSol);
 
        // Creating the polygon for the ceiling
        TYPoint ptPlafond = TYMur::safeDownCast(_tabMur[i]->getElement())->getBoundingRect()->_pts[0];
        // Passing into the coordinate system of the 'Etage'
        ptPlafond = _tabMur[i]->getMatrix() * ptPlafond;
        // Adding the point
        pointsPlafond.push_back(ptPlafond);
    }
 
    // Reversing the points of the floor so that normals face outward
    TYTabPoint tabPtsTemp = pointsSol;
    pointsSol.clear();
    std::vector<TYPoint>::reverse_iterator it;
    for (it = tabPtsTemp.rbegin(); it != tabPtsTemp.rend(); it++)
    {
        pointsSol.push_back((*it));
    }
 
    _pSol->getPolygon()->setPoints(pointsSol);
    _pPlafond->getPolygon()->setPoints(pointsPlafond);
 
    setIsGeometryModified(true);
}
 
OSpectre TYEtage::champDirect(const OPoint3D& unPoint)
{
    OSpectre s = OSpectre::getEmptyLinSpectre();
    OSpectre sTemp = OSpectre::getEmptyLinSpectre();
    AtmosphericConditions atmos(101325., 20., 70.);
 
    unsigned int i = 0, j = 0;
    double distance = NAN;
    OSegment3D SR; // Segment source receptor
    TYTabAcousticVolumeGeoNode tabVolumes;
    TYTabSourcePonctuelleGeoNode tabSources;
    OPoint3D posSource;
 
    // For all the machines
    for (i = 0; i < _tabMachine.size(); i++)
    {
        LPTYAcousticVolumeNode pVolNode = TYAcousticVolumeNode::safeDownCast(_tabMachine[i]->getElement());
 
        if (pVolNode && pVolNode->getIsRayonnant()) // If not radiating, do not take sources
        {
            TYTabSourcePonctuelleGeoNode tabSrcNode = pVolNode->getSrcs();
 
            for (j = 0; j < tabSrcNode.size(); j++)
            {
                // The source
                LPTYSourcePonctuelle pSrc = TYSourcePonctuelle::safeDownCast(tabSrcNode[j]->getElement());
 
                // Transformation matrix to the source coordinate system
                OMatrix matInv = tabSrcNode[j]->getMatrix().getInvert();
 
                // Point position in the source coorinate system
                OPoint3D posPtInSrcRep = matInv * unPoint;
 
                // Contribution of the source to the point
                SR = OSegment3D(posSource, posPtInSrcRep);
                distance = SR.longueur();
 
                // Assigning directivity to the source power
                sTemp = OSpectre::getEmptyLinSpectre(1.0);        // pSrc->lwApparenteSrcDest(SR, atmos); // Q
                sTemp = sTemp.mult(pSrc->getSpectre()->toGPhy()); // W
                sTemp =
                    sTemp.mult(atmos.compute_z() / (4 * M_PI * distance * distance)); // Q.W.rho.C / 4.pi.d²
 
                // Adding spectra
                s = s.sum(sTemp);
            }
        }
    }
 
    // For all the ponctual sources
    for (i = 0; i < _tabSources.size(); i++)
    {
        LPTYUserSourcePonctuelle pSrc = TYUserSourcePonctuelle::safeDownCast(_tabSources[i]->getElement());
 
        if (pSrc && pSrc->getIsRayonnant())
        {
            posSource = *pSrc->getPos();
            SR = OSegment3D(posSource, unPoint);
            distance = SR.longueur();
 
            // Assigning directivity to the source power
            sTemp = OSpectre::getEmptyLinSpectre(
                1.); // pSrc->lwApparenteSrcDest(SR, atmos); // Directivity of the source Q
            sTemp = sTemp.mult(pSrc->getSpectre()->toGPhy());                         // Power W
            sTemp = sTemp.mult(atmos.compute_z() / (4 * M_PI * distance * distance)); // Q.W.rho.C/(4.pi.d²)
 
            // Adding spectra
            s = s.sum(sTemp);
        }
    }
 
    s.setType(SPECTRE_TYPE_LP);
 
    return s;
}
void TYEtage::calculChampReverbere()
{
    // We start by computing the average absorption coefficient of the room
    coeffSabine();
 
    // Computing TR
    calculTempsReverb();
 
    // Computing the reverberated field
    calculChampRevSabine();
}
 
void TYEtage::calculChampRevSabine()
{
    unsigned int i = 0, j = 0;
    AtmosphericConditions atmos(101325., 20., 70.);
 
    // Room effect ((4.Rho.C / (alpha.S))-(4/S) - Tr.C.AbsoATm)
    _reverb = TYSpectre::getEmptyLinSpectre(4.0); // Spectrum initialised to value 4.0
 
    _reverb = _reverb.div(_absoSabine.mult(_surfAbsorbante)); // 4/(alpha.S)
    _reverb = _reverb.mult(atmos.compute_z());                // 4.Rho.C/(alpha.S)
 
    // reverberated field : W*(Room effect)
    OSpectre sTemp = OSpectre::getEmptyLinSpectre();
 
    // Pr = 4W*rho*c/a
    TYTabSourcePonctuelleGeoNode tabAllSources;
 
    // Retrieving all the source
    // of the machines
    for (i = 0; i < _tabMachine.size(); i++)
    {
        LPTYAcousticVolumeNode pVolNode = TYAcousticVolumeNode::safeDownCast(_tabMachine[i]->getElement());
        if (pVolNode && pVolNode->getIsRayonnant())
        {
            // The sources of this machine
            TYTabSourcePonctuelleGeoNode tabSrcMachine =
                TYMachine::safeDownCast(_tabMachine[i]->getElement())->getSrcs();
            tabAllSources.insert(tabAllSources.end(), tabSrcMachine.begin(), tabSrcMachine.end());
        }
    }
 
    for (i = 0; i < _tabSources.size(); i++)
    {
        LPTYUserSourcePonctuelle pSrc = TYUserSourcePonctuelle::safeDownCast(_tabSources[i]->getElement());
 
        // If it is radiating, we add the ponctual source
        if (pSrc && pSrc->getIsRayonnant())
        {
            tabAllSources.push_back(_tabSources[i]);
        }
    }
 
    // For each of these sources
    for (j = 0; j < tabAllSources.size(); j++)
    {
        // Adding spectra of all the sources
        sTemp = sTemp.sum(
            TYSourcePonctuelle::safeDownCast(tabAllSources[j]->getElement())->getSpectre()->toGPhy());
    }
 
    // Adding spectra
    _reverb = _reverb.mult(sTemp); // 4.W.Rho.C / (alpha.S)
 
    _reverb.setType(SPECTRE_TYPE_LP);
}
 
void TYEtage::updateParoi()
{
    TYTabMurGeoNode tabMur = getTabMur();
 
    for (unsigned int i = 0; i < tabMur.size(); i++)
    {
        LPTYMur pMur = TYMur::safeDownCast(tabMur[i]->getElement());
        TYMur::safeDownCast(_tabMur[i]->getElement())->setParoi(_pParoi);
    }
 
    _pSol->setParoi(_pParoi);
    _pPlafond->setParoi(_pParoi);
}
 
void TYEtage::findFaceMachineSol()
{
    unsigned int i = 0;
 
    _facesMachineSol.clear();
 
    // Retrieving all the faces of the machines
    TYTabAcousticSurfaceGeoNode accFaces;
    for (i = 0; i < _tabMachine.size(); i++)
    {
        TYTabAcousticSurfaceGeoNode tabTmp =
            TYMachine::safeDownCast(_tabMachine[i]->getElement())->acousticFaces();
        OMatrix matrixMachine = _tabMachine[i]->getMatrix();
 
        for (unsigned int j = 0; j < tabTmp.size(); j++)
        {
            // Passing into the coordinate system of this 'Etage'
            OMatrix matrix = matrixMachine * tabTmp[j]->getMatrix();
            tabTmp[j]->setMatrix(matrix);
 
            accFaces.push_back(tabTmp[j]);
        }
    }
 
    // Searching for the faces of this 'Etage' which are set on the floor
    OPlan planSol = _pSol->plan();
    double distance = 0.0;
 
    for (i = 0; i < accFaces.size(); i++)
    {
        // The face
        LPTYAcousticSurfaceGeoNode pFaceGeoNode = accFaces[i];
 
        // Contour of the face
        LPTYAcousticSurface pSurface = TYAcousticSurface::safeDownCast(accFaces[i]->getElement());
        TYTabPoint contour = pSurface->getContour();
        if (contour.size() < 3)
        {
            continue;
        }
 
        OMatrix matrixFace = accFaces[i]->getMatrix();
 
        // A point on the plane of the face in the coordinate system of the 'Etage'
        OPoint3D ptPlan = matrixFace * OVector3D(contour[0]);
        // The normal to the face in the coordinate system of the 'Etage'
        OVector3D vecPlan = OVector3D(matrixFace * OPoint3D(0.0, 0.0, 0.0), matrixFace * pSurface->normal());
        vecPlan.normalize();
        // The plane of the face in the coordinate system of the 'Etage'
        OPlan planFace(ptPlan, vecPlan);
 
        // Distance betaween 2 floors if they are parallel
        if (planFace.distancePlanParallel(planSol, distance))
        {
            // If the face is set on the floor (with a tolerance)
            if (ABS(distance) <= TYSEUILCONFONDUS)
            {
                // We "deactivate" this face of the machine
                pSurface->setDensiteSrcs(0.0);
 
                // We preserve the faces touching the floor
                _facesMachineSol.push_back(accFaces[i]);
            }
        }
    }
}
 
bool TYEtage::updateAcoustic(const bool& force) // force=false
{
    unsigned int i = 0;
    bool ret = true;
 
    // If not radiating, we do not block the calculation
    // (this situation may be intentional, but no acoustic distribution is performed in this case)
    if (!_isRayonnant)
    {
        return true;
    }
 
    // We start by adjusting the height of the sources
    updateZSource();
 
    // updateAcoustic of the machines in the 'Batiment' if any
    if ((_tabMachine.size() != 0) || (_tabSources.size() != 0))
    {
        findFaceMachineSol();
 
        // Machines
        for (i = 0; i < _tabMachine.size(); i++)
        {
            ret &= TYMachine::safeDownCast(_tabMachine[i]->getElement())->updateAcoustic();
        }
    }
 
    calculChampReverbere();
    distriSrcs();
    ret &= setSrcsLw();
 
    return ret;
}
 
void TYEtage::remAllSrcs()
{
    // Remove the sources on the walls
    for (unsigned int i = 0; i < _tabMur.size(); i++)
    {
        TYAcousticRectangleNode::safeDownCast(_tabMur[i]->getElement())->remAllSrcs();
    }
 
    // Remove the sources on the floor and ceiling
    _pSol->remAllSrcs();
    _pPlafond->remAllSrcs();
}
 
double TYEtage::activeSurface() const
{
    unsigned int i = 0;
    double surface = 0.0;
 
    for (i = 0; i < _tabMur.size(); i++)
    {
        LPTYMur pMur = TYMur::safeDownCast(_tabMur[i]->getElement());
 
        surface += pMur->activeSurface();
    }
 
    return surface;
}
 
TYSpectre TYEtage::setGlobalLW(const TYSpectre& spectre, const double& surfGlobale, const int& regime /*=-1*/)
{
    /* If the 'Etage' is set to "Puissance imposée", we return it; if the 'Etage' is set to "Puissance
     * calculée", its power depends on the sources it contains and has been calculated previously by an
     * updateAcoustic (this is the opposite of the machines).*/
    return getCurrentSpectre().toGPhy(); // Returns the obtained spectrum
}
 
TYSpectre TYEtage::getPuissanceRayonnee(LPTYAcousticSurface pCurrentSurf, const OMatrix matMur,
                                        const LPTYParoi pMurParoi)
{
    TYSpectre spectreEltMur = TYSpectre::getEmptyLinSpectre();
    TYSpectre s = TYSpectre::getEmptyLinSpectre();
    OSpectre spectreAtt;
    OPoint3D posSrc;
    AtmosphericConditions atmos(101325., 20., 70.);
 
    // A sub-face of wall must be of type MurElement
    LPTYMurElement pMurElt = TYMurElement::safeDownCast(pCurrentSurf);
 
    if (pMurElt) // Process floor and ceiling case
    {
        if (pMurElt->getIsSub())
        {
            // If the 'Paroi' is a window 'Fenetre'
            spectreAtt = pMurElt->getParoi()->getMatStruct()->getSpectreTransm();
        }
        else
        {
            // Otherwise, it is the 'Paroi' associated with the 'Mur'
            spectreAtt = pMurParoi->getMatStruct()->getSpectreTransm();
        }
    }
    else // Case of floor and ceiling
    {
        // Otherwise, it is the 'Paroi' associated with the 'Mur'
        spectreAtt = pMurParoi->getMatStruct()->getSpectreTransm();
    }
 
    TYTabSourcePonctuelleGeoNode tabSources = pCurrentSurf->getSrcs();
    double surf = pCurrentSurf->surface() / tabSources.size();
 
    // For all the ponctual sources of the face
    for (unsigned int k = 0; k < tabSources.size(); k++)
    {
        LPTYSourcePonctuelle pSource = TYSourcePonctuelle::safeDownCast(tabSources[k]->getElement());
 
        // Position of the source in the coordinate system of the 'Etage'
        posSrc = matMur * *(pSource->getPos());
 
        s = _reverb.div(4.0); // Correction reverberated field (pressure), reverberated intensity.
 
        s = s.sum(champDirect(posSrc));
 
        s = s.mult(surf / atmos.compute_z()); // W = P² * S / (rho.C)
        //      s = s.sum(_reverb);// P² = directField + reverberatedField
 
        //      s = s.div(4.0); // DT 20100106 as the test case transparent 'Paroi' did not match
 
        s = s.div((spectreAtt).toGPhy()); // See whether the spectrum must be converted in physical value
 
        spectreEltMur = spectreEltMur.sum(s);
    }
 
    spectreEltMur.setType(SPECTRE_TYPE_LW);
    return spectreEltMur;
}
 
void TYEtage::setParoi(const LPTYParoi pParoi)
{
    assert(pParoi);
    assert(_pParoi);
 
    *_pParoi = *pParoi;
}
 
void TYEtage::updateZSource()
{
    unsigned int i = 0;
    for (i = 0; i < _tabSources.size(); i++)
    {
        LPTYUserSourcePonctuelle pSource = TYUserSourcePonctuelle::safeDownCast(_tabSources[i]->getElement());
        double h = pSource->getHauteur();
        pSource->getPos()->_z = h;
        _tabSources[i]->setIsGeometryModified(true);
    }
 
    for (i = 0; i < _tabMachine.size(); i++)
    {
        double h = _tabMachine[i]->getHauteur();
        ORepere3D repere3D = _tabMachine[i]->getORepere3D();
        repere3D._origin._z = h;
        _tabMachine[i]->setRepere(repere3D);
    }
 
    setIsGeometryModified(true);
}
 
void TYEtage::propagateAtt(LPTYAttenuateur pAtt)
{
    size_t i = 0;
    size_t nbFaces = this->getTabMur().size();
 
    LPTYMur pMur = NULL;
 
    // Propagating to the walls 'Murs'
    for (i = 0; i < nbFaces; i++)
    {
        pMur = TYMur::safeDownCast(_tabMur[i]->getElement());
 
        if (pMur)
        {
            pMur->propagateAtt(pAtt);
        }
    }
 
    // Propagating to the floor and ceiling
    _pSol->propagateAtt(pAtt);
    _pPlafond->propagateAtt(pAtt);
 
    TYAcousticVolume::propagateAtt(pAtt);
}