pod.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_HPP__
#define __BITPIT_POD_HPP__
 
#if BITPIT_ENABLE_MPI
#    include <mpi.h>
#endif
#include <string>
#include <vector>
#include <unordered_map>
 
#include "pod_kernel.hpp"
 
namespace bitpit {
 
class PODKernel;
 
class POD : public VTKBaseStreamer {
 
public:
 
    enum class MemoryMode {
        MEMORY_NORMAL ,
        MEMORY_LIGHT 
    };
 
    enum class RunMode {
        RESTORE ,
        COMPUTE 
    };
 
    enum class WriteMode {
        DUMP ,
        DEBUG ,
        NONE 
    };
 
    enum class ReconstructionMode {
        PROJECTION ,
        MINIMIZATION 
    };
 
    enum class ErrorMode {
        COMBINED ,
        SINGLE ,
        NONE 
    }; 
 
    enum class MeshType {
        UNDEFINED ,
        VOLOCTREE 
    };
 
public:
# if BITPIT_ENABLE_MPI
    POD(MPI_Comm comm = MPI_COMM_WORLD);
# else
    POD();
# endif
 
    ~POD();
 
    POD(POD&& other) = default;
 
    void clear();
 
    void setDirectory(const std::string &directory);
    const std::string & getDirectory();
    void setName(const std::string &name);
    const std::string & getName();
    void addSnapshot(const std::string &directory, const std::string &name);
    void addSnapshot(const pod::SnapshotFile &file);
    void setSnapshots(const std::vector<pod::SnapshotFile> &database);
    void readSnapshot(const pod::SnapshotFile &snap, pod::PODField &fieldr);
    void removeLeave1outSnapshot(const std::string &directory, const std::string &name);
    void removeLeave1outSnapshot(const pod::SnapshotFile &file);    
    void unsetLeave1outSnapshots();    
    void addReconstructionSnapshot(const std::string &directory, const std::string &name);
    void addReconstructionSnapshot(const pod::SnapshotFile &file);
    void setModeCount(std::size_t nmodes);
    std::size_t getModeCount();
    void setEnergyLevel(double energy);
    double getEnergyLevel();
    void setErrorThreshold(double threshold);
    double getErrorThreshold(); 
    void setTargetErrorFields(std::vector<std::string> &namesf, std::vector<std::array<std::string,3>> &namevf);
 
    void setMeshType(MeshType type);
    void setMesh(const std::string &directory, const std::string &name);
    void setMesh(const pod::SnapshotFile &file);
    void setMesh(std::unique_ptr<VolumeKernel> &&mesh);
    MeshType getMeshType();
    void setStaticMesh(bool flag);
    void setUseMean(bool flag);    
 
    void setMemoryMode(MemoryMode mode);
    MemoryMode getMemoryMode();
    void setRunMode(RunMode mode);
    RunMode getRunMode();
    void setWriteMode(WriteMode mode);
    WriteMode getWriteMode();
    void setReconstructionMode(ReconstructionMode mode);
    ReconstructionMode getReconstructionMode();
    void setErrorMode(ErrorMode mode);
    ErrorMode getErrorMode();       
    void setExpert(bool mode = true);
 
    void setSensorMask(const PiercedStorage<bool> & mask, VolumeKernel * mesh = nullptr);
 
    std::size_t getSnapshotCount();
    std::vector<std::string> getScalarNames();
    std::vector<std::array<std::string,3>> getVectorNames();
    std::vector<std::string> getFieldsNames();
 
    const VolumeKernel* getMesh();
    const pod::PODMode & getMean();
    const std::vector<pod::PODMode> & getModes();
    std::vector<std::vector<double> > getReconstructionCoeffs();
    const std::unordered_set<long int> & getListActiveIDs();
    std::size_t getListIDInternalCount();
    std::unique_ptr<PODKernel> & getKernel();
 
    void run();
    void dump();
    void restore();
    void leave1out();    
 
    void evalDecomposition();
    void evalReconstruction();
 
    void evalMeanMesh();
    void fillListActiveIDs(const PiercedStorage<bool> &bfield);
    void evalCorrelation();
    void evalModes();
    void evalEigen();
    void evalErrorBoundingBox();
    void computeMapper(const VolumeKernel * mesh);
    void adaptionPrepare(const std::vector<adaption::Info> & info);
    void adaptionAlter(const std::vector<adaption::Info> & info);
    void adaptionCleanUp(const std::vector<adaption::Info> & info);
 
    void dumpDecomposition();
    void restoreDecomposition();
 
    void reconstructFields(pod::PODField &field, pod::PODField &recon);
    void reconstructFields(const std::vector<std::vector<double>> &coeffMatrix, pod::PODField &recon);
    void reconstructFields(PiercedStorage<double> &fields, VolumeKernel *mesh,
                           std::map<std::string, std::size_t> targetFields,
                           const std::unordered_set<long> *targetCells);
 
    std::vector<std::vector<double>> projectField(pod::PODField &field);
 
    void dumpField(const std::string &name, const pod::PODField &field) const;
 
    std::vector<double> fieldsl2norm(pod::PODField &snap);
    std::vector<double> fieldsMax(pod::PODField &snap);
 
