FractureNetworkGenerator.h

Go to the documentation of this file.

/*
 * FractureNetworkGenerator.h
 *
 *  Created on: Mar 3, 2012
 *      Author: michael
 */

#ifndef FRACTURENETWORKGENERATOR_H_
#define FRACTURENETWORKGENERATOR_H_

#include <cmath>
#include <cstdlib>
#include <vector>
#include "algorithms/geometries/Channel.h"
#include "tarch/logging/Log.h"
#include "algorithms/CalculationBasics.h"

namespace algorithms {
  namespace channels {
    class FractureNetworkGenerator;
  } /* namespace channels */
} /* namespace algorithms */

class algorithms::channels::FractureNetworkGenerator {
public:
  FractureNetworkGenerator(
      const double& lengthMin,
      const double& lengthMax,
      const double& widthMin,
      const double& widthMax,
      const double& orientationMin,
      const double& orientationMax,
      const double& domainSizePerDirection,
      const int&    numObjects);

  virtual
  ~FractureNetworkGenerator();

  algorithms::geometries::Channel generateRandomChannel() {
#ifdef Debug
    std::stringstream ss;
    ss <<"generateRandomChannel()"
        << "min orientation: " <<CalculationBasics::toDegree(_orientationMin) <<", "
        << "max orientation: " <<CalculationBasics::toDegree(_orientationMax) <<std::endl
        ;
    _log.debug("generateRandomChannel", ss.str());
#endif
    return algorithms::geometries::Channel(
        getRandomDoubleInRange(_lengthMin, _lengthMax),
        getRandomDoubleInRange(_widthMin,  _widthMax),
        getRandomDoubleInRange(_domainMin, _domainMax),
        getRandomDoubleInRange(_domainMin, _domainMax),
        getRandomDoubleInRange(_orientationMin, _orientationMax)
    );
  }

  std::vector< algorithms::geometries::Channel >& generateFractureNetwork() {
    _channels.clear();
    _channels.reserve(_numObjects);
    for(unsigned int i=0;i<_numObjects;i++){
      _channels.push_back(generateRandomChannel());
    }
    std::stringstream ss;
    ss << "generated " << _numObjects <<" channels";
    _log.info("generateFractureNetwork",ss.str());
    return _channels;
  }

  std::vector<algorithms::geometries::Channel>& getChannels();
private:
  double getRandomDoubleInRange(const double& min, const double& max) {
    return static_cast<double>(rand())/static_cast<double>((RAND_MAX)) * (max-min) + min;
  }

  static tarch::logging::Log _log;
  const double&       _lengthMin;
  const double&       _lengthMax;
  const double&       _widthMin;
  const double&       _widthMax;
  const double&       _orientationMin;
  const double&       _orientationMax;
  const double        _domainMin;
  const double        _domainMax;
  const unsigned int  _numObjects;
  std::vector< algorithms::geometries::Channel > _channels;
};


#endif /* FRACTURENETWORKGENERATOR_H_ */