heterogeometry.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 HETEROGEOMETRY_HPP
#define HETEROGEOMETRY_HPP

#include "utils.hpp"
#include "aggregate.hpp"
#include "randomizer.hpp"
#include "concmixture.hpp"
#include "octree.hpp"
using octree::Octree;

#include <string>
using std::string;

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

namespace aggregpacking {


/*********************************************************************
* HETERO GEOMETRY
*********************************************************************/

class HeteroGeometry {
    protected:
#ifdef AGGREGPACKING_SERIALIZATION
        HeteroGeometry() : HeteroGeometry(string()) {};


        HeteroGeometry(const string& fileName) : fileName(fileName), aggregType(Sphere::className), aggregates(0), placeNumTries(10000) {};
#else
        HeteroGeometry() : aggregType(Sphere::className), aggregates(0), placeNumTries(10000) {};
#endif

        vector<Aggregate*> aggregates;

        string fileName;

        Octree<Aggregate*>* octree;

        int placeNumTries;


        Aggregate* CreateParticle(double size);


        void take(const AggregSizeRandomizer& aggregSizeRandomizer, const ConcreteMixture& concreteMixture);


        bool place(double minRelAggregDist);


        bool place() { return place(0.); }


        virtual bool placeOneParticle(Aggregate& aggreg) = 0;


        virtual bool containsParticle(const Aggregate& aggreg) = 0;

        void clearAggregates();

        string aggregType;

#ifdef AGGREGPACKING_SERIALIZATION
        void saveAggregates(ostream& os) const;

        void loadAggregates(istream& is);
#endif
    public:

        void build(const AggregSizeRandomizer& aggregSizeRandomizer, const ConcreteMixture& concreteMixture, double minRelAggregDist);


        void build(const AggregSizeRandomizer& aggregSizeRandomizer, const ConcreteMixture& concreteMixture) { build(aggregSizeRandomizer,concreteMixture,0.); }


        void rebuild(const AggregSizeRandomizer& aggregSizeRandomizer, const ConcreteMixture& concreteMixture, double minRelAggregDist);


        void rebuild(const AggregSizeRandomizer& aggregSizeRandomizer, const ConcreteMixture& concreteMixture) { rebuild(aggregSizeRandomizer,concreteMixture,0.); }

        virtual double computeVolume() = 0;

        virtual void initOctree() = 0;

        const vector<Aggregate*>& getAggregates() const { return aggregates; }

        vector<Aggregate*>& getAggregates() { return aggregates; }

        string getAggregType() { return aggregType; }

        const string& getAggregType() const { return aggregType; }

        void setAggregType(const string& s);

        Octree<Aggregate*>* getOctree() { return octree; }

        const Octree<Aggregate*>* getOctree() const { return octree; }

        string getFileName() { return fileName; }

        int getPlaceNumTries() { return placeNumTries; }

        void setPlaceNumTries(int v) { placeNumTries = v; }


        bool check();

#ifdef AGGREGPACKING_SERIALIZATION
        virtual const string& getClassName() = 0;

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

        friend istream& operator>>(istream& f, HeteroGeometry& o);


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

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


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

        bool load() { return load(string()); }
#endif
};






/*********************************************************************
* CUBE HETERO GEOMETRY
*********************************************************************/

class CubeHeteroGeometry : public HeteroGeometry {
    private:
        double cubeSize;

        virtual bool placeOneParticle(Aggregate& aggreg);

    public:
#ifdef AGGREGPACKING_SERIALIZATION

        CubeHeteroGeometry(double c, const string& m);


        CubeHeteroGeometry(double c) : CubeHeteroGeometry(c,string()) {}
#else
        CubeHeteroGeometry(double c);
#endif

        ~CubeHeteroGeometry();

        virtual void initOctree();

        virtual double computeVolume() { return pow(cubeSize,3); }

        double getCubeSize() { return cubeSize; }

        virtual bool containsParticle(const Aggregate& aggreg);

#ifdef AGGREGPACKING_SERIALIZATION
        const static string className;

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

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

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





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

} // namespace
#endif