示例#1
0
void
PreconditionerTeko::buildBlockGIDs ( std::vector<std::vector<int> >& gids,
                                     const MapEpetra& map,
                                     const std::vector<int>& blockSizes )
{
    int numLocal = map.map ( Unique )->NumMyElements();
    int numBlocks = blockSizes.size();

    gids.clear();
    gids.resize ( blockSizes.size() );

    int gid = -1;
    int cumulBlocksSizes = 0;

    for ( int i ( 0 ); i < numLocal; ++i )
    {
        gid = map.map ( Unique )->GID ( i );
        cumulBlocksSizes = 0;
        for ( int j ( 0 ); j < numBlocks; ++j )
        {
            cumulBlocksSizes += blockSizes[j];
            if ( gid <= cumulBlocksSizes )
            {
                gids[j].push_back ( gid );
                break;
            }
        }
    }
}
MatrixBlockMonolithicEpetra<DataType>::MatrixBlockMonolithicEpetra (const MapEpetra& map, int numEntries) :
    MatrixEpetra<DataType> (map, numEntries),
    M_blockNumRows (std::vector<UInt> (1, map.map (Unique)->NumGlobalElements() ) ),
    M_blockNumColumns (std::vector<UInt> (1, map.map (Unique)->NumGlobalElements() ) ),
    M_blockFirstRows (std::vector<UInt> (1, 0) ),
    M_blockFirstColumns (std::vector<UInt> (1, 0) )
{
}
示例#3
0
文件: MapEpetra.cpp 项目: lifev/lifev
bool MapEpetra::mapsAreSimilar ( MapEpetra const& epetraMap ) const
{
    if ( this == &epetraMap )
    {
        return true;
    }

    return ( getUniqueMap()->SameAs ( *epetraMap.getUniqueMap() ) &&
             getRepeatedMap()->SameAs ( *epetraMap.getRepeatedMap() ) );
}
MatrixBlockMonolithicEpetra<DataType>::MatrixBlockMonolithicEpetra ( const MapVector<MapEpetra>& vector, int numEntries)
    :
    MatrixEpetra<DataType> (vector.totalMap() )
    //MatrixEpetra<DataType>( typename MatrixEpetra<DataType>::matrix_ptrtype())
{
    ASSERT ( vector.nbMap() > 0 , "Map vector empty, impossible to construct a MatrixBlockMonolithicEpetra!");

    MapEpetra myMap (vector.map (0) );
    M_blockNumRows.push_back (vector.mapSize (0) );
    M_blockNumColumns.push_back (vector.mapSize (0) );
    M_blockFirstRows.push_back (0);
    M_blockFirstColumns.push_back (0);

    UInt totalRows (vector.mapSize (0) );
    UInt totalColumns (vector.mapSize (0) );

    for (UInt i (1); i < vector.nbMap(); ++i)
    {
        myMap += vector.map (i);
        M_blockNumRows.push_back (vector.mapSize (i) );
        M_blockNumColumns.push_back (vector.mapSize (i) );
        M_blockFirstRows.push_back (totalRows);
        M_blockFirstColumns.push_back (totalColumns);

        totalRows += vector.mapSize (i);
        totalColumns += vector.mapSize (i);
    }

    this->mapPtr().reset (new MapEpetra (myMap) );
    this->matrixPtr().reset ( new typename MatrixEpetra<DataType>::matrix_type ( Copy, *myMap.map ( Unique ), numEntries, false) );
}
MatrixEpetraStructured<DataType>::MatrixEpetraStructured ( const MapVector<MapEpetra>& vector, int numEntries, bool ignoreNonLocalValues ) :
    MatrixEpetra<DataType> ( typename MatrixEpetra<DataType>::matrix_ptrtype() ), M_blockStructure ( vector )
{
    ASSERT ( vector.nbMap() > 0 , "Map vector empty, impossible to construct a MatrixBlockMonolithicEpetra!" );

    MapEpetra myMap ( vector.totalMap() );

    this->mapPtr().reset ( new MapEpetra ( myMap ) );
    this->matrixPtr().reset ( new typename MatrixEpetra<DataType>::matrix_type ( Copy, *myMap.map ( Unique ), numEntries, ignoreNonLocalValues ) );
}
示例#6
0
void
MultiscaleCoupling::createCouplingMap ( MapEpetra& couplingMap )
{

#ifdef HAVE_LIFEV_DEBUG
    debugStream ( 8200 ) << "MultiscaleCoupling::createCouplingMap( couplingMap ) \n";
#endif

    M_couplingVariablesOffset = couplingMap.map ( Unique )->NumGlobalElements();

    couplingMap += localCouplingVariables ( 0 ).map();
}
示例#7
0
void MonolithicBlockMatrix::createInterfaceMap( const MapEpetra& interfaceMap , const std::map<ID, ID>& locDofMap, const UInt subdomainMaxId,  const boost::shared_ptr<Epetra_Comm> epetraWorldComm )
{
    //std::map<ID, ID> const& locDofMap = M_dofStructureToHarmonicExtension->locDofMap();
    std::map<ID, ID>::const_iterator ITrow;

    Int numtasks = epetraWorldComm->NumProc();
    int* numInterfaceDof(new int[numtasks]);
    int pid=epetraWorldComm->MyPID();
    int numMyElements = interfaceMap.map(Unique)->NumMyElements();
    numInterfaceDof[pid]=numMyElements;
    MapEpetra subMap(*interfaceMap.map(Unique), (UInt)0, subdomainMaxId);

    M_numerationInterface.reset(new vector_Type(subMap,Unique));
    //should be an int vector instead of double
    //                    M_numerationInterfaceInt.reset(new Epetra_IntVector(*M_interfaceMap.getMap(Unique)));

    for (int j=0; j<numtasks; ++j)
        epetraWorldComm->Broadcast( &numInterfaceDof[j], 1, j);

    for (int j=numtasks-1; j>0 ; --j)
    {
        numInterfaceDof[j] = numInterfaceDof[j-1];
    }
    numInterfaceDof[0]=0;
    for (int j=1; j<numtasks ; ++j)
        numInterfaceDof[j] += numInterfaceDof[j-1];

    UInt l=0;

    M_interface = (UInt) interfaceMap.map(Unique)->NumGlobalElements()/nDimensions;
//UInt solidDim=M_dFESpace->map().map(Unique)->NumGlobalElements()/nDimensions;
    for (l=0, ITrow=locDofMap.begin(); ITrow!=locDofMap.end() ; ++ITrow)
    {
        if (interfaceMap.map(Unique)->LID(ITrow->second /*+ dim*solidDim*/)>=0)
        {
            (*M_numerationInterface)[ITrow->second /*+ dim*solidDim*/ ]=l+ (int)(numInterfaceDof[pid]/nDimensions)/*+ dim*localInterface*/      ;
            //                                    (*M_numerationInterfaceInt)[ITrow->second /*+ dim*solidDim*/ ]=l+1+ (int)(M_numInterfaceDof[pid]/nDimensions)/*+ dim*localInterface*/      ;
            if ((int)(*M_numerationInterface)(ITrow->second )!=floor(l+ numInterfaceDof[pid]/nDimensions+0.2 /*+ dim*localInterface*/) )
                std::cout<<"ERROR! the numeration of the coupling map is not correct"<<std::endl;
            ++l;
        }
    }

    std::vector<int> couplingVector;
    couplingVector.reserve((int)(interfaceMap.map(Unique)->NumMyElements()));

    for (UInt dim=0; dim<nDimensions; ++dim)
    {
        for ( ITrow=locDofMap.begin(); ITrow!=locDofMap.end() ; ++ITrow)
        {
            if (interfaceMap.map(Unique)->LID(ITrow->second)>=0)
            {
                couplingVector.push_back((*M_numerationInterface)(ITrow->second /*+ dim * solidDim*/)+ dim * M_interface );
                //couplingVector.push_back((*M_numerationInterfaceInt)[ITrow->second /*+ dim * solidDim*/]+ dim * M_interface );
            }
        }
    }// so the map for the coupling part of the matrix is just Unique

    M_interfaceMap.reset(new MapEpetra(-1, static_cast< Int> ( couplingVector.size() ), &couplingVector[0], epetraWorldComm));
}