TestMonteCarlo.hpp

#ifndef TESTMONTECARLO_HPP
#define TESTMONTECARLO_HPP

#include "montecarlo/MonteCarlo.hpp"
#include "pdesolver/PDESolverCreator.hpp"

#include "mesh/MeshesCreator.hpp"
#include "TestEnvironment.hpp"


class TestMonteCarlo : public TestWithParam<std::string> {
protected:
  bool onlyFine = true;

  int level = 3;

  int dM = 1e6;

  MeshesCreator meshesCreator;

  PDESolverCreator pdeSolverCreator;

  MonteCarlo mc;

  TestMonteCarlo(const std::string &meshName, bool parallel) :
    meshesCreator(MeshesCreator("Interval").
      WithDistribute("RCB").
      WithoutOverlap()),
    pdeSolverCreator(PDESolverCreator().
      WithProblem(GetParam()).
      WithQuantity("GeneratorValue").
      WithModel("DummyPDESolver")),
    mc(MonteCarlo(level, dM, onlyFine, parallel,
                  meshesCreator, pdeSolverCreator)) {
    mc.Method();
  }

  void TearDown() {
    PPM->Barrier(0);
  }
};

class TestMonteCarloSeriell : public TestMonteCarlo {
protected:
  TestMonteCarloSeriell(const std::string &meshName) :
    TestMonteCarlo(meshName, false) {}
};

class TestMonteCarloParallel : public TestMonteCarlo {
protected:
  TestMonteCarloParallel(const std::string &meshName) :
    TestMonteCarlo(meshName, true) {}
};

class TestMonteCarloSeriellInterval : public TestMonteCarloSeriell {
protected:
  TestMonteCarloSeriellInterval() :
    TestMonteCarloSeriell("Interval") {}
};

class TestMonteCarloParallelInterval : public TestMonteCarloParallel {
protected:
  TestMonteCarloParallelInterval() :
    TestMonteCarloParallel("Interval") {}
};



#endif //TESTMONTECARLO_HPP