levelSetComplementObject.tpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
# include <cassert>
 
# include "bitpit_IO.hpp"
# include "bitpit_common.hpp"
 
# include "levelSetObject.hpp"
# include "levelSetProxyObject.hpp"
# include "levelSetComplementObject.hpp"
 
namespace bitpit {
 
template<typename SourceLevelSetObject>
LevelSetComplementBaseObject<SourceLevelSetObject>::LevelSetComplementBaseObject(int id, const SourceLevelSetObject *source)
    : LevelSetProxyObject<SourceLevelSetObject, SourceLevelSetObject>(id),
      m_sourceObject(source)
{
}
 
template<typename SourceLevelSetObject>
bool LevelSetComplementBaseObject<SourceLevelSetObject>::empty() const
{
    return m_sourceObject->empty();
}
 
template<typename SourceLevelSetObject>
void LevelSetComplementBaseObject<SourceLevelSetObject>::replaceSourceObject(const SourceLevelSetObject *current, const SourceLevelSetObject *updated)
{
    if (current != m_sourceObject) {
        throw std::runtime_error("Unable to find the source that should be replaced.");
    }
 
    m_sourceObject = updated;
}
 
template<typename SourceLevelSetObject>
void LevelSetComplementBaseObject<SourceLevelSetObject>::fillCellPropagatedSignCache()
{
    // Early return if propagated sign cannot be copied from the source object
    LevelSetBulkEvaluationMode sourceBulkEvaluationMode = m_sourceObject->getCellBulkEvaluationMode();
 
    bool useSourceSign = false;
    if (sourceBulkEvaluationMode == LevelSetBulkEvaluationMode::SIGN_PROPAGATION) {
        useSourceSign = true;
    } else if (sourceBulkEvaluationMode == LevelSetBulkEvaluationMode::EXACT) {
        LevelSetCacheMode sourceSignCacheMode = m_sourceObject->getFieldCellCacheMode(LevelSetField::SIGN);
        if (sourceSignCacheMode == LevelSetCacheMode::FULL) {
            useSourceSign = true;
        } else {
            LevelSetCacheMode sourceValueCacheMode = m_sourceObject->getFieldCellCacheMode(LevelSetField::VALUE);
            if (sourceValueCacheMode == LevelSetCacheMode::FULL) {
                useSourceSign = true;
            }
        }
    }
 
    if (!useSourceSign) {
        SourceLevelSetObject::fillCellPropagatedSignCache();
        return;
    }
 
    // Mesh information
    const VolumeKernel &mesh = *(this->getKernel()->getMesh()) ;
    VolumeKernel::CellConstIterator cellBegin = mesh.cellConstBegin();
    VolumeKernel::CellConstIterator cellEnd   = mesh.cellConstEnd();
 
    // Get cache for sign propagation
    typedef typename SourceLevelSetObject::CellCacheCollection::template ValueCache<char> ZoneCache;
    ZoneCache *propagatedSignCache = this->template getCellCache<char>(this->m_cellPropagatedSignCacheId);
 
    // Get propagated sign from source object
    for (VolumeKernel::CellConstIterator cellItr = cellBegin; cellItr != cellEnd; ++cellItr) {
        long cellId = cellItr.getId();
        short cellSign = - m_sourceObject->evalCellSign(cellId);
 
        propagatedSignCache->insertEntry(cellId, static_cast<char>(cellSign));
    }
}
 
template<typename SourceLevelSetObject>
short LevelSetComplementBaseObject<SourceLevelSetObject>::_evalCellSign(long id) const
{
    return (-1 * m_sourceObject->evalCellSign(id));
}
 
template<typename SourceLevelSetObject>
double LevelSetComplementBaseObject<SourceLevelSetObject>::_evalCellValue(long id, bool signedLevelSet) const
{
    double value = m_sourceObject->evalCellValue(id, signedLevelSet);
    if (signedLevelSet) {
        value *= -1.;
    }
 
    return value;
}
 
template<typename SourceLevelSetObject>
std::array<double,3> LevelSetComplementBaseObject<SourceLevelSetObject>::_evalCellGradient(long id, bool signedLevelSet) const
{
    std::array<double,3> gradient = m_sourceObject->evalCellGradient(id, signedLevelSet);
    if (signedLevelSet) {
        gradient *= -1.;
    }
 
    return gradient;
}
 
template<typename SourceLevelSetObject>
short LevelSetComplementBaseObject<SourceLevelSetObject>::_evalSign(const std::array<double,3> &point) const
{
    return (-1 * m_sourceObject->evalSign(point));
}
 
template<typename SourceLevelSetObject>
double LevelSetComplementBaseObject<SourceLevelSetObject>::_evalValue(const std::array<double,3> &point, bool signedLevelSet) const
{
    double value = m_sourceObject->evalValue(point, signedLevelSet);
    if (signedLevelSet) {
        value *= -1.;
    }
 
    return value;
}
 
template<typename SourceLevelSetObject>
std::array<double,3> LevelSetComplementBaseObject<SourceLevelSetObject>::_evalGradient(const std::array<double,3> &point, bool signedLevelSet) const
{
    std::array<double,3> gradient = m_sourceObject->evalGradient(point, signedLevelSet);
    if (signedLevelSet) {
        gradient *= -1.;
    }
 
    return gradient;
}
 
template<typename SourceLevelSetObject>
const SourceLevelSetObject * LevelSetComplementBaseObject<SourceLevelSetObject>::getCellReferenceObject(long id) const
{
    BITPIT_UNUSED(id);
 
    return m_sourceObject;
}
 
template<typename SourceLevelSetObject>
const SourceLevelSetObject * LevelSetComplementBaseObject<SourceLevelSetObject>::getReferenceObject(const std::array<double, 3> &point) const
{
    BITPIT_UNUSED(point);
 
    return m_sourceObject;
}
 
template<typename SourceLevelSetObject>
const SourceLevelSetObject * LevelSetComplementBaseObject<SourceLevelSetObject>::getSourceObject() const
{
    return m_sourceObject;
}
 
template<typename SourceLevelSetObject>
std::vector<const SourceLevelSetObject *> LevelSetComplementBaseObject<SourceLevelSetObject>::getSourceObjects() const
{
    return std::vector<const SourceLevelSetObject *>(1, m_sourceObject);
}
 
}