processorGAMGInterface.H 5.55 KB
Newer Older
1 2 3 4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
OpenFOAM bot's avatar
OpenFOAM bot committed
5
    \\  /    A nd           | www.openfoam.com
6
     \\/     M anipulation  |
OpenFOAM bot's avatar
OpenFOAM bot committed
7
-------------------------------------------------------------------------------
OpenFOAM bot's avatar
OpenFOAM bot committed
8
    Copyright (C) 2011-2014 OpenFOAM Foundation
9
    Copyright (C) 2019 OpenCFD Ltd.
10 11 12 13
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

14 15 16 17
    OpenFOAM 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 3 of the License, or
    (at your option) any later version.
18 19 20 21 22 23 24

    OpenFOAM 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
25
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

Class
    Foam::processorGAMGInterface

Description
    GAMG agglomerated processor interface.

SourceFiles
    processorGAMGInterface.C

\*---------------------------------------------------------------------------*/

#ifndef processorGAMGInterface_H
#define processorGAMGInterface_H

#include "GAMGInterface.H"
#include "processorLduInterface.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

/*---------------------------------------------------------------------------*\
                  Class processorGAMGInterface Declaration
\*---------------------------------------------------------------------------*/

class processorGAMGInterface
:
    public GAMGInterface,
    public processorLduInterface
{
    // Private data

60 61 62
        //- Communicator to use for parallel communication
        const label comm_;

63 64 65 66 67 68 69 70 71 72 73 74
        //- My processor rank in communicator
        label myProcNo_;

        //- Neighbouring processor rank in communicator
        label neighbProcNo_;

        //- Transformation tensor
        tensorField forwardT_;

        //- Message tag used for sending
        int tag_;

75 76 77

    // Private Member Functions

78 79
        //- No copy construct
        processorGAMGInterface(const processorGAMGInterface&) = delete;
80

81 82
        //- No copy assignment
        void operator=(const processorGAMGInterface&) = delete;
83 84 85 86 87 88 89 90 91 92 93 94 95


public:

    //- Runtime type information
    TypeName("processor");

    // Constructors

        //- Construct from fine-level interface,
        //  local and neighbour restrict addressing
        processorGAMGInterface
        (
mattijs's avatar
mattijs committed
96 97
            const label index,
            const lduInterfacePtrsList& coarseInterfaces,
98 99
            const lduInterface& fineInterface,
            const labelField& restrictAddressing,
100
            const labelField& neighbourRestrictAddressing,
101 102
            const label fineLevelIndex,
            const label coarseComm
103 104
        );

105 106 107 108 109 110 111 112 113 114 115 116 117 118
        //- Construct from components
        processorGAMGInterface
        (
            const label index,
            const lduInterfacePtrsList& coarseInterfaces,
            const labelUList& faceCells,
            const labelUList& faceRestrictAddresssing,
            const label coarseComm,
            const label myProcNo,
            const label neighbProcNo,
            const tensorField& forwardT,
            const int tag
        );

119 120 121 122 123 124 125 126
        //- Construct from Istream
        processorGAMGInterface
        (
            const label index,
            const lduInterfacePtrsList& coarseInterfaces,
            Istream& is
        );

127

128
    //- Destructor
129
    virtual ~processorGAMGInterface() = default;
130 131 132 133 134 135 136 137 138 139


    // Member Functions

        // Interface transfer functions

            //- Initialise neighbour field transfer
            virtual void initInternalFieldTransfer
            (
                const Pstream::commsTypes commsType,
140
                const labelUList& iF
141 142 143 144 145 146
            ) const;

            //- Transfer and return internal field adjacent to the interface
            virtual tmp<labelField> internalFieldTransfer
            (
                const Pstream::commsTypes commsType,
147
                const labelUList& iF
148 149 150 151 152
            ) const;


        //- Processor interface functions

153
            //- Return communicator used for sending
154
            virtual label comm() const
155 156 157 158 159
            {
                return comm_;
            }

            //- Return processor number (rank in communicator)
160 161
            virtual int myProcNo() const
            {
162
                return myProcNo_;
163 164
            }

Andrew Heather's avatar
Andrew Heather committed
165
            //- Return neighbour processor number (rank in communicator)
166 167
            virtual int neighbProcNo() const
            {
168
                return neighbProcNo_;
169 170 171 172 173
            }

            //- Return face transformation tensor
            virtual const tensorField& forwardT() const
            {
174
                return forwardT_;
175
            }
mattijs's avatar
mattijs committed
176 177 178 179

            //- Return message tag used for sending
            virtual int tag() const
            {
180
                return tag_;
181
            }
182 183 184 185 186 187


        // I/O

            //- Write to stream
            virtual void write(Ostream&) const;
188 189 190 191 192 193 194 195 196 197 198 199
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //