olb::refinement::lagrava Namespace Reference

Implementation of a simplified version of the refinement algorithm by Lagrava et al. More...

Classes
struct	FineToCoarseO
struct	FullTimeCoarseToFineO
struct	HalfTimeCoarseToFineO
struct	InitializeO

Functions
template<typename T , typename DESCRIPTOR >
std::unique_ptr< SuperLatticeRefinement< T, DESCRIPTOR > >	makeCoarseToFineCoupler (SuperLattice< T, DESCRIPTOR > &sLatticeCoarse, SuperGeometry< T, DESCRIPTOR::d > &sGeometryCoarse, SuperLattice< T, DESCRIPTOR > &sLatticeFine, SuperGeometry< T, DESCRIPTOR::d > &sGeometryFine)
template<typename T , typename DESCRIPTOR >
std::unique_ptr< SuperLatticeRefinement< T, DESCRIPTOR > >	makeFineToCoarseCoupler (SuperLattice< T, DESCRIPTOR > &sLatticeCoarse, SuperGeometry< T, DESCRIPTOR::d > &sGeometryCoarse, SuperLattice< T, DESCRIPTOR > &sLatticeFine, SuperGeometry< T, DESCRIPTOR::d > &sGeometryFine)

Detailed Description

Implementation of a simplified version of the refinement algorithm by Lagrava et al.

DOI: 10.1016/j.jcp.2012.03.015

Function Documentation

makeCoarseToFineCoupler()

template<typename T , typename DESCRIPTOR >

std::unique_ptr< SuperLatticeRefinement< T, DESCRIPTOR > > olb::refinement::lagrava::makeCoarseToFineCoupler	(	SuperLattice< T, DESCRIPTOR > &	sLatticeCoarse,
		SuperGeometry< T, DESCRIPTOR::d > &	sGeometryCoarse,
		SuperLattice< T, DESCRIPTOR > &	sLatticeFine,
		SuperGeometry< T, DESCRIPTOR::d > &	sGeometryFine )

Definition at line 261 of file lagrava.h.

{
  auto& loadBalancerFine = dynamic_cast<RefinedLoadBalancer<T,DESCRIPTOR::d>&>(
    sLatticeFine.getLoadBalancer());
  auto& loadBalancerCoarse = sLatticeCoarse.getLoadBalancer();
  auto& cDecompositionFine = sLatticeFine.getCuboidDecomposition();
  const auto& converterCoarse = sLatticeCoarse.getConverter();
 
  SuperIndicatorDomainFrontierDistanceF<T,DESCRIPTOR> c2fFrontierI(cDecompositionFine,
                                                                   sGeometryFine,
                                                                   0);
  SuperIndicatorDomainFrontierDistanceF<T,DESCRIPTOR> c2fInsideI(cDecompositionFine,
                                                                 sGeometryFine,
                                                                 1);
  SuperIndicatorDomainFrontierDistanceF<T,DESCRIPTOR> c2fOutsideI(cDecompositionFine,
                                                                  sGeometryFine,
                                                                  -1);
 
  auto coarseToFine = std::make_unique<SuperLatticeRefinement<T,DESCRIPTOR>>(sLatticeCoarse,
                                                                             sLatticeFine,
                                                                             loadBalancerFine);
  auto& coarseToFineCommunicatorCoarse = coarseToFine->getCoarseCommunicator(meta::id<FullTimeCoarseToFineO>{});
  coarseToFineCommunicatorCoarse.template requestField<descriptors::POPULATION>();
 
  for (int iC = 0; iC < loadBalancerFine.size(); ++iC) {
    auto& fBlock = sLatticeFine.getBlock(iC);
 
    fBlock.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> fineLatticeR) {
      if (c2fFrontierI.getBlockIndicatorF(iC)(fineLatticeR)) {
        if (fBlock.isInsideCore(fineLatticeR)) {
          coarseToFine->getBlock(iC).add(fineLatticeR);
        } else {
          // Couple co-incident nodes in overlap s.t. context data for interpolation is available
          if (fineLatticeR % 2 == Vector<int,DESCRIPTOR::d>(0)) {
            coarseToFine->getBlock(iC).add(fineLatticeR);
 
            // Coarse populations need to be up to date for FullTimeCoarseToFineO
            auto coarseLatticeR = (fineLatticeR / 2).withPrefix(
              loadBalancerCoarse.glob(loadBalancerFine.cloc(iC)));
            coarseToFineCommunicatorCoarse.requestCell(coarseLatticeR);
          }
        }
      }
    });
 
    auto& insideI  = c2fInsideI.getBlockIndicatorF(iC);
    auto& outsideI = c2fOutsideI.getBlockIndicatorF(iC);
 
    fBlock.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> fineLatticeR) {
      if (auto index = coarseToFine->getBlock(iC).getDataIndex(fineLatticeR)) {
        auto [type, normal] = computeBoundaryTypeAndNormal(insideI, outsideI, fineLatticeR);
        coarseToFine->getBlock(iC).getData()
                     .template getField<fields::refinement::NORMAL>().set(*index, normal);
      }
    });
    fBlock.defineDynamics(outsideI, meta::id<NoDynamics<T,DESCRIPTOR>>{});
 
    coarseToFine->getBlock(iC).getData()
                 .template getData<OperatorParameters<refinement::lagrava::HalfTimeCoarseToFineO>>()
                 .template set<descriptors::TAU>(converterCoarse.getLatticeRelaxationTime());
    coarseToFine->getBlock(iC).getData()
                 .template getData<OperatorParameters<refinement::lagrava::FullTimeCoarseToFineO>>()
                 .template set<descriptors::TAU>(converterCoarse.getLatticeRelaxationTime());
 
  }
 
  coarseToFineCommunicatorCoarse.exchangeRequests();
  coarseToFine->setProcessingContext(ProcessingContext::Simulation);
 
  return coarseToFine;
}

