diff --git a/kratos/linear_solvers/power_iteration_eigenvalue_solver.h b/kratos/linear_solvers/power_iteration_eigenvalue_solver.h index 5c638736381d..22c4d8b8af01 100644 --- a/kratos/linear_solvers/power_iteration_eigenvalue_solver.h +++ b/kratos/linear_solvers/power_iteration_eigenvalue_solver.h @@ -20,8 +20,6 @@ #include #include #include -#include -#include // External includes @@ -31,6 +29,7 @@ #include "processes/process.h" #include "includes/define.h" #include "linear_solvers/iterative_solver.h" +#include "utilities/random_initializer_utility.h" namespace Kratos { @@ -53,123 +52,6 @@ namespace Kratos ///@} ///@name Kratos Classes ///@{ - -/// Utility to initialize a random vector -/** - * Defines several utility functions - */ -template -class RandomInitializeUtil -{ -public: - - ///@name Type Definitions - ///@{ - - typedef UblasSpace SparseSpaceType; - - typedef UblasSpace LocalSpaceType; - - typedef typename SparseSpaceType::MatrixType SparseMatrixType; - - typedef typename SparseSpaceType::VectorType VectorType; - - typedef typename LocalSpaceType::MatrixType DenseMatrixType; - - typedef typename LocalSpaceType::VectorType DenseVectorType; - - typedef std::size_t SizeType; - - ///@} - ///@name Life Cycle - ///@{ - - ///@} - ///@name Operators - ///@{ - - - ///@} - ///@name Operations - ///@{ - - static inline void RandomInitialize( - const SparseMatrixType& K, - DenseVectorType& R, - const bool Inverse = false - ) - { - // We create a random vector as seed of the method - std::random_device this_random_device; - std::mt19937 generator(this_random_device()); - - const SizeType size = K.size1(); - const TDataType normK = SparseSpaceType::TwoNorm(K); - const TDataType aux_value = (Inverse == false) ? normK : 1.0/normK; - std::normal_distribution<> normal_distribution(aux_value, 0.25 * aux_value); - - for (SizeType i = 0; i < size; i++) - { - R[i] = normal_distribution(generator); - } - } - - ///@} - ///@name Access - ///@{ - - - ///@} - ///@name Inquiry - ///@{ - - - ///@} - ///@name Input and output - ///@{ - - ///@} - ///@name Friends - ///@{ - -private: - - ///@name Private static Member Variables - ///@{ - - ///@} - ///@name Private member Variables - ///@{ - - ///@} - ///@name Private Operators - ///@{ - - ///@} - ///@name Private Operations - ///@{ - - ///@} - ///@name Private Access - ///@{ - - ///@} - ///@name Private Inquiry - ///@{ - - ///@} - ///@name Private LifeCycle - ///@{ - - ///@} - ///@name Unaccessible methods - ///@{ - - RandomInitializeUtil(void); - - RandomInitializeUtil(RandomInitializeUtil& rSource); - -}; /* Class RandomInitializeUtil */ /// This class uses the inverted power iteration method to obtain the lowest eigenvalue of a system /** Basically that @@ -296,7 +178,7 @@ class PowerIterationEigenvalueSolver : public IterativeSolver::RandomInitialize(K, y); + RandomInitializeUtility::RandomInitialize(K, y); if(Eigenvalues.size() < 1) { @@ -517,342 +399,6 @@ class PowerIterationEigenvalueSolver : public IterativeSolver, - class TReordererType = Reorderer > -class PowerIterationHighestEigenvalueSolver : public IterativeSolver -{ -public: - ///@name Type Definitions - ///@{ - - /// Pointer definition of PowerIterationHighestEigenvalueSolver - KRATOS_CLASS_POINTER_DEFINITION(PowerIterationHighestEigenvalueSolver); - - typedef IterativeSolver BaseType; - - typedef typename TSparseSpaceType::MatrixType SparseMatrixType; - - typedef typename TSparseSpaceType::VectorType VectorType; - - typedef typename TDenseSpaceType::MatrixType DenseMatrixType; - - typedef typename TDenseSpaceType::VectorType DenseVectorType; - - typedef std::size_t SizeType; - - typedef std::size_t IndexType; - - ///@} - ///@name Life Cycle - ///@{ - - /// Default constructor. - PowerIterationHighestEigenvalueSolver() {} - - PowerIterationHighestEigenvalueSolver( - double MaxTolerance, - unsigned int MaxIterationNumber, - unsigned int RequiredEigenvalueNumber, - typename TLinearSolverType::Pointer pLinearSolver - ): BaseType(MaxTolerance, MaxIterationNumber), - mRequiredEigenvalueNumber(RequiredEigenvalueNumber), - mpLinearSolver(pLinearSolver) - { - - } - - PowerIterationHighestEigenvalueSolver( - Parameters ThisParameters, - typename TLinearSolverType::Pointer pLinearSolver - ): mpLinearSolver(pLinearSolver) - { - Parameters DefaultParameters = Parameters(R"( - { - "solver_type" : "power_iteration_highest_eigenvalue_solver", - "max_iteration" : 10000, - "tolerance" : 1e-8, - "required_eigen_number" : 1, - "shifting_convergence" : 0.25, - "verbosity" : 1, - "linear_solver_settings" : {} - })" ); - - ThisParameters.ValidateAndAssignDefaults(DefaultParameters); - - mRequiredEigenvalueNumber = ThisParameters["required_eigen_number"].GetInt(); - mEchoLevel = ThisParameters["verbosity"].GetInt(); - BaseType::SetTolerance( ThisParameters["tolerance"].GetDouble() ); - BaseType::SetMaxIterationsNumber( ThisParameters["max_iteration"].GetInt() ); - } - - /// Copy constructor. - PowerIterationHighestEigenvalueSolver(const PowerIterationHighestEigenvalueSolver& Other) : BaseType(Other) - { - - } - - - /// Destructor. - ~PowerIterationHighestEigenvalueSolver() override - { - - } - - - ///@} - ///@name Operators - ///@{ - - /// Assignment operator. - PowerIterationHighestEigenvalueSolver& operator=(const PowerIterationHighestEigenvalueSolver& Other) - { - BaseType::operator=(Other); - return *this; - } - - ///@} - ///@name Operations - ///@{ - - /** - * The power iteration algorithm - * @param K: The stiffness matrix - * @param M: The mass matrix - * @param Eigenvalues: The vector containing the eigen values - * @param Eigenvectors: The matrix containing the eigen vectors - */ - void Solve( - SparseMatrixType& K, - SparseMatrixType& M, - DenseVectorType& Eigenvalues, - DenseMatrixType& Eigenvectors - ) override - { - using boost::numeric::ublas::trans; - - const SizeType size = K.size1(); - const SizeType max_iteration = BaseType::GetMaxIterationsNumber(); - const double tolerance = BaseType::GetTolerance(); - - VectorType x = ZeroVector(size); - VectorType y = ZeroVector(size); - - RandomInitializeUtil::RandomInitialize(K, y); - - if(Eigenvalues.size() < 1) - { - Eigenvalues.resize(1, 0.0); - } - - // Starting with first step - double ro = 0.0; - double old_ro = Eigenvalues[0]; - VectorType y_old = ZeroVector(size); - - if (mEchoLevel > 1) - { - std::cout << "Iteration ro \t\t convergence norm" << std::endl; - } - - for(SizeType i = 0 ; i < max_iteration ; i++) - { - // x = K*y - TSparseSpaceType::Mult(K, y, x); - - // y = M*x - TSparseSpaceType::Mult(M, x, y); - - ro = static_cast(*boost::max_element(y)); - - TSparseSpaceType::InplaceMult(y, 1.0/ro); - - if(ro == 0.0) - { - KRATOS_ERROR << "Perpendicular eigenvector to M" << std::endl; - } - - const double convergence_ro = std::abs((ro - old_ro) / ro); - const double convergence_norm = TSparseSpaceType::TwoNorm(y - y_old)/TSparseSpaceType::TwoNorm(y); - - if (mEchoLevel > 1) - { - std::cout << "Iteration: " << i << "\tro: " << ro << " \tConvergence norm: " << convergence_norm << " \tConvergence ro: " << convergence_ro << std::endl; - } - - if(convergence_norm < tolerance || convergence_ro < tolerance) - { - break; - } - - old_ro = ro; - TSparseSpaceType::Assign(y_old, 1.0, y); - } - - if (mEchoLevel > 0) - { - KRATOS_WATCH(ro); - KRATOS_WATCH(y); - } - - Eigenvalues[0] = ro; - - if((Eigenvectors.size1() < 1) || (Eigenvectors.size2() < size)) - { - Eigenvectors.resize(1,size); - } - - for(SizeType i = 0 ; i < size ; i++) - { - Eigenvectors(0,i) = y[i]; - } - } - - /** - * This method returns directly the first eigen value obtained - * @param K: The stiffness matrix - * @param M: The mass matrix - * @return The first eigenvalue - */ - double GetEigenValue( - SparseMatrixType& K, - SparseMatrixType& M - ) - { - DenseVectorType eigen_values; - DenseMatrixType eigen_vectors; - - Solve(K, M, eigen_values, eigen_vectors); - - return eigen_values[0]; - } - - ///@} - ///@name Access - ///@{ - - - ///@} - ///@name Inquiry - ///@{ - - - ///@} - ///@name Input and output - ///@{ - - /// Turn back information as a string. - std::string Info() const override - { - std::stringstream buffer; - buffer << "Power iteration eigenvalue solver with " << BaseType::GetPreconditioner()->Info(); - return buffer.str(); - } - - /// Print information about this object. - void PrintInfo(std::ostream& rOStream) const override - { - rOStream << Info(); - } - - /// Print object's data. - void PrintData(std::ostream& rOStream) const override - { - BaseType::PrintData(rOStream); - } - - - ///@} - ///@name Friends - ///@{ - - - ///@} - -protected: - ///@name Protected static Member Variables - ///@{ - - - ///@} - ///@name Protected member Variables - ///@{ - - - ///@} - ///@name Protected Operators - ///@{ - - - ///@} - ///@name Protected Operations - ///@{ - - - ///@} - ///@name Protected Access - ///@{ - - - ///@} - ///@name Protected Inquiry - ///@{ - - - ///@} - ///@name Protected LifeCycle - ///@{ - - - ///@} - -private: - ///@name Static Member Variables - ///@{ - - - ///@} - ///@name Member Variables - ///@{ - - unsigned int mRequiredEigenvalueNumber; - - unsigned int mEchoLevel; - - typename TLinearSolverType::Pointer mpLinearSolver; - - ///@} - ///@name Private Operators - ///@{ - - - ///@} - ///@name Private Operations - ///@{ - - - ///@} - ///@name Private Access - ///@{ - - - ///@} - ///@name Private Inquiry - ///@{ - - - ///@} - ///@name Un accessible methods - ///@{ - - - ///@} - -}; // Class PowerIterationHighestEigenvalueSolver - ///@} ///@name Type Definitions diff --git a/kratos/linear_solvers/power_iteration_highest_eigenvalue_solver.h b/kratos/linear_solvers/power_iteration_highest_eigenvalue_solver.h new file mode 100644 index 000000000000..4c5666efe0d0 --- /dev/null +++ b/kratos/linear_solvers/power_iteration_highest_eigenvalue_solver.h @@ -0,0 +1,432 @@ +// | / | +// ' / __| _` | __| _ \ __| +// . \ | ( | | ( |\__ ` +// _|\_\_| \__,_|\__|\___/ ____/ +// Multi-Physics +// +// License: BSD License +// Kratos default license: kratos/license.txt +// +// Main authors: Vicente Mataix Ferrandiz +// +// + +#if !defined(KRATOS_POWER_ITERATION_HIGHEST_EIGENVALUE_SOLVER_H_INCLUDED ) +#define KRATOS_POWER_ITERATION_HIGHEST_EIGENVALUE_SOLVER_H_INCLUDED + +// System includes +#include +#include +#include +#include + +// External includes + +// Project includes +#include "spaces/ublas_space.h" +#include "includes/ublas_interface.h" +#include "processes/process.h" +#include "includes/define.h" +#include "linear_solvers/iterative_solver.h" +#include "utilities/random_initializer_utility.h" + +namespace Kratos +{ + +///@name Kratos Globals +///@{ + +///@} +///@name Type Definitions +///@{ + +///@} +///@name Enum's +///@{ + +///@} +///@name Functions +///@{ + +///@} +///@name Kratos Classes +///@{ + +/// This class uses the inverted power iteration method to obtain the lowest eigenvalue of a system +/** Basically that +*/ +template, + class TReordererType = Reorderer > +class PowerIterationHighestEigenvalueSolver : public IterativeSolver +{ +public: + ///@name Type Definitions + ///@{ + + /// Pointer definition of PowerIterationHighestEigenvalueSolver + KRATOS_CLASS_POINTER_DEFINITION(PowerIterationHighestEigenvalueSolver); + + typedef IterativeSolver BaseType; + + typedef typename TSparseSpaceType::MatrixType SparseMatrixType; + + typedef typename TSparseSpaceType::VectorType VectorType; + + typedef typename TDenseSpaceType::MatrixType DenseMatrixType; + + typedef typename TDenseSpaceType::VectorType DenseVectorType; + + typedef std::size_t SizeType; + + typedef std::size_t IndexType; + + ///@} + ///@name Life Cycle + ///@{ + + /// Default constructor. + PowerIterationHighestEigenvalueSolver() {} + + PowerIterationHighestEigenvalueSolver( + double MaxTolerance, + unsigned int MaxIterationNumber, + unsigned int RequiredEigenvalueNumber, + typename TLinearSolverType::Pointer pLinearSolver + ): BaseType(MaxTolerance, MaxIterationNumber), + mRequiredEigenvalueNumber(RequiredEigenvalueNumber), + mpLinearSolver(pLinearSolver) + { + + } + + PowerIterationHighestEigenvalueSolver( + Parameters ThisParameters, + typename TLinearSolverType::Pointer pLinearSolver + ): mpLinearSolver(pLinearSolver) + { + Parameters DefaultParameters = Parameters(R"( + { + "solver_type" : "power_iteration_highest_eigenvalue_solver", + "max_iteration" : 10000, + "tolerance" : 1e-8, + "required_eigen_number" : 1, + "shifting_convergence" : 0.25, + "verbosity" : 1, + "linear_solver_settings" : {} + })" ); + + ThisParameters.ValidateAndAssignDefaults(DefaultParameters); + + mRequiredEigenvalueNumber = ThisParameters["required_eigen_number"].GetInt(); + mEchoLevel = ThisParameters["verbosity"].GetInt(); + BaseType::SetTolerance( ThisParameters["tolerance"].GetDouble() ); + BaseType::SetMaxIterationsNumber( ThisParameters["max_iteration"].GetInt() ); + } + + /// Copy constructor. + PowerIterationHighestEigenvalueSolver(const PowerIterationHighestEigenvalueSolver& Other) : BaseType(Other) + { + + } + + + /// Destructor. + ~PowerIterationHighestEigenvalueSolver() override + { + + } + + + ///@} + ///@name Operators + ///@{ + + /// Assignment operator. + PowerIterationHighestEigenvalueSolver& operator=(const PowerIterationHighestEigenvalueSolver& Other) + { + BaseType::operator=(Other); + return *this; + } + + ///@} + ///@name Operations + ///@{ + + /** + * The power iteration algorithm + * @param K: The stiffness matrix + * @param M: The mass matrix + * @param Eigenvalues: The vector containing the eigen values + * @param Eigenvectors: The matrix containing the eigen vectors + */ + void Solve( + SparseMatrixType& K, + SparseMatrixType& M, + DenseVectorType& Eigenvalues, + DenseMatrixType& Eigenvectors + ) override + { + using boost::numeric::ublas::trans; + + const SizeType size = K.size1(); + const SizeType max_iteration = BaseType::GetMaxIterationsNumber(); + const double tolerance = BaseType::GetTolerance(); + + VectorType x = ZeroVector(size); + VectorType y = ZeroVector(size); + + RandomInitializeUtility::RandomInitialize(K, y); + + if(Eigenvalues.size() < 1) + { + Eigenvalues.resize(1, 0.0); + } + + // Starting with first step + double ro = 0.0; + double old_ro = Eigenvalues[0]; + VectorType y_old = ZeroVector(size); + + if (mEchoLevel > 1) + { + std::cout << "Iteration ro \t\t convergence norm" << std::endl; + } + + for(SizeType i = 0 ; i < max_iteration ; i++) + { + // x = K*y + TSparseSpaceType::Mult(K, y, x); + + // y = M*x + TSparseSpaceType::Mult(M, x, y); + + ro = static_cast(*boost::max_element(y)); + + TSparseSpaceType::InplaceMult(y, 1.0/ro); + + if(ro == 0.0) + { + KRATOS_ERROR << "Perpendicular eigenvector to M" << std::endl; + } + + const double convergence_ro = std::abs((ro - old_ro) / ro); + const double convergence_norm = TSparseSpaceType::TwoNorm(y - y_old)/TSparseSpaceType::TwoNorm(y); + + if (mEchoLevel > 1) + { + std::cout << "Iteration: " << i << "\tro: " << ro << " \tConvergence norm: " << convergence_norm << " \tConvergence ro: " << convergence_ro << std::endl; + } + + if(convergence_norm < tolerance || convergence_ro < tolerance) + { + break; + } + + old_ro = ro; + TSparseSpaceType::Assign(y_old, 1.0, y); + } + + if (mEchoLevel > 0) + { + KRATOS_WATCH(ro); + KRATOS_WATCH(y); + } + + Eigenvalues[0] = ro; + + if((Eigenvectors.size1() < 1) || (Eigenvectors.size2() < size)) + { + Eigenvectors.resize(1,size); + } + + for(SizeType i = 0 ; i < size ; i++) + { + Eigenvectors(0,i) = y[i]; + } + } + + /** + * This method returns directly the first eigen value obtained + * @param K: The stiffness matrix + * @param M: The mass matrix + * @return The first eigenvalue + */ + double GetEigenValue( + SparseMatrixType& K, + SparseMatrixType& M + ) + { + DenseVectorType eigen_values; + DenseMatrixType eigen_vectors; + + Solve(K, M, eigen_values, eigen_vectors); + + return eigen_values[0]; + } + + ///@} + ///@name Access + ///@{ + + + ///@} + ///@name Inquiry + ///@{ + + + ///@} + ///@name Input and output + ///@{ + + /// Turn back information as a string. + std::string Info() const override + { + std::stringstream buffer; + buffer << "Power iteration eigenvalue solver with " << BaseType::GetPreconditioner()->Info(); + return buffer.str(); + } + + /// Print information about this object. + void PrintInfo(std::ostream& rOStream) const override + { + rOStream << Info(); + } + + /// Print object's data. + void PrintData(std::ostream& rOStream) const override + { + BaseType::PrintData(rOStream); + } + + + ///@} + ///@name Friends + ///@{ + + + ///@} + +protected: + ///@name Protected static Member Variables + ///@{ + + + ///@} + ///@name Protected member Variables + ///@{ + + + ///@} + ///@name Protected Operators + ///@{ + + + ///@} + ///@name Protected Operations + ///@{ + + + ///@} + ///@name Protected Access + ///@{ + + + ///@} + ///@name Protected Inquiry + ///@{ + + + ///@} + ///@name Protected LifeCycle + ///@{ + + + ///@} + +private: + ///@name Static Member Variables + ///@{ + + + ///@} + ///@name Member Variables + ///@{ + + unsigned int mRequiredEigenvalueNumber; + + unsigned int mEchoLevel; + + typename TLinearSolverType::Pointer mpLinearSolver; + + ///@} + ///@name Private Operators + ///@{ + + + ///@} + ///@name Private Operations + ///@{ + + + ///@} + ///@name Private Access + ///@{ + + + ///@} + ///@name Private Inquiry + ///@{ + + + ///@} + ///@name Un accessible methods + ///@{ + + + ///@} + +}; // Class PowerIterationHighestEigenvalueSolver + +///@} + +///@name Type Definitions +///@{ + + +///@} +///@name Input and output +///@{ + + +/// input stream function +template +inline std::istream& operator >> (std::istream& IStream, + PowerIterationHighestEigenvalueSolver& rThis) +{ + return IStream; +} + +/// output stream function +template +inline std::ostream& operator << (std::ostream& OStream, + const PowerIterationHighestEigenvalueSolver& rThis) +{ + rThis.PrintInfo(OStream); + OStream << std::endl; + rThis.PrintData(OStream); + + return OStream; +} +///@} + + +} // namespace Kratos. + +#endif // KRATOS_POWER_ITERATION_HIGHEST_EIGENVALUE_SOLVER_H_INCLUDED defined diff --git a/kratos/python/add_linear_solvers_to_python.cpp b/kratos/python/add_linear_solvers_to_python.cpp index 8f6857e02ed3..7187390f43b7 100644 --- a/kratos/python/add_linear_solvers_to_python.cpp +++ b/kratos/python/add_linear_solvers_to_python.cpp @@ -41,6 +41,7 @@ #include "linear_solvers/ilu0_preconditioner.h" #include "linear_solvers/ilu_preconditioner.h" #include "linear_solvers/power_iteration_eigenvalue_solver.h" +#include "linear_solvers/power_iteration_highest_eigenvalue_solver.h" #include "linear_solvers/rayleigh_quotient_iteration_eigenvalue_solver.h" #include "linear_solvers/deflated_gmres_solver.h" diff --git a/kratos/utilities/random_initializer_utility.h b/kratos/utilities/random_initializer_utility.h new file mode 100644 index 000000000000..5458b406e94b --- /dev/null +++ b/kratos/utilities/random_initializer_utility.h @@ -0,0 +1,190 @@ +// | / | +// ' / __| _` | __| _ \ __| +// . \ | ( | | ( |\__ ` +// _|\_\_| \__,_|\__|\___/ ____/ +// Multi-Physics +// +// License: BSD License +// Kratos default license: kratos/license.txt +// +// Main authors: Vicente Mataix Ferrandiz +// +// + +#if !defined(KRATOS_RANDOM_UTILITY_INITIALIZER_H_INCLUDED ) +#define KRATOS_RANDOM_UTILITY_INITIALIZER_H_INCLUDED + +// System includes + +#include +#include + +// External includes + +// Project includes +#include "spaces/ublas_space.h" +#include "includes/ublas_interface.h" + +namespace Kratos +{ + +///@name Kratos Globals +///@{ + +///@} +///@name Type Definitions +///@{ + +///@} +///@name Enum's +///@{ + +///@} +///@name Functions +///@{ + +///@} +///@name Kratos Classes +///@{ + +/// Utility to initialize a random vector +/** + * Defines several utility functions + */ +template +class RandomInitializeUtility +{ +public: + + ///@name Type Definitions + ///@{ + + typedef UblasSpace SparseSpaceType; + + typedef UblasSpace LocalSpaceType; + + typedef typename SparseSpaceType::MatrixType SparseMatrixType; + + typedef typename SparseSpaceType::VectorType VectorType; + + typedef typename LocalSpaceType::MatrixType DenseMatrixType; + + typedef typename LocalSpaceType::VectorType DenseVectorType; + + typedef std::size_t SizeType; + + ///@} + ///@name Life Cycle + ///@{ + + ///@} + ///@name Operators + ///@{ + + + ///@} + ///@name Operations + ///@{ + + /** + * This method initializes a vector using a normal normal distribution + * @param R: The vector to fill with random values + * @param MeanValue: The mean value used in the normal distribution + * @param VarianceValue: The variance value used in the normal distribution + */ + static inline void NormalDestributionRandom( + DenseVectorType& R, + const TDataType& MeanValue, + const TDataType& VarianceValue + ) + { + // We create a random vector as seed of the method + std::random_device this_random_device; + std::mt19937 generator(this_random_device()); + + std::normal_distribution<> normal_distribution(MeanValue, VarianceValue); + + for (SizeType i = 0; i < R.size(); ++i) + { + R[i] = normal_distribution(generator); + } + } + + + /** + * This method initializes a vector using a normal distribution. The mean and the variance is taken from the norm of the matrix + * @param K: The stiffness matrix + * @param R: The vector to initialize + * @param Inverse: If consider the inverse pf the matrix norm or not + */ + static inline void RandomInitialize( + const SparseMatrixType& K, + DenseVectorType& R, + const bool Inverse = false + ) + { + const TDataType normK = SparseSpaceType::TwoNorm(K); + const TDataType aux_value = (Inverse == false) ? normK : 1.0/normK; + NormalDestributionRandom(R, aux_value, 0.25 * aux_value); + } + + ///@} + ///@name Access + ///@{ + + + ///@} + ///@name Inquiry + ///@{ + + + ///@} + ///@name Input and output + ///@{ + + ///@} + ///@name Friends + ///@{ + +private: + + ///@name Private static Member Variables + ///@{ + + ///@} + ///@name Private member Variables + ///@{ + + ///@} + ///@name Private Operators + ///@{ + + ///@} + ///@name Private Operations + ///@{ + + ///@} + ///@name Private Access + ///@{ + + ///@} + ///@name Private Inquiry + ///@{ + + ///@} + ///@name Private LifeCycle + ///@{ + + ///@} + ///@name Unaccessible methods + ///@{ + + RandomInitializeUtility(void); + + RandomInitializeUtility(RandomInitializeUtility& rSource); + +}; /* Class RandomInitializeUtility */ + +} // namespace Kratos. + +#endif // KRATOS_RANDOM_UTILITY_INITIALIZER_H_INCLUDED defined