root/src/parallelization/hiparsimulator/updategroup.h @ 127:3e368f5be1d3

#include <libgeodecomp/config.h>
#ifdef LIBGEODECOMP_FEATURE_MPI
#ifndef _libgeodecomp_parallelization_hiparsimulator_updategroup_h_
#define _libgeodecomp_parallelization_hiparsimulator_updategroup_h_

#include <libgeodecomp/io/initializer.h>
#include <libgeodecomp/misc/displacedgrid.h>
#include <libgeodecomp/misc/region.h>
#include <libgeodecomp/mpilayer/mpilayer.h>
#include <libgeodecomp/parallelization/hiparsimulator/intersectingregionaccumulator.h>
#include <libgeodecomp/parallelization/hiparsimulator/stepper.h>
#include <libgeodecomp/parallelization/hiparsimulator/partitionmanager.h>
#include <libgeodecomp/parallelization/hiparsimulator/patchaccepter.h>
#include <libgeodecomp/parallelization/hiparsimulator/patchprovider.h>
#include <libgeodecomp/parallelization/hiparsimulator/patchlink.h>
#include <libgeodecomp/parallelization/hiparsimulator/vanillaregionaccumulator.h>
#include <libgeodecomp/parallelization/hiparsimulator/vanillastepper.h>

namespace LibGeoDecomp {
namespace HiParSimulator {

template<class CELL_TYPE, class PARTITION, class STEPPER=VanillaStepper<CELL_TYPE> >
class UpdateGroup
{
    friend class UpdateGroupPrototypeTest;
    friend class UpdateGroupTest;
public:
    const static int DIM = CELL_TYPE::Topology::DIMENSIONS;
    typedef DisplacedGrid<
        CELL_TYPE, typename CELL_TYPE::Topology, true> GridType;
    typedef typename Stepper<CELL_TYPE>::PatchType PatchType;
    typedef boost::shared_ptr<PatchProvider<GridType> > PatchProviderPtr;
    typedef boost::shared_ptr<PatchAccepter<GridType> > PatchAccepterPtr;
    typedef boost::shared_ptr<typename PatchLink<GridType>::Link> PatchLinkPtr;
    typedef PartitionManager<DIM, typename CELL_TYPE::Topology> MyPartitionManager;
    typedef typename MyPartitionManager::RegionVecMap RegionVecMap;

    UpdateGroup(
        const PARTITION& _partition, 
        const SuperVector<long>& _weights, 
        const unsigned& _offset,
        const CoordBox<DIM>& box, 
        const unsigned& _ghostZoneWidth,
        Initializer<CELL_TYPE> *_initializer,
        MPI::Comm *communicator = &MPI::COMM_WORLD) : 
        partition(_partition),
        weights(_weights),
        offset(_offset),
        ghostZoneWidth(_ghostZoneWidth),
        initializer(_initializer),
        mpiLayer(communicator),
        rank(mpiLayer.rank())
    {
        partitionManager.reset(new MyPartitionManager());
        partitionManager->resetRegions(
            box,
            new VanillaRegionAccumulator<PARTITION>(
                partition,
                offset,
                weights),
            rank,
            ghostZoneWidth);
        SuperVector<CoordBox<DIM> > boundingBoxes(mpiLayer.size());
        CoordBox<DIM> ownBoundingBox(partitionManager->ownRegion().boundingBox());
        mpiLayer.allGather(ownBoundingBox, &boundingBoxes);
        partitionManager->resetGhostZones(boundingBoxes);

        stepper.reset(new STEPPER( partitionManager, initializer));

        RegionVecMap map = partitionManager->getInnerGhostZoneFragments();
        for (typename RegionVecMap::iterator i = map.begin(); i != map.end(); ++i) {
            if (!i->second.back().empty()) {
                boost::shared_ptr<typename PatchLink<GridType>::Accepter> link(
                    new typename PatchLink<GridType>::Accepter(
                        i->second.back(), i->first));
                addPatchAccepter(link, Stepper<CELL_TYPE>::GHOST);
                patchLinks << link;
            }
        }

        map = partitionManager->getOuterGhostZoneFragments();
        for (typename RegionVecMap::iterator i = map.begin(); i != map.end(); ++i) {
            if (!i->second.back().empty()) {
                boost::shared_ptr<typename PatchLink<GridType>::Provider> link(
                    new typename PatchLink<GridType>::Provider(
                        i->second.back(), i->first));
                addPatchProvider(link, Stepper<CELL_TYPE>::GHOST);
                patchLinks << link;
            }
        }

        // fixme: recharge regularly?
        // for (int i = 0; i < patchLinks.size(); ++i) {
        //     patchLinks[i]->charge(ghostZoneWidth, 2 * ghostZoneWidth, ghostZoneWidth);
        // }
    }

    void addPatchProvider(
        const PatchProviderPtr& ghostZonePatchProvider, 
        const PatchType& patchType)
    {
        stepper->addPatchProvider(ghostZonePatchProvider, patchType);
    }

    void addPatchAccepter(
        const PatchAccepterPtr& ghostZonePatchAccepter, 
        const PatchType& patchType)
    {
        stepper->addPatchAccepter(ghostZonePatchAccepter, patchType);
    }
    
    inline void update(int nanoSteps) 
    {
        stepper->update(nanoSteps);
    }

    const GridType& grid() const
    {
        return stepper->grid();
    }

private:
    boost::shared_ptr<Stepper<CELL_TYPE> > stepper;
    boost::shared_ptr<MyPartitionManager> partitionManager;
    SuperVector<PatchLinkPtr> patchLinks;
    PARTITION partition;
    SuperVector<long> weights;
    unsigned offset;
    unsigned ghostZoneWidth;
    Initializer<CELL_TYPE> *initializer;
    MPILayer mpiLayer;
    unsigned rank;
};

}
}

#endif
#endif