References olb::computeBoundaryTypeAndNormal(), olb::BlockStructureD< D >::forSpatialLocations(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getConverter(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::SuperStructure< T, D >::getLoadBalancer(), and olb::Simulation.

Here is the call graph for this function:

makeFineToCoarseCoupler()

template<typename T , typename DESCRIPTOR >

std::unique_ptr< SuperLatticeRefinement< T, DESCRIPTOR > > olb::refinement::lagrava::makeFineToCoarseCoupler	(	SuperLattice< T, DESCRIPTOR > &	sLatticeCoarse,
		SuperGeometry< T, DESCRIPTOR::d > &	sGeometryCoarse,
		SuperLattice< T, DESCRIPTOR > &	sLatticeFine,
		SuperGeometry< T, DESCRIPTOR::d > &	sGeometryFine )

Definition at line 338 of file lagrava.h.

{
  auto& loadBalancerFine = dynamic_cast<RefinedLoadBalancer<T,DESCRIPTOR::d>&>(
    sLatticeFine.getLoadBalancer());
  auto& cDecompositionFine = sLatticeFine.getCuboidDecomposition();
  const auto& converterCoarse = sLatticeCoarse.getConverter();
 
  SuperIndicatorDomainFrontierDistanceF<T,DESCRIPTOR> f2cFrontierI(cDecompositionFine,
                                                                   sGeometryFine,
                                                                   2);
 
  auto fineToCoarse = std::make_unique<SuperLatticeRefinement<T,DESCRIPTOR>>(
    sLatticeCoarse, sLatticeFine, loadBalancerFine);
  for (int iC = 0; iC < loadBalancerFine.size(); ++iC) {
    auto& cBlock = sLatticeCoarse.getBlock(loadBalancerFine.cloc(iC));
 
    cBlock.forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> coarseLatticeR) {
      if (f2cFrontierI.getBlockIndicatorF(iC)(2*coarseLatticeR)) {
        fineToCoarse->getBlock(iC).add(2*coarseLatticeR);
      }
    });
    fineToCoarse->getBlock(iC).getData()
                 .template getData<OperatorParameters<refinement::lagrava::FineToCoarseO>>()
                 .template set<descriptors::TAU>(converterCoarse.getLatticeRelaxationTime());
  }
 
  fineToCoarse->setProcessingContext(ProcessingContext::Simulation);
 
  return fineToCoarse;
}

References olb::BlockStructureD< D >::forCoreSpatialLocations(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getConverter(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::SuperStructure< T, D >::getLoadBalancer(), and olb::Simulation.

Here is the call graph for this function: