random_initializer_utility.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_RANDOM_UTILITY_INITIALIZER_H_INCLUDED )
#define  KRATOS_RANDOM_UTILITY_INITIALIZER_H_INCLUDED
 
// System includes
#include <random>
 
// External includes
 
// Project includes
#include "spaces/ublas_space.h"
 
namespace Kratos
{
 
 
 
 
 
    
template<class TDataType>
class RandomInitializeUtility
{
public:
 
 
    typedef UblasSpace<TDataType, CompressedMatrix, boost::numeric::ublas::vector<double>> SparseSpaceType;
    
    typedef UblasSpace<TDataType, Matrix, Vector> 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;
 
 
 
 
    
    static inline void NormalDestributionRandom(
        VectorType& R,
        const TDataType& MeanValue,
        const TDataType& VarianceValue
        )
    {
        // We create a random vector as seed of the method
        unsigned int seed = 1; // Constant seed
        std::default_random_engine generator(seed);
        
        std::normal_distribution<TDataType> normal_distribution(MeanValue, VarianceValue);
        
        for (SizeType i = 0; i < R.size(); ++i)
            R[i] = normal_distribution(generator);
    }
    
    
    static inline void RandomInitialize(
        const SparseMatrixType& K,
        VectorType& R,
        const bool Inverse = false 
        )
    {
        const TDataType threshold = std::numeric_limits<TDataType>::epsilon();
        const TDataType normK = SparseSpaceType::TwoNorm(K);
        const TDataType aux_value = (Inverse == false) ? normK : (normK > threshold) ? 1.0/normK : 1.0;
        NormalDestributionRandom(R, aux_value, 0.25 * aux_value);
    }
    
 
 
 
 
 
 
private:
    
 
 
 
    
 
 
 
 
    RandomInitializeUtility(void);
 
    RandomInitializeUtility(RandomInitializeUtility& rSource);
 
}; /* Class RandomInitializeUtility */
 
}  // namespace Kratos.
 
#endif // KRATOS_RANDOM_UTILITY_INITIALIZER_H_INCLUDED defined