shells/utilities/BasicSensor.h

Go to the documentation of this file.

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

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


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


namespace utilities {

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;
    shells::SVertex    *           _closestVertex;
};

}


// implementations
namespace utilities {

    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::set<shells::SVertex *> SVertexSet;
        SVertexSet vertexSet;
        std::insert_iterator<SVertexSet> inserter(vertexSet, vertexSet.begin());
        shells::SElementTriangleVertices<std::insert_iterator<SVertexSet> > op;
        mShell->iterateOverElements(std::bind2nd(op, inserter), shells::MShell::active);
        const unsigned numVertices = vertexSet.size();

        // collect all the reference coordinates        
        _CoordinateCont coordinates;
        coordinates.reserve(numVertices*_spaceDim);
        
        shells::SVertexCollector<std::back_insert_iterator<_CoordinateCont>, 
            shells::SVertexCoordinate> getCoordinates;

        std::for_each(vertexSet.begin(), vertexSet.end(),
                      std::bind2nd(getCoordinates, std::back_inserter(coordinates)));
                
        assert((numVertices*_spaceDim)==coordinates.size());
        
        // find the closest vertex ID to sensorPosition
        double minDistanceSqr = 0.0;
        unsigned 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;
            }
        }
        
        SVertexSet::iterator itc = vertexSet.begin();
        std::advance(itc, closestVertexID);
        _closestVertex = *itc;
        
        _os << "Attaching to vertex with GlobalD " << closestVertexID << " and position ";
        for (unsigned i=0; i<_spaceDim; ++i) {
            _os << coordinates[closestVertexID*_spaceDim+i] << " ";
        }

        _os << "\nRequested 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

---