randomizer.hpp

Go to the documentation of this file.

/*
*
*      AggregPacking : Generator of random aggregate packings in concrete     
*                                                                             
*                           version 0.1 (2014-08-22)                          
* 
*                      Copyright (C)  2014  Jan Stransky                      
* 
*          Czech Technical University, Faculty of Civil Engineering,          
*      Department of Structural Mechanics, 166 29 Prague, Czech Republic      
* 
* AggregPacking is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
* 
* AggregPacking 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef RANDOMIZER_HPP
#define RANDOMIZER_HPP

#define NMINVALUES_DEFAULT 10000

#include <vector>
#include <array>
#include <string>
using std::vector;
using std::array;
using std::string;

#include "utils.hpp"

#ifdef AGGREGPACKING_SERIALIZATION
#include <iostream>
#include <fstream>
using std::istream;
using std::ostream;
using std::ifstream;
using std::ofstream;
#endif

#ifdef AGGREGPACKING_BOOST_PYTHON
#include <boost/python.hpp>
namespace bp = boost::python;
#endif

namespace aggregpacking {


/**********************************************************************
* RANDOMIZER
**********************************************************************/
class Randomizer {
    private:
        static int seed;

    public:
        static double random() { return (double)rand()/(double)RAND_MAX; }


        static double randint(int m) { return (int)(random()*m); }

        static int getSeed() { return Randomizer::seed; }


        static void setSeed(int s) { Randomizer::seed = s; srand(s); }
};



/**********************************************************************
* AGGREG SIZE RANDOMIZER
**********************************************************************/

class AggregSizeRandomizer: public Randomizer {
    public:
        typedef vector<double> sizes_t;

    protected:
        sizes_t sizes;

        void initSizes(unsigned int nMinValues);

#ifdef AGGREGPACKING_SERIALIZATION
        string fileName;


        void saveSizes(ostream& os) const;


        void loadSizes(istream& is);


        static AggregSizeRandomizer* Load(istream& is);

#endif
    public:
#ifdef AGGREGPACKING_SERIALIZATION
        AggregSizeRandomizer() : AggregSizeRandomizer(string()) {};


        AggregSizeRandomizer(const string& m) : fileName(m) {};
#else
        AggregSizeRandomizer() {};
#endif

        virtual double cdf(double size) const = 0;

        double take() const;

        const sizes_t& getSizes() { return sizes; }

        virtual double getMinSize() const { return sizes[sizes.size()-1]; }

        virtual double getMaxSize() const { return sizes[0]; }

#ifdef AGGREGPACKING_SERIALIZATION
        string getFileName() { return fileName; }

        virtual const string& getClassName() = 0;


        virtual void save(const string& fName) const { saveObject(*this,fName,fileName); }

        virtual void save() const { save(string()); }


        virtual bool load(const string& fName) { return loadObject(*this,fName,fileName); }


        virtual bool load() { load(string()); }

        friend ostream& operator<<(ostream& f, const AggregSizeRandomizer& o);

        friend istream& operator>>(istream& f, AggregSizeRandomizer& o);
#endif
};






/**********************************************************************
* FULLER CURVE RANDOMIZER
**********************************************************************/

class FullerCurveRandomizer : public AggregSizeRandomizer {
    protected:
        double exponent;

        double minSize;

        double maxSize;

    public:

        FullerCurveRandomizer() : FullerCurveRandomizer(NMINVALUES_DEFAULT,0.5,.5e-3,16e-3) {}

#ifdef AGGREGPACKING_SERIALIZATION

        FullerCurveRandomizer(int n, double e, double minSize, double maxSize) : FullerCurveRandomizer(n,e,minSize,maxSize,string()) {}


        FullerCurveRandomizer(int n, double e, double minSize, double maxSize, const string& m) : AggregSizeRandomizer(m), exponent(e), minSize(minSize), maxSize(maxSize) {
            initSizes(n);
        }
#else
        FullerCurveRandomizer(int n, double e, double minSize, double maxSize) : AggregSizeRandomizer(), exponent(e), minSize(minSize), maxSize(maxSize) {
            initSizes(n);
        }
#endif

        virtual double cdf(double size) const;

        double getExponent() { return exponent; }

        void setExponent(double v) { exponent = v; }

        virtual double getMinSize() const { return minSize; }

        virtual double getMaxSize() const { return maxSize; }

#ifdef AGGREGPACKING_SERIALIZATION
        const static string className;

        virtual const string& getClassName() { return FullerCurveRandomizer::className; }

        friend ostream& operator<<(ostream& f, const FullerCurveRandomizer& o);

        friend istream& operator>>(istream& f, FullerCurveRandomizer& o);
#endif
};
//**********************************************************************



/**********************************************************************
* EXPERIMENTAL SIEVE CURVE RANDOMIZER
**********************************************************************/

class ExperimentalSieveCurveRandomizer : public AggregSizeRandomizer {
    public:
        typedef vector<array<double,2>> sieve_curve;

    protected:
        sieve_curve values;

        void check();


        int findInterval(double size) const;

    public:
        ExperimentalSieveCurveRandomizer() : ExperimentalSieveCurveRandomizer(NMINVALUES_DEFAULT,{{.5e-3,0.},{16e-3,1.}}) {};

#ifdef AGGREGPACKING_SERIALIZATION

        ExperimentalSieveCurveRandomizer(int n, const sieve_curve& v) : ExperimentalSieveCurveRandomizer(n,v,string()) {};


        ExperimentalSieveCurveRandomizer(int n, const sieve_curve& v, const string& m) : AggregSizeRandomizer(m), values(v) {
            check();
            initSizes(n);
        }
#else
        ExperimentalSieveCurveRandomizer(int n, const sieve_curve& v) : AggregSizeRandomizer(), values(v) {
            check();
            initSizes(n);
        }
#endif

        const sieve_curve& getValues() const { return values; }

        sieve_curve getValues() { return values; }

        void setValues(const sieve_curve& sc) { values = sc; check(); }

        virtual double cdf(double size) const;

        virtual double getMinSize() const { return values[0][0]; }

        virtual double getMaxSize() const { return values[values.size()-1][0]; }

#ifdef AGGREGPACKING_SERIALIZATION
        const static string className;

        virtual const string& getClassName() { return ExperimentalSieveCurveRandomizer::className; }

        friend ostream& operator<<(ostream& f, const ExperimentalSieveCurveRandomizer& o);

        friend istream& operator>>(istream& f, ExperimentalSieveCurveRandomizer& o);
#endif
};
//**********************************************************************



/**********************************************************************
* PYTHON
**********************************************************************/
#ifdef AGGREGPACKING_BOOST_PYTHON
void py_randomizer();
#endif

} // namespace
#endif