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

Go to the documentation of this file.

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

#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"


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


class ShellManagerSpecific : public SMP {  
private:
    typedef utilities::BasicSensor<shells::SVertexDisplacement> BasicSensorSp;
  
public:
    ShellManagerSpecific(const std::string& controlFileName, MPI_Comm solidComm,
                         int numFluidNodes, int firstFluidNode) : 
        SMP(controlFileName, solidComm), _sensor0(NULL), _sensor1(NULL), 
        _subIterations(1) {
        
#ifdef DEBUG_PRINT
        int myRank;
        MPI_Comm_rank(solidComm, &myRank);

        std::stringstream nameStr;
        nameStr << "S";
        nameStr << myRank;
        nameStr << ".log";
        std::string name;
        nameStr >> name;
        _olog = new std::ofstream(name.c_str());
#endif
        computeMassPrepareAdvance();
        
        // 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 << "*** LagrangianComm created.\n").flush();
#endif  
        
        // read data 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<1) 
            _subIterations = 1;
    };


    ~ShellManagerSpecific() {
        if (_sensor0!=NULL) delete _sensor0;
        if (_sensor1!=NULL) delete _sensor1;
        if (_elcLag!=NULL) delete _elcLag;
        if (_olog!=NULL) delete _olog;
        if (_gnuplotFile0!=NULL) {
            _gnuplotFile0->close();
            delete _gnuplotFile0;
        }
        if (_gnuplotFile1!=NULL) {
            _gnuplotFile1->close();
            delete _gnuplotFile1;
        }
    }

   
    void sendBoundaryReceivePressure() {
        double *elCoordinates = NULL;
        double *elVelocities = NULL;
        int *elGlobalNodeIDs = NULL;
        int elNumNodes;
        int *elConnectivity = NULL;
        int elNumElements;
        
        SMP::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();

        // this hack is necessary if solid domain larger than fluid domain
        for (unsigned n=0; n<_elPressures.size(); n++) {
            if (_elPressures[n] == std::numeric_limits<double>::max()) {
                _elPressures[n] = 0.0;
            }
        }
        
        // apply pressure loading
        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);

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

        for (int n=1; n<_subIterations; ++n) {      
          predictAndEnforceBC();         
          internalExternalForces();     
          correct();    
          incrementCurrentTimeAndStep();
        }
        
        
        dt = stableTimeStep()*_subIterations;
        t = getCurrentTime();

        // print sensor data every five steps - currently hard wired
        assert (_sensor0!=NULL);
        assert (_sensor1!=NULL);
        const int stepNum  = getCurrentStepNum();
        if (!(stepNum%5)) { 
            _sensor0->printData(t);
            _sensor1->printData(t);
        }
    }

         
    void initialize(double& t, double& dt){
        sendBoundaryReceivePressure();
        dt = stableTimeStep()*_subIterations;
        t = getCurrentTime();

        // open a file and instantiate sensors
        // find out to which file to write
        utilities::PropertiesParser *prop = new utilities::PropertiesParser;
        std::string sensorFileName;
        prop->registerPropertiesVar("sensorFileName", sensorFileName);
        std::ifstream inputFile("./shellInput.dat");
        if (!inputFile.is_open()) assert(false);
        prop->readValues(inputFile);

        const int myRank = communicatorRank();
        std::string nameGnuplot0 = 
            utilities::makeUniqueName(0, myRank, sensorFileName.c_str(), "dat");
        std::string nameGnuplot1 = 
            utilities::makeUniqueName(1, myRank, sensorFileName.c_str(), "dat");
        
        const double zPosition = 0.210; 
        _gnuplotFile0 = new std::ofstream(nameGnuplot0.c_str(), std::ios::app);
        double attachPoint0[3]={0.019506872061907737, 0.005226850615845407, zPosition};
        
        _gnuplotFile1 = new std::ofstream(nameGnuplot1.c_str(), std::ios::app);
        double attachPoint1[3]={-0.01428002144606233, -0.01428002144606233, zPosition};

        delete prop;
        inputFile.close();

        _sensor0 = new BasicSensorSp(*_gnuplotFile0, ShellManagerBasic::mShell(), 
                                     attachPoint0);     
        assert(_sensor0!=NULL);
        
        _sensor1 = new BasicSensorSp(*_gnuplotFile1, ShellManagerBasic::mShell(), 
                                     attachPoint1);     
        assert(_sensor1!=NULL);
    }

 
    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::ofstream                             *_olog;

    std::ofstream                             *_gnuplotFile0;
    std::ofstream                             *_gnuplotFile1;
        
    std::vector<double>                        _elPressures;

    BasicSensorSp                             *_sensor0;
    BasicSensorSp                             *_sensor1;

    int                                        _subIterations;
};

#endif

---