Commit 57e85394 authored by Timo Koch's avatar Timo Koch

[mixeddimension] Remove temporarily until ported

parent d9985f25
add_subdirectory("embedded")
add_subdirectory("facet")
add_subdirectory("glue")
install(FILES
assembler.hh
integrationpointsource.hh
model.hh
newtoncontroller.hh
problem.hh
properties.hh
subproblemlocaljacobian.hh
subproblemproperties.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/mixeddimension)
This diff is collapsed.
#install headers
install(FILES
bboxtreecouplingmanager.hh
bboxtreecouplingmanagersimple.hh
pointsourcedata.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/mixeddimension/embedded/cellcentered)
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
* \file
* \ingroup EmbeddedCoupling
* \brief Provides a starting algorithm (a default main function) for multidimension problems
*/
#ifndef DUMUX_START_EMBEDDED_MIXEDDIMENSION_HH
#define DUMUX_START_EMBEDDED_MIXEDDIMENSION_HH
#include <ctime>
#include <iostream>
#include <dune/common/parallel/mpihelper.hh>
#include <dune/grid/io/file/dgfparser/dgfexception.hh>
#include <dumux/common/propertysystem.hh>
#include <dumux/common/parameters.hh>
#include <dumux/common/dumuxmessage.hh>
#include <dumux/common/defaultusagemessage.hh>
namespace Dumux
{
// forward declaration of property tags
namespace Properties
{
NEW_PROP_TAG(LowDimProblemTypeTag);
NEW_PROP_TAG(BulkProblemTypeTag);
}
template <class TypeTag>
int start_(int argc,
char **argv,
void (*usage)(const char *, const std::string &))
{
using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
using ParameterTree = typename GET_PROP(TypeTag, ParameterTree);
using BulkProblemTypeTag = typename GET_PROP_TYPE(TypeTag, BulkProblemTypeTag);
using LowDimProblemTypeTag = typename GET_PROP_TYPE(TypeTag, LowDimProblemTypeTag);
using BulkGridCreator = typename GET_PROP_TYPE(BulkProblemTypeTag, GridCreator);
using LowDimGridCreator = typename GET_PROP_TYPE(LowDimProblemTypeTag, GridCreator);
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using TimeManager = typename GET_PROP_TYPE(TypeTag, TimeManager);
// initialize MPI, finalize is done automatically on exit
const auto& mpiHelper = Dune::MPIHelper::instance(argc, argv);
// print dumux start message
if (mpiHelper.rank() == 0)
DumuxMessage::print(/*firstCall=*/true);
////////////////////////////////////////////////////////////
// parse the command line arguments and input file
////////////////////////////////////////////////////////////
// if the user just wanted to see the help / usage message show usage and stop program
if(!ParameterParser::parseCommandLineArguments(argc, argv, ParameterTree::tree(), usage))
{
usage(argv[0], defaultUsageMessage(argv[0]));
return 0;
}
// parse the input file into the parameter tree
// check first if the user provided an input file through the command line, if not use the default
const auto parameterFileName = ParameterTree::tree().hasKey("ParameterFile") ? GET_RUNTIME_PARAM(TypeTag, std::string, ParameterFile) : "";
ParameterParser::parseInputFile(argc, argv, ParameterTree::tree(), parameterFileName, usage);
////////////////////////////////////////////////////////////
// check for some user debugging parameters
////////////////////////////////////////////////////////////
bool printProps = false; // per default don't print all properties
if (ParameterTree::tree().hasKey("PrintProperties") || ParameterTree::tree().hasKey("TimeManager.PrintProperties"))
printProps = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, bool, TimeManager, PrintProperties);
if (printProps && mpiHelper.rank() == 0)
Properties::print<TypeTag>();
bool printParams = true; // per default print all properties
if (ParameterTree::tree().hasKey("PrintParameters") || ParameterTree::tree().hasKey("TimeManager.PrintParameters"))
printParams = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, bool, TimeManager, PrintParameters);
//////////////////////////////////////////////////////////////////////
// try to create a grid (from the given grid file or the input file)
/////////////////////////////////////////////////////////////////////
try { BulkGridCreator::makeGrid(); }
catch (...) {
std::string usageMessage = "\n\t -> Creation of the bulk grid failed! <- \n\n";
usageMessage += defaultUsageMessage(argv[0]);
usage(argv[0], usageMessage);
throw;
}
BulkGridCreator::loadBalance();
try { LowDimGridCreator::makeGrid(); }
catch (...) {
std::string usageMessage = "\n\t -> Creation of the low dim grid failed! <- \n\n";
usageMessage += defaultUsageMessage(argv[0]);
usage(argv[0], usageMessage);
throw;
}
LowDimGridCreator::loadBalance();
//////////////////////////////////////////////////////////////////////
// run the simulation
/////////////////////////////////////////////////////////////////////
// read the initial time step and the end time (mandatory parameters)
auto tEnd = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, TimeManager, TEnd);
auto dt = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, TimeManager, DtInitial);
// check if we are about to restart a previously interrupted simulation
bool restart = false;
Scalar restartTime = 0;
if (ParameterTree::tree().hasKey("Restart") || ParameterTree::tree().hasKey("TimeManager.Restart"))
{
restart = true;
restartTime = GET_RUNTIME_PARAM_FROM_GROUP(TypeTag, Scalar, TimeManager, Restart);
}
// instantiate and run the concrete problem
TimeManager timeManager;
Problem problem(timeManager, BulkGridCreator::grid().leafGridView(), LowDimGridCreator::grid().leafGridView());
timeManager.init(problem, restartTime, dt, tEnd, restart);
timeManager.run();
// print dumux end message and maybe the parameters for debugging
if (mpiHelper.rank() == 0)
{
DumuxMessage::print(/*firstCall=*/false);
if (printParams)
Parameters::print<TypeTag>();
}
return 0;
}
/*!
* \ingroup Start
*
* \brief Provides a main function with error handling
*
* \tparam TypeTag The type tag of the problem which needs to be solved
*
* \param argc The number of command line arguments of the program
* \param argv The contents of the command line arguments of the program
* \param usage Callback function for printing the usage message
*/
template <class TypeTag>
int start(int argc,
char **argv,
void (*usage)(const char *, const std::string &))
{
try {
return start_<TypeTag>(argc, argv, usage);
}
catch (ParameterException &e) {
Parameters::print<TypeTag>();
std::cerr << std::endl << e << ". Abort!" << std::endl;
return 1;
}
catch (Dune::DGFException & e) {
std::cerr << "DGF exception thrown (" << e <<
"). Most likely, the DGF file name is wrong "
"or the DGF file is corrupted, "
"e.g. missing hash at end of file or wrong number (dimensions) of entries."
<< std::endl;
return 2;
}
catch (Dune::Exception &e) {
std::cerr << "Dune reported error: " << e << std::endl;
return 3;
}
}
} // end namespace Dumux
#endif
add_subdirectory("mpfa")
install(FILES
gmshdualfacetgridcreator.hh
start.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/mixeddimension/facet)
\ No newline at end of file
This diff is collapsed.
install(FILES
couplingmanager.hh
couplingmapper.hh
darcyslaw.hh
fickslaw.hh
fourierslaw.hh
interactionvolume.hh
interiorboundarydata.hh
properties.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/mixeddimension/facet)
\ No newline at end of file
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
* \file
* \brief Base classes for interaction volumes of mpfa models with active coupling over the element facets.
*/
#ifndef DUMUX_MIXEDDIMENSION_FACET_MPFA_O_INTERACTIONVOLUME_HH
#define DUMUX_MIXEDDIMENSION_FACET_MPFA_O_INTERACTIONVOLUME_HH
#include <dumux/discretization/cellcentered/mpfa/interactionvolume.hh>
#include <dumux/discretization/cellcentered/mpfa/facetypes.hh>
#include <dumux/discretization/cellcentered/mpfa/methods.hh>
namespace Dumux
{
//! Forward declaration
template<class TypeTag> class CCMpfaOFacetCouplingInteractionVolume;
//! Specialization of the interaction volume traits class for the o-method in coupled models
template<class TypeTag>
class CCMpfaOFacetCouplingInteractionVolumeTraits : public CCMpfaOInteractionVolumeTraits<TypeTag>
{
public:
using BoundaryInteractionVolume = CCMpfaOFacetCouplingInteractionVolume<TypeTag>;
};
// the o-method interaction volume is substituted by the one including data on the facet element's
// tensorial quantities into the local system to be solved.
template<class TypeTag>
class CCMpfaOFacetCouplingInteractionVolume : public CCMpfaOInteractionVolume<TypeTag,
CCMpfaOFacetCouplingInteractionVolumeTraits<TypeTag>,
CCMpfaOFacetCouplingInteractionVolume<TypeTag>>
{
using Traits = CCMpfaOFacetCouplingInteractionVolumeTraits<TypeTag>;
using ThisType = CCMpfaOFacetCouplingInteractionVolume<TypeTag>;
using ParentType = CCMpfaOInteractionVolume<TypeTag, Traits, ThisType>;
using Scalar = typename GET_PROP_TYPE(TypeTag, Scalar);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using Element = typename GridView::template Codim<0>::Entity;
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using MpfaHelper = typename GET_PROP_TYPE(TypeTag, MpfaHelper);
using PrimaryVariables = typename GET_PROP_TYPE(TypeTag, PrimaryVariables);
using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
using InteriorBoundaryData = typename GET_PROP_TYPE(TypeTag, InteriorBoundaryData);
using ElementVolumeVariables = typename GET_PROP_TYPE(TypeTag, ElementVolumeVariables);
using LocalScvfType = typename Traits::LocalScvfType;
static constexpr bool useTpfaBoundary = GET_PROP_VALUE(TypeTag, UseTpfaBoundary);
public:
using typename ParentType::LocalIndexType;
using typename ParentType::Seed;
CCMpfaOFacetCouplingInteractionVolume(const Seed& seed,
const Problem& problem,
const FVElementGeometry& fvGeometry,
const ElementVolumeVariables& elemVolVars)
: ParentType(seed, problem, fvGeometry, elemVolVars)
{}
public:
// We include data on the tensorial quantities of the facet elements here
template<typename GetTensorFunction>
Scalar interiorNeumannTerm(const GetTensorFunction& getTensor,
const Element& element,
const LocalScvfType& localScvf,
const InteriorBoundaryData& data) const
{
// obtain the complete data on the facet element
const auto completeFacetData = data.completeCoupledFacetData(this->fvGeometry_());
// calculate "leakage factor"
const auto n = localScvf.unitOuterNormal();
const auto v = [&] ()
{
auto res = n;
res *= -0.5*completeFacetData.volVars().extrusionFactor();
res += localScvf.ip();
res -= localScvf.globalScvf().facetCorner();
res /= res.two_norm2();
return res;
} ();
// substract (n*T*v)*Area from diagonal matrix entry
const auto facetTensor = getTensor(completeFacetData.problem(),
completeFacetData.element(),
completeFacetData.volVars(),
completeFacetData.fvGeometry(),
completeFacetData.scv());
return localScvf.area()*
this->elemVolVars_()[localScvf.insideGlobalScvIndex()].extrusionFactor()*
MpfaHelper::nT_M_v(n, facetTensor, v);
}
void assembleNeumannFluxVector()
{
// initialize the neumann fluxes vector to zero
this->neumannFluxes_.resize(this->fluxFaceIndexSet_.size(), PrimaryVariables(0.0));
if (!this->onDomainOrInteriorBoundary() || useTpfaBoundary)
return;
LocalIndexType fluxFaceIdx = 0;
for (auto localFluxFaceIdx : this->fluxFaceIndexSet_)
{
const auto& localScvf = this->localScvf_(localFluxFaceIdx);
const auto faceType = localScvf.faceType();
if (faceType == MpfaFaceTypes::neumann)
{
const auto& element = this->localElement_(localScvf.insideLocalScvIndex());
const auto& globalScvf = this->fvGeometry_().scvf(localScvf.insideGlobalScvfIndex());
auto neumannFlux = this->problem_().neumann(element, this->fvGeometry_(), this->elemVolVars_(), globalScvf);
neumannFlux *= globalScvf.area();
neumannFlux *= this->elemVolVars_()[globalScvf.insideScvIdx()].extrusionFactor();
// The flux is assumed to be prescribed in the form of -D*gradU
this->neumannFluxes_[fluxFaceIdx] = neumannFlux;
}
fluxFaceIdx++;
}
}
};
} // end namespace
#endif
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
* \file
* \brief A class to store info on interior boundaries
*/
#ifndef DUMUX_DISCRETIZATION_CC_MPFA_FACET_INTERIORBOUNDARYDATA_HH
#define DUMUX_DISCRETIZATION_CC_MPFA_FACET_INTERIORBOUNDARYDATA_HH
#include <dumux/discretization/cellcentered/mpfa/facetypes.hh>
#include <dumux/mixeddimension/properties.hh>
namespace Dumux
{
template<class TypeTag>
class CCMpfaFacetCouplingInteriorBoundaryData
{
// types associated with the low dim domain
using GlobalProblemTypeTag = typename GET_PROP_TYPE(TypeTag, GlobalProblemTypeTag);
using LowDimProblemTypeTag = typename GET_PROP_TYPE(GlobalProblemTypeTag, LowDimProblemTypeTag);
using Problem = typename GET_PROP_TYPE(TypeTag, Problem);
using GridView = typename GET_PROP_TYPE(TypeTag, GridView);
using Element = typename GridView::template Codim<0>::Entity;
using SpatialParams = typename GET_PROP_TYPE(TypeTag, SpatialParams);
using VolumeVariables = typename GET_PROP_TYPE(TypeTag, VolumeVariables);
using FVElementGeometry = typename GET_PROP_TYPE(TypeTag, FVElementGeometry);
using SubControlVolumeFace = typename GET_PROP_TYPE(TypeTag, SubControlVolumeFace);
using ElementSolutionVector = typename GET_PROP_TYPE(TypeTag, ElementSolutionVector);
using BoundaryInteractionVolume = typename GET_PROP_TYPE(TypeTag, BoundaryInteractionVolume);
using IndexType = typename GridView::IndexSet::IndexType;
using LocalIndexType = typename BoundaryInteractionVolume::LocalIndexType;
using LowDimProblem = typename GET_PROP_TYPE(LowDimProblemTypeTag, Problem);
using LowDimSpatialParams = typename GET_PROP_TYPE(LowDimProblemTypeTag, SpatialParams);
using LowDimVolumeVariables = typename GET_PROP_TYPE(LowDimProblemTypeTag, VolumeVariables);
using LowDimGridView = typename GET_PROP_TYPE(LowDimProblemTypeTag, GridView);
using LowDimElement = typename LowDimGridView::template Codim<0>::Entity;
using LowDimFVElementGeometry = typename GET_PROP_TYPE(LowDimProblemTypeTag, FVElementGeometry);
using LowDimSubControlVolume = typename GET_PROP_TYPE(LowDimProblemTypeTag, SubControlVolume);
//! Dummy type for the CompleteCoupledFacetData struct.
//! Implementations need to have at least the provided interfaces.
//! Note that the return types are also "wrong" (Here just to satisfy the compiler)
struct CompleteCoupledFacetData
{
const LowDimProblem& problem() const
{ return *lowDimProblemPtr_; }
const LowDimSpatialParams& spatialParams() const
{ return *lowDimSpatialParamsPtr_; }
const LowDimVolumeVariables& volVars() const
{ return lowDimVolVars_; }
const LowDimElement& element() const
{ return lowDimElement_;}
const LowDimFVElementGeometry& fvGeometry() const
{ return lowDimFvGeometry_; }
const LowDimSubControlVolume& scv() const
{ return lowDimScv_; }
CompleteCoupledFacetData(const LowDimProblem& problem,
const IndexType elementIndex,
LowDimElement&& element,
LowDimFVElementGeometry&& fvGeometry,
LowDimVolumeVariables&& volVars)
: lowDimProblemPtr_(&problem),
lowDimSpatialParamsPtr_(&problem.spatialParams()),
lowDimElement_(std::move(element)),
lowDimFvGeometry_(std::move(fvGeometry)),
lowDimVolVars_(std::move(volVars)),
lowDimScv_(lowDimFvGeometry_.scv(elementIndex))
{}
private:
const LowDimProblem* lowDimProblemPtr_;
const LowDimSpatialParams* lowDimSpatialParamsPtr_;
LowDimElement lowDimElement_;
LowDimFVElementGeometry lowDimFvGeometry_;
LowDimVolumeVariables lowDimVolVars_;
const LowDimSubControlVolume& lowDimScv_;
};
public:
//! the constructor
CCMpfaFacetCouplingInteriorBoundaryData(const Problem& problem,
IndexType elementIndex,
IndexType scvfIndex,
LocalIndexType localIndex,
MpfaFaceTypes faceType)
: problemPtr_(&problem),
elementIndex_(elementIndex),
scvfIndex_(scvfIndex),
localIndex_(localIndex),
faceType_(faceType)
{}
//! returns the global index of the element/scv connected to the interior boundary
IndexType elementIndex() const
{ return elementIndex_; }
//! returns the global index of the scvf connected to the interior boundary
IndexType scvfIndex() const
{ return scvfIndex_; }
//! returns the local index i of the scvf within the interaction volume.
//! This is either:
//! - the i-th flux face index (interior neumann boundaries)
//! - the i-th interior dirichlet face (interior dirichlet boundaries)
LocalIndexType localIndexInInteractionVolume() const
{ return localIndex_; }
//! returns the face type of this scvf
MpfaFaceTypes faceType() const
{ return faceType_; }
//! returns the volume variables for interior dirichlet boundaries
LowDimVolumeVariables facetVolVars(const FVElementGeometry& fvGeometry) const
{
return problem_().couplingManager().lowDimVolVars(problem_().model().fvGridGeometry().element(elementIndex()),
fvGeometry,
fvGeometry.scvf(scvfIndex()));
}
//! returns the volume variables for interior dirichlet boundaries
LowDimVolumeVariables facetVolVars(const FVElementGeometry& fvGeometry, const SubControlVolumeFace& scvf) const
{
assert(scvf.index() == scvfIndex() && "calling facet volume variables for an scvf other than the bound one");
return problem_().couplingManager().lowDimVolVars(problem_().model().fvGridGeometry().element(elementIndex()),
fvGeometry,
scvf);
}
//! The following interface is here for compatibility reasonsto be overloaded for problems using facet coupling.
//! prepares all the necessary variables of the other domain.
//! Note that also an implementation of the CompleteFacetData structure has to be provided.
CompleteCoupledFacetData completeCoupledFacetData(const FVElementGeometry& fvGeometry) const
{
const auto& couplingMapper = problem_().couplingManager().couplingMapper();
// get coupling data for this scvf
const auto element = problem_().model().fvGridGeometry().element(elementIndex());
const auto& scvfCouplingData = couplingMapper.getBulkCouplingData(element).getScvfCouplingData(fvGeometry.scvf(scvfIndex()));
// obtain data necessary to fully instantiate the complete coupled facet data
assert(scvfCouplingData.first && "no coupled facet element found for given scvf!");
const auto& lowDimProblem = problem_().couplingManager().lowDimProblem();
auto lowDimElement = lowDimProblem.model().fvGridGeometry().element(scvfCouplingData.second);
auto lowDimFvGeometry = localView(lowDimProblem.model().fvGridGeometry());
lowDimFvGeometry.bindElement(lowDimElement);
LowDimVolumeVariables lowDimVolVars;
lowDimVolVars.update(lowDimProblem.model().elementSolution(lowDimElement, lowDimProblem.model().curSol()),
lowDimProblem,
lowDimElement,
lowDimFvGeometry.scv(scvfCouplingData.second));
return CompleteCoupledFacetData(lowDimProblem,
scvfCouplingData.second,
std::move(lowDimElement),
std::move(lowDimFvGeometry),
std::move(lowDimVolVars));
}
private:
const Problem& problem_() const
{ return *problemPtr_; }
const Problem* problemPtr_;
IndexType elementIndex_;
IndexType scvfIndex_;
LocalIndexType localIndex_;
MpfaFaceTypes faceType_;
};
} // end namespace
#endif
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*****************************************************************************
* See the file COPYING for full copying permissions. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program 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 General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*****************************************************************************/
/*!
* \file
* \ingroup MixedDimension
* \brief Base properties for the bulk problems in mixed dimensional models
* with a lower dimensional model living on the element facets.
*/
#ifndef DUMUX_FACET_MIXEDDIMENSION_PROPERTIES_HH
#define DUMUX_FACET_MIXEDDIMENSION_PROPERTIES_HH
#include <dumux/mixeddimension/subproblemproperties.hh>
#include <dumux/mixeddimension/facet/mpfa/interactionvolume.hh>
#include <dumux/mixeddimension/facet/mpfa/interiorboundarydata.hh>
#include <dumux/mixeddimension/facet/mpfa/darcyslaw.hh>
#include <dumux/mixeddimension/facet/mpfa/fickslaw.hh>
#include <dumux/mixeddimension/facet/mpfa/fourierslaw.hh>
namespace Dumux
{
namespace Properties
{
NEW_TYPE_TAG(FacetCouplingBulkMpfaModel, INHERITS_FROM(CCMpfaModel));
//! The boundary interaction volume class (we use the facet coupling specialized o-method interaction volume)
SET_TYPE_PROP(FacetCouplingBulkMpfaModel, BoundaryInteractionVolume, CCMpfaOFacetCouplingInteractionVolume<TypeTag>);
//! The interior boundary data class
SET_TYPE_PROP(FacetCouplingBulkMpfaModel, InteriorBoundaryData, CCMpfaFacetCouplingInteriorBoundaryData<TypeTag>);
//! Ẃe always enable interior boundaries
SET_BOOL_PROP(FacetCouplingBulkMpfaModel, EnableInteriorBoundaries, true);
//! Facet coupling is always true here
SET_BOOL_PROP(FacetCouplingBulkMpfaModel, MpfaFacetCoupling, true);
//! Darcy's Law
SET_TYPE_PROP(FacetCouplingBulkMpfaModel, AdvectionType, CCMpfaFacetCouplingDarcysLaw<TypeTag>);
//! Ficks's Law
SET_TYPE_PROP(FacetCouplingBulkMpfaModel, MolecularDiffusionType, CCMpfaFacetCouplingFicksLaw<TypeTag>);