pod_common.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_COMMON_HPP__
#define __BITPIT_POD_COMMON_HPP__
 
#include "bitpit_containers.hpp"
#include "bitpit_patchkernel.hpp"
 
namespace bitpit {

namespace pod {
typedef PiercedStorage<double> ScalarStorage;                   
typedef PiercedStorage<std::array<double, 3>> VectorStorage;    

struct SnapshotFile
{
    std::string directory;   
    std::string name;        

    SnapshotFile(const std::string &_directory = std::string(), const std::string &_name = std::string())
    : directory(_directory), name(_name)
    {
    }
 
};

struct PODField
{
    std::shared_ptr<VolumeKernel>           meshStorage; 
    VolumeKernel*                           mesh;        
    std::unique_ptr<PiercedStorage<bool>>   mask;        
    std::unique_ptr<pod::ScalarStorage>     scalar;      
    std::unique_ptr<pod::VectorStorage>     vector;      

    PODField()
        : mesh(nullptr)
    {
    }

    PODField(const PODField & field) :
        mask(new PiercedStorage<bool>(*field.mask)),
        scalar(new PiercedStorage<double>(*field.scalar)),
        vector(new PiercedStorage<std::array<double,3>>(*field.vector))
    {
        meshStorage = field.meshStorage;
        mesh        = field.mesh;
    }

    PODField(PODField && field) = default;

 
    PODField(int nsf, int nvf, VolumeKernel *lmesh = nullptr, const PiercedKernel<long> *lkernel = nullptr)
    {
        mesh   = lmesh;
        mask   = std::unique_ptr<PiercedStorage<bool>>(new PiercedStorage<bool>(1, lkernel));
        scalar = std::unique_ptr<pod::ScalarStorage>(new pod::ScalarStorage(nsf, lkernel));
        vector = std::unique_ptr<pod::VectorStorage>(new pod::VectorStorage(nvf, lkernel));
    }

    PODField & operator=(PODField other)
    {
        this->swap(other);
 
        return *this;
    }

    void swap(PODField &other)
    {
        std::swap(meshStorage, other.meshStorage);
        std::swap(mesh, other.mesh);
        std::swap(mask, other.mask);
        std::swap(scalar, other.scalar);
        std::swap(vector, other.vector);
    }

    void setStaticKernel(const PiercedKernel<long> *lkernel)
    {
        mask->unsetKernel();
        mask->setStaticKernel(lkernel);
        scalar->unsetKernel();
        scalar->setStaticKernel(lkernel);
        vector->unsetKernel();
        vector->setStaticKernel(lkernel);
    }

    void setDynamicKernel(PiercedKernel<long> *lkernel)
    {
        mask->setDynamicKernel(lkernel, PiercedSyncMaster::SyncMode::SYNC_MODE_JOURNALED);
        scalar->setDynamicKernel(lkernel, PiercedSyncMaster::SyncMode::SYNC_MODE_JOURNALED);
        vector->setDynamicKernel(lkernel, PiercedSyncMaster::SyncMode::SYNC_MODE_JOURNALED);
    }

    void setMesh(VolumeKernel *lmesh)
    {
        meshStorage.reset();
        mesh = lmesh;
    }

    void setMesh(const std::shared_ptr<VolumeKernel> &lmesh)
    {
        meshStorage = lmesh;
        mesh        = meshStorage.get();
    }

    void clear()
    {
        meshStorage.reset();
 
        mesh = nullptr;
        mask.reset();
        scalar.reset();
        vector.reset();
    }
 
};

struct PODMode
{
    std::unique_ptr<pod::ScalarStorage> scalar; 
    std::unique_ptr<pod::VectorStorage> vector; 

    PODMode()
    {
        scalar = nullptr;
        vector = nullptr;
    }

    PODMode(int nsf, int nvf, const PiercedKernel<long>* lkernel = nullptr)
    {
        scalar = std::unique_ptr<pod::ScalarStorage>(new pod::ScalarStorage(nsf, lkernel));
        vector = std::unique_ptr<pod::VectorStorage>(new pod::VectorStorage(nvf, lkernel));
    }

    void clear()
    {
        scalar.reset();
        vector.reset();
    }
 
};
 
}
 
}
 
#endif