Probe.h

Go to the documentation of this file.

//=======================================================================================
// ____          ____    __    ______     __________   __      __       __        __
// \    \       |    |  |  |  |   _   \  |___    ___| |  |    |  |     /  \      |  |
//  \    \      |    |  |  |  |  |_)   |     |  |     |  |    |  |    /    \     |  |
//   \    \     |    |  |  |  |   _   /      |  |     |  |    |  |   /  /\  \    |  |
//    \    \    |    |  |  |  |  | \  \      |  |     |   \__/   |  /  ____  \   |  |____
//     \    \   |    |  |__|  |__|  \__\     |__|      \________/  /__/    \__\  |_______|
//      \    \  |    |   ________________________________________________________________
//       \    \ |    |  |  ______________________________________________________________|
//        \    \|    |  |  |         __          __     __     __     ______      _______
//         \         |  |  |_____   |  |        |  |   |  |   |  |   |   _  \    /  _____)
//          \        |  |   _____|  |  |        |  |   |  |   |  |   |  | \  \   \_______
//           \       |  |  |        |  |_____   |   \_/   |   |  |   |  |_/  /    _____  |
//            \ _____|  |__|        |________|   \_______/    |__|   |______/    (_______/
//
//  This file is part of VirtualFluids. VirtualFluids 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.
//
//  VirtualFluids 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.
//
//  SPDX-License-Identifier: GPL-3.0-or-later
//  SPDX-FileCopyrightText: Copyright © VirtualFluids Project contributors, see AUTHORS.md in root folder
//
//=======================================================================================
 
#ifndef Probe_H
#define Probe_H
 
#include "Samplers/Sampler.h"
 
#include <string>
 
#include <basics/DataTypes.h>
#include <basics/PointerDefinitions.h>
#include <basics/geometry3d/GbObject3D.h>
#include <basics/writer/WbWriterVtkXmlBinary.h>
 
namespace vf::gpu {
 
struct LBMSimulationParameter;
class Parameter;
class CudaMemoryManager;
 
class Probe : public Sampler
{
public:
    enum class Statistic { Instantaneous, Means, Variances };
    Probe(std::shared_ptr<Parameter> para, std::shared_ptr<CudaMemoryManager> cudaMemoryManager, const std::string& outputPath,
          const std::string& probeName, uint tStartSampling, uint tBetweenSamples, uint tStartWritingOutput, uint tBetweenWriting,
          bool outputTimeSeries, bool sampleEveryTimestep, bool sampleScalar = false);
    ~Probe() override;
 
    void addProbePlane(real startX, real startY, real startZ, real length, real width, real height);
    void addProbePoint(real x, real y, real z);
    void addProbePointsFromList(std::vector<real> coordsX, std::vector<real> coordY, std::vector<real> coordZ);
    void addProbeVolume(const std::shared_ptr<GbObject3D>& probeVolume);
    void addStatistic(Statistic variable);
    void addAllAvailableStatistics()
    {
        addStatistic(Statistic::Instantaneous);
        addStatistic(Statistic::Means);
        addStatistic(Statistic::Variances);
    }
 
    void setFileNameToNOut()
    {
        this->fileNameLU = false;
    }
    void init() override;
    void sample(int level, uint t) override;
    void getTaggedFluidNodes(GridProvider* gridProvider) override;
 
    struct PostProcessingVariable;
    struct ProbeData;
    struct TimeseriesParams;
    struct LevelData;
 
    LevelData* getLevelData(int level)
    {
        return &levelDatas[level];
    }
 
    struct GridParams;
    static GridParams getGridParams(LBMSimulationParameter* para);
 
private:
    void addLevelData(int level);
    void addPointsToLevelData(LevelData& levelData, std::vector<uint>& indices, int level);
 
    WbWriterVtkXmlBinary* getWriter()
    {
        return WbWriterVtkXmlBinary::getInstance();
    };
    std::vector<PostProcessingVariable> getPostProcessingVariables(Statistic statistic, int level) const;
    std::vector<PostProcessingVariable> getAllPostProcessingVariables(int level) const;
 
    void writeParallelFile(int t);
    void writeGridFiles(int level, int t);
    void writeGridFile(int level, int t, uint part);
    void appendStatisticToNodeData(Statistic statistic, uint startPos, uint endPos, uint timestep, int level,
                                   std::vector<std::vector<double>>& nodeData);
    void appendTimeseriesFile(int level, int t);
    void appendStatisticToTimestepData(int timestep, std::vector<real>& timestepData, Statistic statistic, int level);
 
    std::vector<real> getTimestepData(real time, int timestep, int level);
 
    std::vector<std::string> getVarNames();
 
    uint getNumberOfTimestepsInTimeseries(int level)
    {
        if (outputTimeSeries)
            return tBetweenWriting * exp2(level);
        return 1;
    }
 
protected:
    SPtr<Parameter> para;
    SPtr<CudaMemoryManager> cudaMemoryManager;
    std::vector<LevelData> levelDatas;
    bool enableComputationInstantaneous {}, enableComputationMeans {}, enableComputationVariances {};
    const bool sampleScalar;
    const bool outputTimeSeries, sampleEveryTimestep;
    std::vector<std::string> fileNamesForCollectionFile;
    std::vector<std::string> timeseriesFileNames;
 
    bool fileNameLU = true;
 
    const uint tStartSampling;
    const uint tBetweenSamples;
    const uint tStartWritingOutput;
    const uint tBetweenWriting;
    std::vector<std::shared_ptr<GbObject3D>> probeObjects;
};
 
struct Probe::PostProcessingVariable
{
    std::string name;
    real conversionFactor;
    PostProcessingVariable(std::string name, real conversionFactor) : name(name), conversionFactor(conversionFactor)
    {
    }
};
 
struct Probe::ProbeData
{
    real *instantaneous, *means, *variances;
    bool computeInstantaneous, computeMeans, computeVariances, sampleScalar;
    uint numberOfPoints, numberOfQuantities, numberOfTimesteps;
    uint* indices;
    __device__ __host__ ProbeData(bool computeInstantaneous, bool computeMeans, bool computeVariance, bool sampleScalar,
                                  uint numberOfPoints, uint numberOfQuantities, uint numberOfTimesteps)
        : computeInstantaneous(computeInstantaneous), computeMeans(computeMeans), computeVariances(computeVariance),
          sampleScalar(sampleScalar), numberOfPoints(numberOfPoints), numberOfQuantities(numberOfQuantities),
          numberOfTimesteps(numberOfTimesteps)
    {
    }
};
 
struct Probe::TimeseriesParams
{
    uint currentTimestep {}, numberOfTimesteps {}, lastTimestepInOldTimeseries {};
};
 
struct Probe::LevelData
{
    ProbeData probeDataH, probeDataD;
    TimeseriesParams timeseriesParams;
    std::vector<real> coordinatesX, coordinatesY, coordinatesZ;
    uint numberOfAveragedValues {};
    LevelData(ProbeData probeDataH, ProbeData probeDataD, std::vector<real> coordinatesX, std::vector<real> coordinatesY,
              std::vector<real> coordinatesZ)
        : probeDataH(probeDataH), probeDataD(probeDataD), coordinatesX(std::move(coordinatesX)), coordinatesY(std::move(coordinatesY)),
          coordinatesZ(std::move(coordinatesZ))
    {
    }
};
 
struct Probe::GridParams
{
    real *velocityX, *velocityY, *velocityZ, *density, *scalar;
};
 
void removeInterpolationCells(std::vector<uint>& indices, Parameter* para, int level);
void removeReceiveNodes(std::vector<uint>& indices, Parameter* para, int level);
 
}
#endif