fsi/sfc-amroc/TubeCJBurnFlaps/src/ShellManagerSpecific.h

Go to the documentation of this file.

// -*- C++ -*-
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// 
//                           Fehmi Cirak, Ralf Deiterding
//                        California Institute of Technology
//                           (C) 2004 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#ifndef SHELLMANAGERSPECIFIC_H
#define SHELLMANAGERSPECIFIC_H
#include <vector>
#include <fstream>
#include <string>
#include <limits>

#include "mpi.h"
#include "elc/LagrangianComm.h"

#include "shells/driverCC/ShellManagerBasic.h"
#include "shells/parallel/ShellManagerParallel.h"
#include "shells/utilities/BasicSensor.h"
#include "shells/utilities/MakeUniqueName.h"
#include "shells/utilities/PropertiesParser.h"
#include "shells/driverCC/SVertexFunctors.h"
#include "shells/driverCC/PrescribeVarFunctor.h"


typedef shells::ShellManagerParallel<shells::ShellManagerBasic>  SMPF; 


class ShellManagerSpecific : public SMPF {  
private:
    typedef utilities::BasicSensor<shells::SVertexDisplacement> BasicSensorSp;
    
public:
    ShellManagerSpecific(const std::string& controlFileName, MPI_Comm solidComm,
                         int numFluidNodes, int firstFluidNode) : 
        SMPF(controlFileName, solidComm), _subIterations(1) {
        
#ifdef DEBUG_PRINT
        int myRank;
        std::ostringstream obuf;
        MPI_Comm_rank(solidComm, &myRank);
        obuf << "S" << myRank << ".log" << static_cast<char>(0);
        oflog.open(obuf.str().c_str());     
        _olog = new std::ostream(oflog.rdbuf());
#endif
        
        computeMassPrepareAdvance();
        
#ifdef DEBUG_PRINT_ELC
        (*_olog << "*** LagrangianComm: " << numFluidNodes << "  " << firstFluidNode ).flush();
#endif  
        // instantiate an elc object for data exchange
        _elcLag = new elc::LagrangianComm<DIM, double>(MPI_COMM_WORLD, solidComm, numFluidNodes,
                                                       firstFluidNode, elc::GlobalIdentifiers);
#ifdef DEBUG_PRINT_ELC
        (*_olog << " created.\n").flush();
#endif  

        // read _subIterations from input file
        utilities::PropertiesParser *prop = new utilities::PropertiesParser;
        prop->registerPropertiesVar("SubIterations", _subIterations);
        std::ifstream inputFile("./shellInput.dat");
        if (!inputFile.is_open()) assert(false);
        prop->readValues(inputFile);    
        delete prop;
        inputFile.close();
        
#ifdef DEBUG_PRINT
        (*_olog << "*** ShellManagerSpecific created.\n").flush();
#endif

        if (_subIterations<=0) 
            _subIterations=1;
    }


    ~ShellManagerSpecific() {
//      if (_sensor!=NULL) delete _sensor;
        if (_elcLag!=NULL) delete _elcLag;
        if (_olog!=NULL) delete _olog;
        if (_gnuplotFile!=NULL) {
            _gnuplotFile->close();
            delete _gnuplotFile;
        }
    }

   
    void sendBoundaryReceivePressure() {
        double *elCoordinates = NULL;
        double *elVelocities = NULL;
        int *elGlobalNodeIDs = NULL;
        int elNumNodes;
        int *elConnectivity = NULL;
        int elNumElements;
        
        SMPF::decode(&elCoordinates, &elVelocities, &elGlobalNodeIDs,
                     &elNumNodes, &elConnectivity, &elNumElements);
        
        // allocate space for pressure and initialize
        _elPressures.resize(elNumElements);       
        std::fill(_elPressures.begin(), _elPressures.end(), 0.0);
        
#ifdef DEBUG_PRINT_ELC
        ( *_olog << "*** ShellManagerSpecific::sendBoundaryReceivePressure" ).flush();
#endif
        
        _elcLag->sendMesh(elNumNodes, reinterpret_cast<void*>(elGlobalNodeIDs), 
                          reinterpret_cast<void*>(elCoordinates), 
                          reinterpret_cast<void*>(elVelocities), 
                          elNumElements, reinterpret_cast<void*>(elConnectivity));
        _elcLag->waitForMesh();
        _elcLag->receivePressure(elNumElements, reinterpret_cast<void*>(&(_elPressures[0])));
        _elcLag->waitForPressure();

        // Necessary if solid domain larger than fluid domain
        for (unsigned int n=0; n<_elPressures.size(); n++) {
            if (_elPressures[n] == std::numeric_limits<double>::max()) {
                _elPressures[n] = 0.0;
            }
        }

        encodePressure(&(_elPressures[0]), _elPressures.size(), element);
        
#ifdef DEBUG_PRINT_ELC
        ( *_olog << " done.\n" ).flush();
#endif
    }


