fsi/sfc-amroc/TubeCJBurnFrac/src/BasicSensorSpecific.h

Go to the documentation of this file.

// -*- C++ -*-
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// 
//                                   Fehmi Cirak
//                        California Institute of Technology
//                           (C) 2005 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#ifndef BASICSENSORSPECIFIC_H
#define BASICSENSORSPECIFIC_H
#include "shells/driverCC/MShell.h"
#include "shells/driverCC/SVertexFunctors.h"
#include "shells/driverCC/SElementFunctors.h"

#include <functional>
#include <iterator>
#include <ostream>
#include <cassert>
#include <set>
#include <vector>
#include <algorithm>


namespace shells {
    class MShell;
}
 
namespace specific {
    template<typename EXTR>
    class BasicSensor;
}


// helper
namespace {
    double distanceSqr(const double f[3], const double s[3]) {
        const double dx = f[0]-s[0];
        const double dy = f[1]-s[1];
        const double dz = f[2]-s[2];
        return (dx*dx+dy*dy+dz*dz);
    }
}


namespace specific {

template<typename EXTR>
class BasicSensor {
public:
    BasicSensor(std::ostream& os, shells::MShell * const mShell, 
                const double sensorPosition[shells::SVertexCoordinate::numVar]);
    ~BasicSensor(){_os.flush();}
    
    void printData(double timeStamp);
    
private:
    BasicSensor(const BasicSensor &);
    const BasicSensor & operator=(const BasicSensor &);
    
private:
    static const unsigned          _spaceDim;
    
    std::ostream&                  _os;
    shells::MShell     * const     _mShell;
    shells::SVertex    *           _closestVertex;
};

}


// implementations
namespace specific {

    template<typename EXTR>
    BasicSensor<EXTR>::BasicSensor(std::ostream& os, shells::MShell * const mShell, 
                                   const double sensorPosition[shells::SVertexCoordinate::numVar]):
        _os(os), _mShell(mShell)
    {
        // scientific format for output
        _os << std::scientific;

        // find triangle vertices - this also works for fracture
        typedef std::vector<shells::SVertex *> SVertexVec;
        SVertexVec vertices;
        typedef std::back_insert_iterator<SVertexVec> BinsVtxIt;
        BinsVtxIt verticesIt(vertices);
        shells::SElementTriangleVertices<BinsVtxIt> verticesCollect;
        mShell->iterateOverElements(std::bind2nd(verticesCollect, verticesIt), shells::MShell::active);

        typedef std::vector<shells::SVertexCoordinate::DataType> CoordinateVec;
        CoordinateVec centers;
        typedef std::back_insert_iterator<CoordinateVec> BinsCoorIt;
        shells::SElementTriangleAverage<BinsCoorIt, shells::SVertexCoordinate> centerCollect;
        BinsCoorIt centersIt(centers);
        mShell->iterateOverElements(std::bind2nd(centerCollect, centersIt), shells::MShell::active);

        const unsigned numElements = static_cast<unsigned>(centers.size()/_spaceDim);
        
        // find clossest element center
        double minDistanceSqr = 1.e18;
        int clossestElementID=0;

        assert(_spaceDim==3);
        for (unsigned i=0; i<numElements; ++i) {            
            const double dc = distanceSqr(&(centers[i*_spaceDim]), sensorPosition);
            const double sameSideTest = centers[i*_spaceDim]*sensorPosition[0];
            if ((dc<minDistanceSqr)&&(sameSideTest>0.0)) {
                minDistanceSqr = dc;
                clossestElementID = i;
            }
        }
        
        // find the clossest Vertex
        const int vtxPerElem = shells::SElementTriangleVertices<BinsVtxIt>::numVert;
        shells::SVertex *vtx = vertices[clossestElementID*vtxPerElem];
        shells::SVertexCoordinate getCoordinate;

        minDistanceSqr = 1.e18;
        _closestVertex = NULL;

        for (unsigned i=0; i<vtxPerElem; ++i) {
            vtx = vertices[clossestElementID*vtxPerElem+i];
            double * vtxCoor = getCoordinate(vtx);
            const double dc = distanceSqr(vtxCoor, sensorPosition);

            if (dc<minDistanceSqr) {
                minDistanceSqr = dc;
                _closestVertex = vtx;
            }
        }
        
        assert(_closestVertex!=NULL);
        
        shells::SVertexNodeID getId;
        const unsigned vertexId = *(getId(_closestVertex));
        _os << "Attaching to vertex with GlobalID " << vertexId <<  " an position ";
        double *vtxCoor = getCoordinate(_closestVertex);
        
        // following trick ensures that exctract disp works properly
        const double eps = 1.e-8;       
        if (sensorPosition[0]<0.0) {
            _os << vtxCoor[0]- eps << " ";
        } else {
            _os << vtxCoor[0]+ eps << " ";
        }
        
        _os << vtxCoor[1] << " " << vtxCoor[2];

        _os << "\n Requested sensor position ";
        for (unsigned i=0; i<_spaceDim; ++i) {
            _os << sensorPosition[i] << " ";
        }

        _os << std::endl;
    }


    
    template<typename EXTR>
    void BasicSensor<EXTR>::printData(double timeStamp) 
    {
        _os << timeStamp << " ";
        
        EXTR dispFunc;
        assert(_closestVertex!=NULL);
        typename EXTR::DataType *disp = dispFunc(_closestVertex);       

        for (unsigned i=0; i<EXTR::numVar; ++i) {
            _os << disp[i] << " ";
        }
        
        _os << std::endl;
    }

    template<typename EXTR>
    const unsigned BasicSensor<EXTR>::_spaceDim = shells::SVertexCoordinate::numVar;
    
}

#endif

---