Grid.h

Go to the documentation of this file.

//- ****************************************************************************
//-
//- Copyright 2009 National Technology & Engineering Solutions of Sandia, LLC
//- (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
//- Government retains certain rights in this software.
//-
//- BSD Open Source License
//- All rights reserved.
//-
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//-
//-   1. Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-
//-   2. Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-
//-   3. Neither the name of the copyright holder nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//-
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef SLBM_GRID_H
#define SLBM_GRID_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
#include <vector>
#include <map>
#include <cmath>
 
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "SLBMGlobals.h"
#include "GridProfile.h"
#include "InterpolatedProfile.h"
#include "LayerProfile.h"
#include "LayerProfileG.h"
#include "QueryProfile.h"
#include "CrustalProfile.h"
#include "CrustalProfileStore.h"
#include "GreatCircle.h"
#include "GreatCircleFactory.h"
#include "Location.h"
#include "SLBMException.h"
#include "Triangle.h"
#include "UncertaintyPIU.h"
#include "UncertaintyPDU.h"
#include "GeoTessPolygon.h"
#include "GeoTessModelSLBM.h"
 
#include "DataBuffer.h"
#include "MD50.h"
 
// **** _BEGIN SLBM NAMESPACE_ **************************************************
 
namespace slbm {
 
class SLBM_EXP_IMP Grid
{
 
public:
 
    Grid();
 
    virtual ~Grid();
 
    static Grid* getGrid(const string& modelDirectory);
 
    static Grid* getGrid(util::DataBuffer& buffer);
 
    static bool fileExists(const string& fileName);
 
    virtual bool operator == (const Grid& other);
 
    virtual bool operator != (const Grid& other) {return !(*this == other);};
 
    static string class_name() {return "Grid"; };
 
    virtual void clear();
 
    virtual void loadFromFile(const string& filename) = ABSTRACT;
 
    virtual void loadFromDirectory(const string& dirName) = ABSTRACT;
 
    virtual void loadFromDataBuffer(util::DataBuffer& buffer) = ABSTRACT;
 
    virtual void saveVelocityModel(util::DataBuffer& buffer) = ABSTRACT;
 
    virtual void saveVelocityModel(const string& filename, const int& format) = ABSTRACT;
 
    virtual int getBufferSize() const = ABSTRACT;
 
    virtual bool is_directory(const string& dir);
 
    virtual int getNNodes()      { return profiles.size(); }
 
    virtual int  getNIntervals()    { return NLAYERS;};
 
    virtual GridProfile* getProfile(const int& nodeId);
 
    virtual GreatCircle* getGreatCircle(
            const int& phase,
            const double& latSource,
            const double& lonSource,
            const double& depthSource,
            const double& latReceiver,
            const double& lonReceiver,
            const double& depthReceiver,
            const double& delta,
            const double& ch_max);
 
    //CrustalProfile* getCrustalProfile(const int& phase,
    //  const double& lat, const double& lon, const double& depth);
 
    virtual CrustalProfile* getReceiverProfile(const int& phase,
            const double& lat, const double& lon, const double& depth);
 
    virtual CrustalProfile* getSourceProfile(const int& phase,
            const double& lat, const double& lon, const double& depth);
 
    virtual void clearCrustalProfiles();
 
    virtual LayerProfile* getLayerProfile(GreatCircle* greatCircle,
            Location& location);
 
    virtual QueryProfile* getQueryProfile(Location& location);
 
    vector<vector<UncertaintyPIU*> >& getUncertainty() { return piu; }
    vector<vector<UncertaintyPIU*> >& getUncertaintyPIU() { return piu; }
 
    UncertaintyPIU& getUncertaintyPIU(int phase, int attribute) { return *piu[phase][attribute]; }
 
    vector<UncertaintyPDU*>& getUncertaintyPDU() { return pdu; }
 
    UncertaintyPDU& getUncertaintyPDU(int phase) { return *pdu[phase]; }
 
    virtual double getAverageMantleVelocity(const int& waveType) = ABSTRACT;
 
    virtual void setAverageMantleVelocity(const int& waveType, const double& velocity) = ABSTRACT;
 
    virtual int getNCrustalProfiles();
 
    virtual bool findProfile(Location& location,
            vector<GridProfile*>& neighbors, vector<int>& nodeIds,
            vector<double>& coefficients) = ABSTRACT;
 
    void initializeActiveNodes(double activeNodeLatMin,
            double activeNodeLonMin,
            double activeNodeLatMax,
            double activeNodeLonMax);
 
    void initializeActiveNodes(GeoTessPolygon* polygon);
 
    virtual int getNActiveNodes() { return activeNodes.size(); };
 
    void clearActiveNodes();
 
    virtual int getGridNodeId(int activeNodeId)
    { return (activeNodeId < 0 ? -1 : activeNodes[activeNodeId]); };
 
    virtual int getActiveNodeId(int nodeId)
    { return profiles[nodeId]->getActiveNodeId(); };
 
    virtual void getNodeNeighbors(const int& nodeId, int neighbors[], int& nNeighbors) = ABSTRACT;
 