    virtual void advanceSp(double& t, double& dt){
        dt /= _subIterations;
        setTimeStep(dt);

#ifdef DEBUG_PRINT
        (*_olog << "*** advancing in time.\n").flush();
#endif

        // functors for fixing nodes at the flaps 
        
        // define a bounding box for nodes to be fixed
        double low0[3]={-100., 0.014 , 0.43};
        double upp0[3]={ 0., 0.0145, 0.46};
        typedef shells::CheckSVtxFieldInBox<shells::SVertexCoordinate> CoordinateCheck;
        CoordinateCheck check0(low0, upp0);

        // set displacements to zero
        typedef shells::PrescribeSVtxField<shells::SVertexDisplacement> PrescribeDisp;    
        double bdisp[3]={0., 0., 0.};
        PrescribeDisp prd(bdisp);
        
        typedef shells::CheckPrescribeSVtxField<PrescribeDisp, CoordinateCheck> CheckPrescribeDisp;
        CheckPrescribeDisp checkpr0(prd, check0);

        double low1[3]={0., 0.014, 0.43};
        double upp1[3]={100.,0.0145, 0.46};
        CoordinateCheck check1(low1, upp1);
        CheckPrescribeDisp checkpr1(prd,check1);
        
        predictAndEnforceBC();
        mShell()->iterateOverVertices(checkpr0);
        mShell()->iterateOverVertices(checkpr1);

        sendBoundaryReceivePressure();
        internalExternalForces();       
        correct();      
        incrementCurrentTimeAndStep();

        for (int n=1; n<_subIterations; n++) {      
            predictAndEnforceBC();       
            mShell()->iterateOverVertices(checkpr0);
            mShell()->iterateOverVertices(checkpr1);

            internalExternalForces();   
            correct();  
            incrementCurrentTimeAndStep();
        }

        dt = stableTimeStep()*_subIterations;
        t = getCurrentTime();
        
        // print sensors
        const int stepNum  = getCurrentStepNum();
        std::for_each(_sensors.begin(), _sensors.end(), 
                      std::bind2nd(std::mem_fun(&BasicSensorSp::printData), t));
    }
    
    
    void addSensors(double xyz[3]) {
        // open a file and instantiate a sensor
        const int myRank = communicatorRank();
        std::string nameGnuplot = utilities::makeUniqueName(_sensors.size(), myRank, "./dispSensor-", "dat");
        std::ofstream *gnuplotFile = new std::ofstream(nameGnuplot.c_str(), std::ofstream::app);
        BasicSensorSp *s = new BasicSensorSp(*gnuplotFile, ShellManagerBasic::mShell(), xyz);   
        _sensors.push_back(s);
    }

         
    void initialize(double& t, double& dt){
        sendBoundaryReceivePressure();
        dt = stableTimeStep()*_subIterations;
        t = getCurrentTime();
        
        // add sensors
        const double radius = 0.020195;
        const double z0 = 0.4566;
        // const double z1 = 0.4314;
        
        double first[3] = {-0.008, radius, z0};
        double second[3] = {0.0, radius, z0};
        addSensors(first);
        addSensors(second);

        double third[3] = {-0.008, radius, z0};
        double fourth[3] = {0.0, radius, z0};
        addSensors(third);
        addSensors(fourth);
    }

 
    void output() {
        printDataParallel(true);

#ifdef DEBUG_PRINT
        ( *_olog << " Printing interface mesh and pressure.\n" ).flush();
        printIFaceMeshPressureParallel();
#endif
    }


    int nSteps() {
        return getCurrentStepNum()/_subIterations;
    }


    void checkpointing() {
        checkPointingParallel();
    }

    void restartSp(double& t, double& dt) {
        restartParallel();
        t = getCurrentTime();
        dt = stableTimeStep()*_subIterations;
        
        sendBoundaryReceivePressure();
        return;
    }

    
// copy and assignment constructors - not implemented
private:
    ShellManagerSpecific(const ShellManagerSpecific &);
    const ShellManagerSpecific & operator=(const ShellManagerSpecific &);   
    
private:
    elc::LagrangianComm<DIM, double>     *_elcLag;

    std::ostream                         *_olog;
    std::ofstream                         oflog; 

    std::ofstream                        *_gnuplotFile;
        
    std::vector<double>                  _elPressures;

    std::vector<BasicSensorSp *>         _sensors;

    int                                  _subIterations;
};

#endif

---