shells/applications/cylinderElastic/excentric/ExBasicSensor.h

Go to the documentation of this file.

// -*- C++ -*-
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// 
//                                   Fehmi Cirak
//                        California Institute of Technology
//                           (C) 2004 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#ifndef EXBASICSENSOR_H
#define EXBASICSENSOR_H
#include <functional>
#include <iterator>
#include <cmath>

#include "shells/driverCC/MShell.h"
#include "shells/driverCC/SVertexFunctors.h"



namespace cylExp {
    template<typename EXTR>
    class BasicSensor;
}


namespace cylExp {
    
    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:
        typedef std::vector<typename EXTR::DataType>                 _DataCont;
        typedef std::vector<shells::SVertexCoordinate::DataType>     _CoordinateCont;
        

        static const unsigned                    _spaceDim;     
        std::ostream&                           _os;
        shells::MShell                  * const _mShell;
        int                                     _closestVertexID;
        shells::SVertexCoordinate::DataType     _position[shells::SVertexCoordinate::numVar];
    };
}


// implementations
namespace cylExp {
    
    // definition of static variable
    template<typename EXTR>
    const unsigned BasicSensor<EXTR>::_spaceDim = shells::SVertexCoordinate::numVar;

    
    // implementation of member methods
    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;

        // collect all the reference coordinates
        _CoordinateCont coordinates;
        size_t numVertices = _mShell->numberOfVertices();
        coordinates.reserve(numVertices*_spaceDim);
        
        
        shells::SVertexCollector<std::back_insert_iterator<_CoordinateCont>, 
            shells::SVertexCoordinate> getCoordinates;
        _mShell->iterateOverVertices(std::bind2nd(getCoordinates, 
                                                  std::back_inserter(coordinates)));
        
        assert((numVertices*_spaceDim)==coordinates.size());
        assert(numVertices);
        
        // find the closest vertex ID to sensorPosition
        double minDistanceSqr = 0.0;
        _closestVertexID = 0;
        
        for (unsigned j=0; j<_spaceDim; ++j) { 
            minDistanceSqr += (sensorPosition[j]-coordinates[j])*
                (sensorPosition[j]-coordinates[j]);
        }
                
        // find the closest vertex 
        for (unsigned i=1; i<numVertices; ++i) {
            double distanceSqr = 0.0;
            for (unsigned j=0; j<_spaceDim; ++j) {
                distanceSqr += (sensorPosition[j]-coordinates[i*_spaceDim+j])*
                    (sensorPosition[j]-coordinates[i*_spaceDim+j]); 
            }
            
            if (distanceSqr<minDistanceSqr) {
                minDistanceSqr = distanceSqr;
                _closestVertexID = i;
            }
        }
        
        for (unsigned i=0; i<_spaceDim; ++i) {
            _position[i] = coordinates[_closestVertexID*_spaceDim+i];
        }
        
        std::cout << "Attaching to vertex with GlobalD: " << _closestVertexID << " and position ";
        for (unsigned i=0; i<_spaceDim; ++i) {
            std::cout << _position[i] << " ";
        }
        std::cout << std::endl;
    }


    
    template<typename EXTR>
    void BasicSensor<EXTR>::printData(double timeStamp) 
    {
        const size_t numVar = EXTR::numVar;
        size_t numVertices = _mShell->numberOfVertices();
        
        // apply EXTR to all vertices for collecting data
        _DataCont variable;     
        variable.reserve(numVertices*numVar);
        shells::SVertexCollector<std::back_insert_iterator<_DataCont>, EXTR> getData;
        _mShell->iterateOverVertices(std::bind2nd(getData, 
                                                  std::back_inserter(variable)));       
        
        assert((numVertices*numVar)==variable.size());
        
        // print the data belonging to _closestVertexID
        double disp[3];
        _os << timeStamp << " ";

        for (unsigned i=0; i<numVar; ++i) {
            unsigned offSet = _closestVertexID*numVar+i;
            assert(offSet<variable.size());
            disp[i] = variable[offSet];
            _os << disp[i] << " ";
        }       
        
        double rad = std::sqrt(disp[0]*disp[0]+disp[1]*disp[1]);
        const double skp = disp[0]*_position[0]+disp[1]*_position[1];
        
        if (skp<0.0) {
            rad = -rad;
        }

        _os << rad << std::endl;
    }
}

#endif

---