    virtual void getNodeNeighbors(const int& nodeId, vector<int>& neighbors) = ABSTRACT;
 
    virtual void getNodeNeighborInfo(const int& nodeId, int neighbors[],
            double distance[], double azimuth[], int& nNeighbors);
 
    virtual void getNodeNeighborInfo(const int& nodeId, vector<int>& neighbors,
            vector<double>& distance, vector<double>& azimuth);
 
    virtual void getActiveNodeNeighbors(const int& nodeid, int neighbors[], int& nNeighbors) = ABSTRACT;
 
    virtual void getActiveNodeNeighbors(const int& nodeid, vector<int>& neighbors) = ABSTRACT;
 
    virtual void getActiveNodeNeighborInfo(const int& nid, int neighbors[],
            double distance[], double azimuth[], int& nNeighbors);
 
    virtual void getActiveNodeNeighborInfo(const int& nid, vector<int>& neighbors,
            vector<double>& distance, vector<double>& azimuth);
 
    // grid nodes.
    // grid nodes.
    virtual void getNodeSeparation(const int& node1, const int& node2, double& distance);
 
    virtual void getNodeAzimuth(const int& node1, const int& node2, double& azimuth);
 
    virtual void getNodeHitCount(const int& nodeId, int& hitCount)
    { hitCount = profiles[nodeId]->getHitCount(); };
 
    virtual void clearNodeHitCount();
 
    virtual int addGeoStack(GeoStack* geoStack) = ABSTRACT;
 
    virtual size_t memSize() = ABSTRACT;
 
    virtual size_t memSizeCrustalProfiles();
 
    virtual string getTessId() = ABSTRACT;
 
    string& getModelPath() { return modelPath; }
 
    virtual string toString() = ABSTRACT;
 
    virtual void setInterpolatorType(const string& interpolatorType) = ABSTRACT;
 
    virtual string getInterpolatorType() = ABSTRACT;
 
    const string getOutputDirectory() { return outputDirectory; }
 
    void specifyOutputDirectory(const string& outputDir);
 
    virtual GeoTessModelSLBM* getModel() { return model; }
 
protected:
 
    string modelPath;
 
    vector<GridProfile*> profiles;
 
    vector<int> activeNodes;
 
    GeoTessModelSLBM* model;
 
    GeoTessPolygon* polygon;
 
    CrustalProfileStore* sources;
    CrustalProfileStore* receivers;
 
    vector<vector<UncertaintyPIU*> > piu;
 
    vector<UncertaintyPDU*> pdu;
 
    void writeBufferToFile(util::DataBuffer& buffer, string fileName);
 
    void reaDataBuffererFromFile(util::DataBuffer& buffer, string dirname,
            string fileName);
 
private:
 
    string outputDirectory;
 
};
 
inline GridProfile* Grid::getProfile(const int& n)
{
    if (n < 0 || n >= (int)profiles.size())
    {
        ostringstream os;
        os << setiosflags(ios::fixed) << setiosflags(ios::showpoint) << setprecision(4);
        os << endl << "ERROR in Grid::getProfile. NodeId "<< n << " is out of range.  " << endl
                << "Valid range is >= 0 and < " << profiles.size() << endl
                << "Version " << SlbmVersion << " File " << __FILE__ << " line " << __LINE__ << endl << endl;
        throw SLBMException(os.str(),107);
    }
    return profiles[n];
}
 
inline  LayerProfile* Grid::getLayerProfile(GreatCircle* gc,
        Location& location)
{
    if (gc->getPhase()/2 == 0)
        // for Pn or Sn, return a LayerProfile with gradient info.
        return new LayerProfileG(gc, location);
    else
        // for Pg or Lg, return a LayerProfile without gradient info.
        return new LayerProfile(gc, location);
}
 
inline  QueryProfile* Grid::getQueryProfile(Location& location)
{
    return new QueryProfile(*this, location);
}
 
inline  CrustalProfile* Grid::getSourceProfile(const int& phase,
        const double& lat, const double& lon, const double& depth)
{
    return sources->getCrustalProfile(phase, lat, lon, depth);
}
 
inline  CrustalProfile* Grid::getReceiverProfile(const int& phase,
        const double& lat, const double& lon, const double& depth)
{
    return receivers->getCrustalProfile(phase, lat, lon, depth);
}
 
inline void Grid::clearCrustalProfiles()
{
    receivers->clear();
    sources->clear();
}
 
inline int Grid::getNCrustalProfiles()
{
    return receivers->getNCrustalProfiles()
            + sources->getNCrustalProfiles();
}
 
inline size_t Grid::memSizeCrustalProfiles()
{
    return receivers->memSize() + sources->memSize();
}
 
inline void Grid::clearNodeHitCount()
{
    for (int i=0; i<(int)profiles.size(); ++i)
        profiles[i]->clearHitCount();
}
 
inline bool Grid::fileExists(const string& fileName)
{
    fstream f;
 
    f.open(fileName.c_str(), ios::in);
    if (f.is_open())
    {
        f.close();
        return true;
    }
    return false;
}
 
 
} // end slbm namespace
 
#endif // GRID_H