from_json_check_result_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_FROM_JSON_CHECK_RESULT_PROCESS_H_INCLUDED )
#define  KRATOS_FROM_JSON_CHECK_RESULT_PROCESS_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "processes/process.h"
#include "includes/model_part.h"
#include "includes/kratos_parameters.h"
#include "utilities/result_dabatase.h"
 
namespace Kratos
{
 
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) FromJSONCheckResultProcess
    : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(FromJSONCheckResultProcess);
 
    KRATOS_DEFINE_LOCAL_FLAG( CORRECT_RESULT );                 
    KRATOS_DEFINE_LOCAL_FLAG( HISTORICAL_VALUE );               
    KRATOS_DEFINE_LOCAL_FLAG( CHECK_ONLY_LOCAL_ENTITIES );      
    KRATOS_DEFINE_LOCAL_FLAG( NODES_CONTAINER_INITIALIZED );    
    KRATOS_DEFINE_LOCAL_FLAG( ELEMENTS_CONTAINER_INITIALIZED ); 
    KRATOS_DEFINE_LOCAL_FLAG( NODES_DATABASE_INITIALIZED );     
    KRATOS_DEFINE_LOCAL_FLAG( ELEMENTS_DATABASE_INITIALIZED );  
 
    typedef ModelPart::NodesContainerType              NodesArrayType;
    typedef ModelPart::ElementsContainerType        ElementsArrayType;
 
    typedef Node NodeType;
 
    typedef std::size_t IndexType;
 
    typedef std::size_t SizeType;
 
 
    FromJSONCheckResultProcess(
        Model& rModel,
        Parameters ThisParameters = Parameters(R"({})")
        );
 
    FromJSONCheckResultProcess(
        ModelPart& rModelPart,
        Parameters ThisParameters = Parameters(R"({})")
        );
 
    virtual ~FromJSONCheckResultProcess() {}
 
 
    void operator()()
    {
        Execute();
    }
 
 
    void ExecuteInitialize() override;
 
    void ExecuteFinalizeSolutionStep() override;
 
    void ExecuteFinalize() override;
 
    int Check() override;
 
    bool IsCorrectResult()
    {
        return this->Is(CORRECT_RESULT);
    }
 
    std::string GetErrorMessage()
    {
        return mErrorMessage;
    }
 
 
    std::string Info() const override
    {
        return "FromJSONCheckResultProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "FromJSONCheckResultProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
protected:
 
    void InitializeDatabases();
 
    void FillVariablesList(
        const std::vector<std::string>& rNodalVariablesNames,
        const std::vector<std::string>& rGPVariablesNames
        );
 
    template<class TEntity>
    bool CheckFlag(
        const TEntity& rEntity,
        const Flags* pFlag
        )
    {
        if (pFlag != nullptr) {
            if (rEntity.IsNot(*pFlag)) {
                return false;
            }
        }
        return true;
    }
 
    bool CheckValues(
        const double ValueEntity,
        const double ValueJSON
        );
 
    void FailMessage(
        const IndexType EntityId,
        const std::string& rEntityType,
        const double ValueEntity,
        const double ValueJSON,
        const std::string& rVariableName,
        const int ComponentIndex = -1,
        const int GPIndex = -1
        );
 
    void CheckNodeValues(IndexType& rCheckCounter);
 
    void CheckNodeHistoricalValues(IndexType& rCheckCounter);
 
    void CheckGPValues(IndexType& rCheckCounter);
 
    SizeType SizeDatabase(
        const Parameters& rResults,
        const NodesArrayType& rNodesArray,
        const ElementsArrayType& rElementsArray
        );
 
    void FillDatabase(
        const Parameters& rResults,
        const NodesArrayType& rNodesArray,
        const ElementsArrayType& rElementsArray,
        const SizeType NumberOfGP
        );
 
    std::string GetNodeIdentifier(NodeType& rNode);
 
    NodesArrayType& GetNodes(const Flags* pFlag = nullptr);
 
    ElementsArrayType& GetElements(const Flags* pFlag = nullptr);
 
    std::size_t ComputeRelevantDigits(const double Value);
 
    const Parameters GetDefaultParameters() const override;
 
 
    const ModelPart& GetModelPart() const;
 
    const Parameters GetSettings() const;
 
    const ResultDatabase& GetNodeDatabase();
 
    const ResultDatabase& GetGPDatabase();
 
 
    FromJSONCheckResultProcess(ModelPart& rModelPart, Parameters Settings, Parameters DefaultSettings);
 
 
private:
 
    /* Model part and different settings */
    ModelPart& mrModelPart;         
    Parameters mThisParameters;     
 
    /* Additional values */
    double mFrequency;              
    double mRelativeTolerance;      
    double mAbsoluteTolerance;      
    SizeType mRelevantDigits;       
 
    /* Counters */
    double mTimeCounter = 0.0;      
 
    /* The entities of the containers */
    NodesArrayType mNodesArray;       
    ElementsArrayType mElementsArray; 
 
    /* The vectors storing the variables of study */
    std::vector<const Variable<double>*> mpNodalVariableDoubleList;                     
    std::vector<const Variable<array_1d<double,3>>*> mpNodalVariableArrayList;          
    std::vector<const Variable<Vector>*> mpNodalVariableVectorList;                     
 
    std::vector<const Variable<double>*> mpGPVariableDoubleList;                        
    std::vector<const Variable<array_1d<double,3>>*> mpGPVariableArrayList;             
    std::vector<const Variable<Vector>*> mpGPVariableVectorList;                        
 
    /* The databases which store the values */
    ResultDatabase mDatabaseNodes;  
    ResultDatabase mDatabaseGP;     
 
    /* Error message */
    std::string mErrorMessage = "";
 
 
 
    FromJSONCheckResultProcess& operator=(FromJSONCheckResultProcess const& rOther);
 
 
}; // Class FromJSONCheckResultProcess
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  FromJSONCheckResultProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const FromJSONCheckResultProcess& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_FROM_JSON_CHECK_RESULT_PROCESS_H_INCLUDED  defined