shells/parallel/ShellManagerParallel.h

Go to the documentation of this file.

// -*- C++ -*-
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// 
//                                   Fehmi Cirak
//                        California Institute of Technology
//                           (C) 2004 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#ifndef SHELLMANAGERPARALLEL_H
#define SHELLMANAGERPARALLEL_H
#include <mpi.h>
#include "MShellParallelizer.h"


namespace shells {

    template <typename SMTYPE>
    class ShellManagerParallel : public SMTYPE {
        //
        // Facet class for parallelized shells 
        // Provides a basic interface (with limited functionality) for shells library
        // SMTYPE is ShellManagerBasic or ShellManagerFragmented    
        // 

    public:
        ShellManagerParallel(const std::string& controlFileName, MPI_Comm comm);
        virtual ~ShellManagerParallel();
    
        // initialization
        virtual void computeMassPrepareAdvance();

        // time integration primitives
        virtual void internalExternalForces();

        // combined time integration primitives
        virtual void advance();

        // print the shell mesh and data
        virtual void printDataParallel(bool flush=false);    
        
        // print interface mesh and pressure for debugging purposes
        virtual void printIFaceMeshPressureParallel();
        
        virtual void checkPointingParallel(unsigned fileIDFirst=0);
        virtual void restartParallel(unsigned fileIDFirst=0);

        // copy and assignment constructors - not implemented
    private:
        ShellManagerParallel(const ShellManagerParallel &);
        const ShellManagerParallel & operator=(const ShellManagerParallel &);
    
    protected:
        int communicatorRank(){
            int rank;
            MPI_Comm_rank(_comm, &rank);
            return rank;
        }

    private:
        MPI_Comm                          _comm;
        parallel::MShellParallelizer     *_parallelizer;
    };



    // implementation
    template <typename SMTYPE>
    ShellManagerParallel<SMTYPE>::ShellManagerParallel(const std::string& controlFileName, 
                                                       MPI_Comm comm) :
        SMTYPE(controlFileName), _comm(comm) 
    {
        assert(_comm != MPI_COMM_NULL);
        
        // instantiate a parallelizer
        int size;
        MPI_Comm_size(_comm, &size); 
        if (size>1) {
            _parallelizer = new parallel::MShellParallelizer(_comm, SMTYPE::mShell());
            assert(_parallelizer!=NULL);
        } else {
            assert(false);
        }

        SMTYPE::mShell()->initializeComputation();
                
        // prepare the communication
        _parallelizer->initializeCommunication();    
    }
    
    
    template <typename SMTYPE>
    ShellManagerParallel<SMTYPE>::~ShellManagerParallel() 
    {
        if (_parallelizer!=NULL) {
            delete _parallelizer;  
        }
    }
    
    
    template <typename SMTYPE>
    void ShellManagerParallel<SMTYPE>::computeMassPrepareAdvance() 
    {
        SMTYPE::computeMassPrepareAdvance();
        
        // exchange mass
        _parallelizer->exchange(parallel::MShellParallelizer::mass);
    }
    

    template <typename SMTYPE>
    void ShellManagerParallel<SMTYPE>::internalExternalForces() 
    {
        SMTYPE::internalExternalForces();
        
        // exchange residual
        assert(_parallelizer!=NULL);
        _parallelizer->exchange(parallel::MShellParallelizer::residual);
    }
    
    
    template <typename SMTYPE>
    void ShellManagerParallel<SMTYPE>::advance()
    {
        // newmark predictor 
        SMTYPE::predictAndEnforceBC();
        
        // compute residuals
        SMTYPE::internalExternalForces();
        
        // exchange residual
        _parallelizer->exchange(parallel::MShellParallelizer::residual);
        
        // newmark corrector
        SMTYPE::correct();
        
        SMTYPE::incrementCurrentTimeAndStep();
        
        return;
    }
    
    
    template <typename SMTYPE>
    void ShellManagerParallel<SMTYPE>::printDataParallel(bool flush)
    {
        int myRank;
        MPI_Comm_rank(_comm, &myRank);
        
        // data is printed in dependence of the input control parameter 
        SMTYPE::printData(flush, myRank);
        
        return;
    }

    template <typename SMTYPE>
    void ShellManagerParallel<SMTYPE>::printIFaceMeshPressureParallel()
    {       
        int myRank;
        MPI_Comm_rank(_comm, &myRank);

        SMTYPE::printIFaceMeshPressure(myRank);
    }

    
    template <typename SMTYPE>
    void ShellManagerParallel<SMTYPE>::checkPointingParallel(unsigned fileIDFirst)
    {
        int myRank;
        MPI_Comm_rank(_comm, &myRank);
        
        SMTYPE::checkPointing(fileIDFirst, myRank);
        
        return;
    }
    
    
    template <typename SMTYPE>
    void ShellManagerParallel<SMTYPE>::restartParallel(unsigned fileIDFirst)
    {
        int myRank;
        MPI_Comm_rank(_comm, &myRank);
        
        SMTYPE::restart(fileIDFirst, myRank);
        
        return;
    }    
}

#endif

---