pod_kernel.hpp

/*---------------------------------------------------------------------------*\
 *
 *  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/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_POD_KERNEL_HPP__
#define __BITPIT_POD_KERNEL_HPP__
 
#if BITPIT_ENABLE_MPI
#    include <mpi.h>
#endif
#include <string>
#include <vector>
#include <unordered_map>
 
#include "pod_common.hpp"
#include "bitpit_common.hpp"
#include "bitpit_patchkernel.hpp"
 
namespace bitpit {
 
class PODKernel : public VTKBaseStreamer {
 
    friend class POD;
 
public:
# if BITPIT_ENABLE_MPI
    PODKernel(MPI_Comm comm = MPI_COMM_WORLD);
# else
    PODKernel();
# endif
 
    virtual ~PODKernel();

    PODKernel(PODKernel&& other) = default;
 
    VolumeKernel* getMesh();
    void evalCellsVolume();
    double getCellVolume(long id);
    double getRawCellVolume(long rawIndex);
    VolumeMapper* getMapper();
 
    bool isMapperDirty();
    void computeMapper(const VolumeKernel * mesh, bool fillInv = true);
    void adaptionPrepare(const std::vector<adaption::Info> & info);
    void adaptionAlter(const std::vector<adaption::Info> & info, bool fillInv = true);
    void adaptionCleanUp(const std::vector<adaption::Info> & info);
 
#if BITPIT_ENABLE_MPI
    MPI_Comm getCommunicator() const;
    bool isCommunicatorSet() const;
#endif
 
 
protected:
    std::unique_ptr<VolumeKernel> m_meshPOD;     
    PiercedStorage<double>        m_cellsVolume; 
 
#if BITPIT_ENABLE_MPI
    MPI_Comm                m_communicator; 
#endif
    int                     m_rank;         
    int                     m_nProcs;       
 
    std::unique_ptr<VolumeMapper> m_meshmap;      
 
    bool                    m_dirtymap;     
 
    void clear();
 
    void setMesh(std::unique_ptr<VolumeKernel> &&mesh);
 
    std::unique_ptr<VolumeKernel> readMesh(const pod::SnapshotFile &snap);
    void restoreMesh(const pod::SnapshotFile &snap);
 
    void clearMapper();
    void setMapperDirty(bool dirty = true);
 
    virtual std::unique_ptr<VolumeKernel> createMesh() = 0;
 
    virtual std::unique_ptr<VolumeMapper> _computeMapper(const VolumeKernel * mesh, bool fillInv) = 0;
 
    virtual pod::PODField mapPODFieldToPOD(const pod::PODField & field, const std::unordered_set<long> * targetCells) = 0;
    virtual void mapPODFieldFromPOD(pod::PODField & field, const std::unordered_set<long> * targetCells, const pod::PODField & mappedField) = 0;
 
    virtual PiercedStorage<double> mapFieldsToPOD(const PiercedStorage<double> & fields, const VolumeKernel * mesh, const std::unordered_set<long> * targetCells,
            const std::vector<std::size_t> &scalarIds, const std::vector<std::array<std::size_t, 3>> &vectorIds) = 0;
    virtual void mapFieldsFromPOD(PiercedStorage<double> & fields, const VolumeKernel * mesh, const std::unordered_set<long> * targetCells,
            const PiercedStorage<double> & mappedFields,
            const std::vector<std::size_t> &scalarIds, const std::vector<std::array<std::size_t, 3>> &vectorIds) = 0;
 
    virtual PiercedStorage<bool> mapBoolFieldToPOD(const PiercedStorage<bool> & field, const VolumeKernel * mesh, const std::unordered_set<long> * targetCells) = 0;
    virtual void mapBoolFieldToPOD(const PiercedStorage<bool> & field, const VolumeKernel * mesh, const std::unordered_set<long> * targetCells, PiercedStorage<bool> & mappedField) = 0;
 
    virtual std::unordered_set<long> mapCellsToPOD(const std::unordered_set<long> * cells) = 0;
 
    virtual void adaptMeshToMesh(const VolumeKernel * meshToAdapt, const VolumeKernel * meshReference) = 0;
 
#if BITPIT_ENABLE_MPI
    void initializeCommunicator(MPI_Comm communicator);
    void freeCommunicator();
#endif
 
};
 
}
 
#endif