    void write(const pod::PODField &snap, std::string file_name) const;
    void write(int mode_index, std::string file_name);
 
private:
    std::unique_ptr<PODKernel>              m_podkernel;                
    MeshType                                m_meshType;                 
    bool                                    m_staticMesh;               
    bool                                    m_useMean;                  
    std::string                             m_directory;                
    std::string                             m_name;                     
    std::vector<pod::SnapshotFile>          m_database;                 
    std::vector<pod::SnapshotFile>          m_reconstructionDatabase;   
    std::vector<pod::SnapshotFile>          m_leave1outOffDatabase;     
    std::size_t                             m_nSnapshots;               
    std::size_t                             m_nReconstructionSnapshots; 
    std::size_t                             m_nScalarFields;            
    std::size_t                             m_nVectorFields;            
    std::size_t                             m_nFields;                  
    std::vector<std::string>                m_nameScalarFields;         
    std::vector<std::array<std::string,3>>  m_nameVectorFields;         
    std::map<std::string, std::size_t>      m_nameTargetErrorFields;    
    bool                                    m_toUpdate;                 
    PiercedStorage<bool>                    m_filter;                   
    PiercedStorage<bool>                    m_sensorMask;               
    pod::PODMode                            m_mean;                     
    pod::PODField                           m_errorMap;                 
    std::vector<pod::PODMode>               m_modes;                    
    std::size_t                             m_nModes;                   
    double                                  m_energyLevel;              
    double                                  m_errorThreshold;           
    std::vector<std::vector<double>>               m_correlationMatrices;   
    std::vector<std::vector<double>>               m_minimizationMatrices;  
    std::vector<std::vector<double>>               m_lambda;                
    std::vector<std::vector<std::vector<double>>>  m_podCoeffs;             
    std::vector<std::vector<double>>               m_reconstructionCoeffs;  
    std::unordered_set<long int>                   m_listActiveIDs;           
    std::vector<std::size_t>                       m_listActiveIDsLeave1out;  
    std::size_t                                    m_sizeInternal;            
#if BITPIT_ENABLE_MPI
    MPI_Comm            m_communicator; 
#endif
    int                 m_rank;         
    int                 m_nProcs;       
    //pod options
    MemoryMode          m_memoryMode;           
    RunMode             m_runMode;              
    WriteMode           m_writeMode;            
    ReconstructionMode  m_reconstructionMode;   
    ErrorMode           m_errorMode;            
    bool                m_expert;               
    std::vector<std::size_t>    _m_nr;  
    const static int    ARCHIVE_VERSION = 0;
 
    const double    ENERGY_CHECK_TOLERANCE = 1.0e-12;  
    void _evalMeanMesh();
    void checkModeCount(double *alambda, std::size_t ifield);
    void _evalModes();
    void initCorrelation();
    void evalCorrelationTerm(int i, pod::PODField &snapi, int j, pod::PODField &snapj);
    void initErrorMaps();
    void buildErrorMaps(pod::PODField &snap, pod::PODField &recon);    
    void evalMinimizationMatrices();
    void initMinimization();
    void solveMinimization(std::vector<std::vector<double>> &rhs);
 
    void dumpMode(std::size_t ir);
 
    void readMode(std::size_t ir);
 
    double getCellVolume(long id);
    double getRawCellVolume(long rawIndex);
 
    void diff(pod::PODField * _a, const pod::PODMode &b);
    void sum(pod::PODField * _a, const pod::PODMode &b);
 
#if BITPIT_ENABLE_MPI
    void initializeCommunicator(MPI_Comm communicator);
    MPI_Comm getCommunicator() const;
    bool isCommunicatorSet() const;
    void freeCommunicator();
#endif
 
    void evalReconstructionCoeffs(pod::PODField &snapi);
    void evalReconstructionCoeffs(PiercedStorage<double> &fields,
            const std::vector<std::size_t> &scalarIds, const std::vector<std::size_t> &podscalarIds,
            const std::vector<std::array<std::size_t, 3>> &vectorIds, const std::vector<std::size_t> &podvectorIds);
    void buildFields(const std::vector<std::vector<double>> &reconstructionCoeffs, pod::PODField &recon);
    void buildFields(const std::vector<std::vector<double>> &reconstructionCoeffs, PiercedStorage<double> &fields,
            const std::vector<std::size_t> &scalarIds, const std::vector<std::size_t> &podscalarIds,
            const std::vector<std::array<std::size_t, 3>> &vectorIds, const std::vector<std::size_t> &podvectorIds,
            const std::unordered_set<long> *targetCells = nullptr);
 
    void _computeMapper(const VolumeKernel * mesh);
    void _adaptionAlter(const std::vector<adaption::Info> & info);
 
    void diff(PiercedStorage<double> &fields, const pod::PODMode &mode,
            const std::vector<std::size_t> &scalarIds, const std::vector<std::size_t> &podscalarIds,
            const std::vector<std::array<std::size_t, 3>> &vectorIds, const std::vector<std::size_t> &podvectorIds,
            const std::unordered_set<long> *targetCells = nullptr);
    void sum(PiercedStorage<double> &fields, const pod::PODMode &mode,
            const std::vector<std::size_t> &scalarIds, const std::vector<std::size_t> &podscalarIds,
            const std::vector<std::array<std::size_t, 3>> &vectorIds, const std::vector<std::size_t> &podvectorIds,
            const std::unordered_set<long> *targetCells = nullptr);
 
};
 
}
 
#endif