wmdomain.h

Go to the documentation of this file.

/*
 * wmdomain.h
 *
 *  Created on: Feb 23, 2012
 *      Author: smiller
 */
 
#ifndef WMDOMAIN_H_
#define WMDOMAIN_H_
 
// External Libraries
//#include <hdf5.h>
 
// WarpX includes
#include "wxlogger.h"
#include "wxlogstream.h"
#include "wmunstructuredpatch.h"
#include "variables/wmvariable.h"
#include "solver/wmsolverbase.h"
#include "lib/wxany.h"
 
// std includes
#include <cassert>
#include <iostream>
#include <map>
#include <vector>
#include <utility>
#include <typeinfo>
 
class WmUnstructuredPatch;
 
// WmDomain will have to control how the domain is split up among the processors
 
class WmDomain
{
public:
    typedef std::vector<WmUnstructuredPatch*> patchList_t;
 
    typedef std::map<int, WmUnstructuredPatch*> patchMap_t;
    typedef std::pair<int, WmUnstructuredPatch*> patchPair_t;
 
    WmDomain();
 
    ~WmDomain();
 
    void setup(const WxCryptSet& wxc);
 
    void setParentSolver(WmSolverBase* parentSolver)
    {
        _parentSolver = parentSolver;
    }
 
    WmSolverBase const* getParentSolver() const
    {
        return _parentSolver;
    }
 
    int getNumPatches() const;
 
    // These are used to generate the global array
    std::vector<int> getAllPartitionPIDs() const;
    std::map<int, std::pair<int, int>>
    getSubdomainPartitionPIDsAndNumElements(const std::string& subdomainName) const;
 
    std::vector<std::string> getSubdomainNames() const;
 
    const WmUnstructuredPatch* hasPatch(int patchIndex) const;
    const WmUnstructuredPatch* hasLocalPatch(int patchIndex) const;
 
    // These should be part of a WmGeometryDomain class
    patchMap_t getLocalPatches() const
    {
        return _localPatches;
    }
    patchMap_t getLocalPatches(const std::string& subdomainName) const;
    patchMap_t getPatches() const
    {
        return _patches;
    }
    patchMap_t getPatches(const std::string& subdomainName) const;
    int primitive_id() const
    {
        return _primitive_id;
    }
 
    void addPatch(WmUnstructuredPatch* pPatch);
 
    // This should be part of a WmComputeDomain class
    int getLocalPID() const; // This returns the local processor ID number
    const std::vector<int>& getClusterDeviceIndexes() const
    {
        return _clusterDeviceIndex;
    }
    const std::vector<int>& getClusterDeviceNodeRanks() const
    {
        return _clusterDeviceNodeRank;
    }
    const std::vector<float>& getClusterDeviceWeights() const
    {
        return _clusterDeviceWeights;
    }
    const std::map<std::pair<int, int>, int>& getClusterDeviceEdgeWeights() const
    {
        return _clusterDeviceEdgeWeights;
    }
 
protected:
    void applyPatchOffsets();
    void partitionDomain();
 
    WmSolverBase* _parentSolver;
 
    int _primitive_id;
 
    // All patches, some local, some not *** This map owns the patches ***
    patchMap_t _patches;
 
    // A subset of patches local to this MPI rank
    patchMap_t _localPatches;
 
    // Partition structures defining cluster
    // Used to partition the patches within the cluster
    std::vector<int> _clusterDeviceIndex;    // Compute device index local to cluster node
    std::vector<int> _clusterDeviceNodeRank; // Rank of cluster node
    std::vector<float> _clusterDeviceWeights; // Weight of compute device
    std::map<std::pair<int, int>, int>
        _clusterDeviceEdgeWeights; // Weight of link between compute devices
};
 
#endif /* WMDOMAIN_H_ */