GeoTessModel.h

Go to the documentation of this file.

//- ****************************************************************************
//- 
//- Copyright 2009 Sandia Corporation. Under the terms of Contract
//- DE-AC04-94AL85000 with Sandia Corporation, 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:
//- 
//-    * Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-    * 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.
//-    * Neither the name of Sandia National Laboratories 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 GEOTESSMODEL_OBJECT_H
#define GEOTESSMODEL_OBJECT_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <map>
 
// use standard library objects
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "CPPUtils.h"
#include "GeoTessUtils.h"
#include "GeoTessInterpolatorType.h"
#include "GeoTessException.h"
#include "GeoTessPointMap.h"
#include "GeoTessProfileSurface.h"
#include "GeoTessProfileEmpty.h"
#include "GeoTessProfileSurfaceEmpty.h"
#include "GeoTessProfileType.h"
#include "EarthShape.h"
 
// **** _BEGIN GEOTESS NAMESPACE_ **********************************************
 
namespace geotess
{
 
// **** _FORWARD REFERENCES_ ***************************************************
 
class GeoTessPosition;
class GeoTessGrid;
class GeoTessMetaData;
class GeoTessOptimizationType;
class GeoTessProfile;
class IFStreamAscii;
class IFStreamBinary;
 
// **** _CLASS DEFINITION_ *****************************************************
 
class GEOTESS_EXP_IMP GeoTessModel
{
 
protected:
 
    static  map<string, GeoTessGrid*>   reuseGridMap;
 
    GeoTessGrid*                                                grid;
 
    GeoTessProfile***                                                   profiles;
 
    GeoTessMetaData*                                        metaData;
 
    GeoTessPointMap*                                                        pointMap;
 
    void deleteProfiles();
 
    void loadModelAscii(const string& inputFile, const string& relGridFilePath);
 
    virtual void loadModelAscii(IFStreamAscii& input, const string& inputDirectory,
            const string& relGridFilePath);
 
    void loadModelBinary(const string& inputFile, const string& relGridFilePath);
 
    virtual void loadModelBinary(IFStreamBinary& input, const string& inputDirectory,
            const string& relGridFilePath);
 
    void writeModelAscii(const string& outputFile, const string& gridFileName);
 
    virtual void writeModelAscii(IFStreamAscii& output, const string& gridFileName);
 
    void writeModelBinary(const string& outputFile, const string& gridFileName);
 
    virtual void writeModelBinary(IFStreamBinary& output, const string& gridFileName);
 
    template<class T>
    void    loadGrid(T& input, const string& inputDirectory,
            const string& relGridFilePath, const string& gridFileName,
            const string& gridID, const string& funcName)
    {
        // process grid
 
        grid = NULL;
        map<string, GeoTessGrid*>::iterator it = reuseGridMap.find(gridID);
        if (it != reuseGridMap.end())
            grid = it->second;
 
        if (gridFileName == "*")
        {
            // load the grid from this input file.  The grid has to be read from the
            // file, even a reference was retrieved from the reuseGridMap, so that the
            // file is positioned where classes that extend GeoTessModel can read
            // additional data.
            GeoTessGrid* g = new GeoTessGrid(input);
            if (!grid)
            {
                grid = g;
 
                grid->setGridInputFile(metaData->getInputModelFile());
 
                if (metaData->isGridReuseOn())
                    reuseGridMap[gridID] = grid;
            }
            else
                delete g;
        }
        else if (!grid)
        {
            // build the name of the grid file using the input directory and
            // the relative path to the grid file. Assume that both
            // inputDirectory and relGridFilePath may be null or empty.
            string gridFil = gridFileName;
            if (relGridFilePath != "")
                gridFil = CPPUtils::insertPathSeparator(relGridFilePath, gridFileName);
            if (inputDirectory != "")
                gridFil = CPPUtils::insertPathSeparator(inputDirectory, gridFil);
 
            grid = new GeoTessGrid();
            grid->loadGrid(gridFil);
            if (metaData->isGridReuseOn())
                reuseGridMap[gridID] = grid;
 
            // throw an error if the grid ID's are not equal
 
            if (grid->getGridID() != gridID)
            {
                ostringstream os;
                os << endl << "ERROR in GeoTessModel::" + funcName << endl
                        << "gridIDs in model file and existingGrid are not equal: "
                        << endl << "  Model File gridID = " << gridID << endl
                        << "  Grid File gridID  = " << grid->getGridID() << endl;
                throw GeoTessException(os, __FILE__, __LINE__, 1002);
            }
        }
 
        // add a reference to the grid and build the point map
 
        grid->addReference();
    }
 
private:
 
    void constructor(const string& gridFileName, GeoTessGrid* grid, GeoTessMetaData* metaData);
 
 
public:
 
    GeoTessModel();
 
    GeoTessModel(const string& inputFile, const string& relativeGridPath);
 
    GeoTessModel(const string& modelInputFile);
 
    GeoTessModel(vector<int>& attributeFilter);
 
    GeoTessModel(const string& inputFile, const string& relativeGridPath,
            vector<int>& attributeFilter);
 
    GeoTessModel(const string& modelInputFile, vector<int>& attributeFilter);
 
    GeoTessModel(const string& gridFileName, GeoTessMetaData* metaData);
 
    GeoTessModel(GeoTessGrid* grid, GeoTessMetaData* metaData);
 
    virtual ~GeoTessModel();
 
    virtual  string class_name() { return "GeoTessModel"; }
 
    GeoTessModel* loadModel(const string& inputFile, const string& relGridFilePath = "");
 
    static bool isGeoTessModel(const string& fileName);
 
    static string getClassName(const string& fileName, const string& relGridFilePath = ".");
 
    virtual LONG_INT getMemory()
    {
        LONG_INT memory = (LONG_INT)sizeof(GeoTessModel);
 
        memory += metaData->getMemory();
 
        if (profiles)
            for (int i=0; i<getNVertices(); ++i)
                for (int j=0; j<getNLayers(); ++j)
                    if (profiles[i][j])
                        memory += profiles[i][j]->getMemory();
        if (pointMap)
            memory += pointMap->getMemory();
        return memory;
    }
 
    static LONG_INT getReuseGridMapMemory()
    {
        // this ignores some memory allocated to support the map.  It is complicated and
        // platform dependent.  Also probably small compared to the size of the Grids.
        LONG_INT memory = sizeof(map<string, GeoTessGrid*>);
 
        memory += (LONG_INT) (reuseGridMap.size() * (sizeof(string) + sizeof(GeoTessGrid*)));
 
        for (map<string, GeoTessGrid*>::iterator it = reuseGridMap.begin(); it != reuseGridMap.end(); it++)
            memory += (LONG_INT)it->first.length() + it->second->getMemory();
 
        return memory;
    }
 
    static int getReuseGridMapSize() { return reuseGridMap.size(); }
 
    static void clearReuseGrid() { reuseGridMap.clear(); }
 
    EarthShape& getEarthShape() { return metaData->getEarthShape(); }
 
    void setEarthShape(const string& earthShapeName) { metaData->setEarthShape(earthShapeName); }
 
    const GeoTessGrid& getGrid() const { return *grid; }
 
    GeoTessGrid& getGrid(){ return *grid; }
 
    GeoTessMetaData& getMetaData() { return *metaData; }
 
    GeoTessPosition* getPosition();
 
    GeoTessPosition* getPosition(const GeoTessInterpolatorType& horizontalType);
 
    GeoTessPosition* getPosition(const GeoTessInterpolatorType& horizontalType,
            const GeoTessInterpolatorType& radialType);
 
    int getNVertices() const { return grid->getNVertices(); }
 
    int getNLayers() const { return metaData->getNLayers(); }
 
    int getNRadii(int vertexId, int layerId) { return profiles[vertexId][layerId]->getNRadii(); }
 
    int getNData(int vertexId, int layerId) { return profiles[vertexId][layerId]->getNData(); }
 
    int getNAttributes() { return metaData->getNAttributes(); }
 
    double getRadius(int vertexId, int layerId, int nodeId)
    { return profiles[vertexId][layerId]->getRadius(nodeId); }
 
    double getDepth(int vertexId, int layerId, int nodeId)
    { return getEarthShape().getEarthRadius(grid->getVertex(vertexId))
             - profiles[vertexId][layerId]->getRadius(nodeId); }
 
    double getValueDouble(int vertexId, int layerId, int nodeId, int attributeIndex)
    {
        GeoTessData* data = profiles[vertexId][layerId]->getData(nodeId);
        return data == NULL ? NaN_DOUBLE : data->getDouble(attributeIndex);
    }
 
    float getValueFloat(int vertexId, int layerId, int nodeId, int attributeIndex)
    {
        GeoTessData* data = profiles[vertexId][layerId]->getData(nodeId);
        return data == NULL ? NaN_FLOAT : data->getFloat(attributeIndex);
    }
 
    LONG_INT getValueLong(int vertexId, int layerId, int nodeId, int attributeIndex)
    {
        GeoTessData* data = profiles[vertexId][layerId]->getData(nodeId);
        return data == NULL ? LONG_MIN : data->getLong(attributeIndex);
    }
 
    int getValueInt(int vertexId, int layerId, int nodeId, int attributeIndex)
    {
        GeoTessData* data = profiles[vertexId][layerId]->getData(nodeId);
        return data == NULL ? INT_MIN : data->getInt(attributeIndex);
    }
 
    short getValueShort(int vertexId, int layerId, int nodeId, int attributeIndex)
    {
        GeoTessData* data = profiles[vertexId][layerId]->getData(nodeId);
        return data == NULL ? SHRT_MIN : data->getShort(attributeIndex);
    }
 
    byte getValueByte(int vertexId, int layerId, int nodeId, int attributeIndex)
    {
        GeoTessData* data = profiles[vertexId][layerId]->getData(nodeId);
        return data == NULL ? CHAR_MIN : data->getByte(attributeIndex);
    }
 
    template<typename T>
    void setValue(int vertexId, int layerId, int nodeId, int attributeIndex, T value)
    { profiles[vertexId][layerId]->getData(nodeId)->setValue(attributeIndex, value); }
 
    double getRadius(int pointIndex)
    { return getPointMap()->getPointRadius(pointIndex); }
 
    double getDepth(int pointIndex)
    { return getPointMap()->getPointDepth(pointIndex); }
 
    double getValueDouble(int pointIndex, int attributeIndex)
    {
        GeoTessData* data = getPointMap()->getPointData(pointIndex);
        return data == NULL ? NaN_DOUBLE : data->getDouble(attributeIndex);
    }
 
    float getValueFloat(int pointIndex, int attributeIndex)
    {
        GeoTessData* data = getPointMap()->getPointData(pointIndex);
        return data == NULL ? NaN_FLOAT : data->getFloat(attributeIndex);
    }
 
    LONG_INT getValueLong(int pointIndex, int attributeIndex)
    {
        GeoTessData* data = getPointMap()->getPointData(pointIndex);
        return data == NULL ? LONG_MIN : data->getLong(attributeIndex);
    }
 
    int getValueInt(int pointIndex, int attributeIndex)
    {
        GeoTessData* data = getPointMap()->getPointData(pointIndex);
        return data == NULL ? INT_MIN : data->getInt(attributeIndex);
    }
 
    short getValueShort(int pointIndex, int attributeIndex)
    {
        GeoTessData* data = getPointMap()->getPointData(pointIndex);
        return data == NULL ? SHRT_MIN : data->getShort(attributeIndex);
    }
 
    byte getValueByte(int pointIndex, int attributeIndex)
    {
        GeoTessData* data = getPointMap()->getPointData(pointIndex);
        return data == NULL ? CHAR_MIN : data->getByte(attributeIndex);
    }
 
    template<typename T>
    void setValue(int pointIndex, int attributeIndex, T value)
    {
        GeoTessData* data = getPointMap()->getPointData(pointIndex);
        if (data != NULL) data->setValue(attributeIndex, value);
    }
 
    int getNPoints() { return getPointMap()->size(); }
 
    virtual bool operator == (const GeoTessModel& other) const;
 
    virtual bool operator != (const GeoTessModel& other) const { return !(*this == other); } ;
 
    bool is2D()
    {
        return getProfile(0, 0)->getType() == GeoTessProfileType::SURFACE
                || getProfile(0, 0)->getType() == GeoTessProfileType::SURFACE_EMPTY;
    }
 
    bool is3D()
    {
        return !is2D();
    }
 
    GeoTessPointMap* getPointMap()
    {
        if (!pointMap->isPopulated())
            pointMap->setActiveRegion();
        return pointMap;
    }
 
    const set<int>& getConnectedVertices(int layerIndex)
    {
        return grid->getVertexIndicesTopLevel(metaData->getTessellation(layerIndex));
    }
 
    void setActiveRegion()
    {
        pointMap->setActiveRegion();
    }
 
    void setActiveRegion(const string& polygon)
    {
        pointMap->setActiveRegion(polygon);
    }
 
    void setActiveRegion(GeoTessPolygon* polygon)
    {
        if (polygon == NULL)
            pointMap->setActiveRegion();
        else
            pointMap->setActiveRegion(polygon);
    }
 
    GeoTessPolygon* getPolygon() { return pointMap->getPolygon(); }
 
    void getLayerCount(bool activeOnly, int* layerCount)
    {
        for (int layer=0; layer<getNLayers(); ++layer)
            layerCount[layer] = 0;
 
        GeoTessProfile** pp;
        GeoTessProfile* p;
        for (int v=0; v<getNVertices(); ++v)
        {
            pp = profiles[v];
            for (int layer=0; layer<getNLayers(); ++layer)
            {
                if (activeOnly)
                {
                    p = pp[layer];
                    for (int n=0; n<p->getNData(); ++n)
                        if (p->getPointIndex(n) >= 0)
                            ++layerCount[layer];
                }
                else
                    layerCount[layer] += pp[layer]->getNData();
            }
        }
    }
 
    GeoTessProfile* getProfile(int vertex, int layer)
    {
        return profiles[vertex][layer];
    }
 
    GeoTessProfile** getProfiles(int vertex)
    {
        return profiles[vertex];
    }
 
    GeoTessProfile*** getProfiles() const { return profiles; }
 
    void setProfile(int vertex, int layer, GeoTessProfile* profile);
 
    template<typename T>
    void setProfile(int vertex, int layer, vector<float>& radii, vector<vector<T> >& values)
    {
        if (getConnectedVertices(layer).count(vertex) == 1)
            setProfile(vertex, layer, GeoTessProfile::newProfile(radii, values));
        else setProfile(vertex, layer, new GeoTessProfileEmpty(radii[0], radii[radii.size()-1]));
    }
 
    template<typename T>
    void setProfile(const int& vertex, const int& layer,
            float* radii, const int& nRadii,
            T** values, const int& nNodes, const int& nAttributes)
    {
        if (getConnectedVertices(layer).count(vertex) == 1)
            setProfile(vertex, layer, GeoTessProfile::newProfile(radii, nRadii, values, nNodes, nAttributes));
        else setProfile(vertex, layer, new GeoTessProfileEmpty(radii[0], radii[nRadii-1]));
    }
 
    void setProfile(int vertex, int layer, vector<float>& radii)
    { setProfile(vertex, layer, new GeoTessProfileEmpty(radii[0], radii[radii.size()-1])); }
 
    template<typename T>
    void setProfile(const int& vertex, const int& layer, float* radii, const int& nRadii)
    { setProfile(vertex, layer, new GeoTessProfileEmpty(radii[0], radii[nRadii-1])); }
 
    template<typename T>
    void setProfile(const int& vertex, vector<T>& values)
    { setProfile(vertex, 0, new GeoTessProfileSurface(GeoTessData::getData(values))); }
 
    template<typename T>
    void setProfile(const int& vertex, T* values, const int& nAttributes)
    { setProfile(vertex, 0, new GeoTessProfileSurface(GeoTessData::getData(values, nAttributes))); }
 
    void setProfile(const int& vertex)
    { setProfile(vertex, 0, new GeoTessProfileSurfaceEmpty()); }
 
    void writeModel(const string& outputFile, const string& gridFileName = "*");
 
    string toString();
 
    void getLayerCount(vector<int>& layerCount, const bool& activeOnly)
    {
        layerCount.resize(metaData->getNLayers(), 0);
 
        GeoTessProfile** pp;
        GeoTessProfile* p;
        for (int vtx=0; vtx<getNVertices(); ++vtx)
        {
            pp = profiles[vtx];
            for (int layer = 0; layer < metaData->getNLayers(); ++layer)
                if (activeOnly)
                {
                    p = pp[layer];
                    for (int n = 0; n < p->getNData(); ++n)
                        if (p->getPointIndex(n) >= 0)
                            ++layerCount[layer];
                }
                else
                    layerCount[layer] += pp[layer]->getNData();
        }
    }
 
    void profileCount(vector< vector<int> >& count)
    {
        count.clear();
 
        getPointMap();
 
        // this is total number of profiles of each type, independent of layer index.
        vector<int> totalCount;
        for (int profileType=0; profileType<GeoTessProfileType::size(); ++profileType)
            totalCount.push_back(0);
 
        for (int layer = 0; layer < getNLayers(); ++layer)
        {
            vector<int> typeCount;
 
            for (int profileType=0; profileType<GeoTessProfileType::size(); ++profileType)
                typeCount.push_back(0);
 
            count.push_back(typeCount);
        }
 
        for (int layer = 0; layer < getNLayers(); ++layer)
        {
            for (int vertex = 0; vertex < metaData->getNVertices(); ++vertex)
            {
                int pType = profiles[vertex][layer]->getType().ordinal();
                count[layer][pType] += 1;
                totalCount[pType] += 1;
            }
        }
 
        count.push_back(totalCount);
    }
 
    template<typename T>
    void    initializeData(const vector<string>& attributeNames,
            const vector<string>& attributeUnits, T fillValue)
    {
        if (profiles == NULL)
        {
            ostringstream os;
            os << endl << "ERROR in GeoTessModel::initializeData" << endl
                    << "Attempting to initialize the model data before Profiles" << endl
                    << "have been specified (profiles == NULL)" << endl;
            throw GeoTessException(os, __FILE__, __LINE__, 1001);
        }
 
        const GeoTessDataType& newDataType = GeoTessDataType::getDataType(fillValue);
        int nAttributesNew = attributeNames.size();
 
        int newDataTypeOrdinal = newDataType.ordinal();
        int oldDataTypeOrdinal = metaData->getDataType().ordinal();
 
        // if neither the dataType or the number of attributes has changed, there is no need to
        // copy the data.  The only thing that happens is that the attributeNames or attributeUnits might change.
        if (newDataTypeOrdinal != oldDataTypeOrdinal || nAttributesNew != metaData->getNAttributes())
        {
            // initialize an array of the new dataType with number of elements
            // equal to the number of new attributes and populate it with fillValue.
            T* newValues = new T[nAttributesNew];
            for (int i=0; i<nAttributesNew; ++i)
                newValues[i] = fillValue;
 
            GeoTessProfile* profile;
            vector<GeoTessData*> data;
            for (int v = 0; v < getNVertices(); ++v)
                for (int lid = 0; lid < getNLayers(); ++lid)
                {
                    profile = profiles[v][lid];
                    data.reserve(profile->getNData());
                    data.clear();
                    for (int n = 0; n < profile->getNData(); ++n)
                    {
                        profile->getData(n)->getValues(newValues, nAttributesNew);
                        data.push_back(GeoTessData::getData(newValues, nAttributesNew));
                    }
                    // set new entries into profile and continue
                    profile->setData(data);
                }
            delete[] newValues;
        }
 
        metaData->setDataType(newDataType);
 
        metaData->setAttributes(attributeNames, attributeUnits);
    }
 
    template<typename T>
    void    initializeData(const string& attributeNames,
            const string& attributeUnits, T fillValue)
    {
        vector<string> names;
        CPPUtils::tokenizeString(attributeNames, ";", names);
        vector<string> units;
        CPPUtils::tokenizeString(attributeUnits, ";", units);
        initializeData(names, units, fillValue);
    }
 
    void getWeights(const double* pointA, const double* pointB, const double& pointSpacing, const double& radius,
            const GeoTessInterpolatorType& horizontalType, map<int, double>& weights);
 
    void getWeights(GeoTessGreatCircle& greatCircle, const double& pointSpacing, const double& radius,
            const GeoTessInterpolatorType& horizontalType, map<int, double>& weights);
 
    void getWeights(const vector<double*>& rayPath,
            const vector<double>& radii,
            const vector<int>& layerIds,
            const GeoTessInterpolatorType& horizontalType,
            const GeoTessInterpolatorType& radialType,
            map<int, double>& weights);
 
    void getWeights(double** rayPath, double* radii, int* layerIds, const int& numPoints,
            const GeoTessInterpolatorType& horizontalType,
            const GeoTessInterpolatorType& radialType,
            map<int, double>& weights);
 
    double getPathIntegral(const int& attribute, const map<int, double>& weights);
 
    double getPathIntegral(const int& attribute,
            double** rayPath, double* radii, int* layerIds, const int& numPoints,
            const GeoTessInterpolatorType& horizontalType, const GeoTessInterpolatorType& radialType,
            map<int, double>* weights = NULL);
 
    double getPathIntegral(const int& attribute,
            const vector<double*>& rayPath, const vector<double>& radii, const vector<int>& layerIds,
            const GeoTessInterpolatorType& horizontalType, const GeoTessInterpolatorType& radialType,
            map<int, double>* weights = NULL);
 
    double getPathIntegral2D(const int& attribute,
            const double* firstPoint, const double* lastPoint, double pointSpacing,
            double earthRadius, const GeoTessInterpolatorType& horizontalType,
            map<int, double>* weights = NULL);
 
    double getPathIntegral2D(const int& attribute,
            GeoTessGreatCircle& greatCircle, double pointSpacing,
            double earthRadius, const GeoTessInterpolatorType& horizontalType,
            map<int, double>* weights = NULL);
 
 
    // the following constructors are all deprecated because GeoTessOptimization is no longer used.
    // GeoTess is always optimized for speed.
    GeoTessModel(const GeoTessOptimizationType* optimization);
    GeoTessModel(const string& inputFile, const string& relativeGridPath, const GeoTessOptimizationType* optimization);
    GeoTessModel(const string& modelInputFile, const GeoTessOptimizationType* optimization);
    GeoTessModel(vector<int>& attributeFilter, const GeoTessOptimizationType* optimization);
    GeoTessModel(const string& inputFile, const string& relativeGridPath,
            vector<int>& attributeFilter, const GeoTessOptimizationType* optimization);
    GeoTessModel(const string& modelInputFile, vector<int>& attributeFilter,
            const GeoTessOptimizationType* optimization);
 
//  // The following getWeight() and getPathIntegral() functions are deprecated.
//  // They were included in GeoTessModel v2.1.1  but were reconfigured in v2.2.0.
//  // They are included here for backward compatibility, but will not appear in the documentation.
//  void getWeights(const vector<double*>& rayPath, const vector<double>& radii,
//          const GeoTessInterpolatorType& ht, const GeoTessInterpolatorType& rt, map<int, double>& weights)
//  { vector<int> layerIds; getWeights(rayPath, radii, layerIds, ht, rt, weights);}
//
//  void getWeights(double** rayPath, double* radii, const int& numPoints,
//          const GeoTessInterpolatorType& ht,const GeoTessInterpolatorType& rt,map<int, double>& weights)
//  { getWeights(rayPath, radii, NULL, numPoints, ht, rt, weights);}
//
//  double getPathIntegral(const int& attribute, const bool& reciprocal, double** rayPath, double* radii, const int& numPoints,
//          const GeoTessInterpolatorType& ht, const GeoTessInterpolatorType& rt)
//  { return getPathIntegral(attribute, reciprocal, rayPath, radii, NULL, numPoints, ht, rt); }
//
//  double getPathIntegral(const int& attribute, const bool& reciprocal, double** rayPath, double* radii, const int& numPoints,
//          const GeoTessInterpolatorType& ht, const GeoTessInterpolatorType& rt, map<int, double>& weights)
//  { return getPathIntegral(attribute, reciprocal, rayPath, radii, NULL, numPoints, ht, rt, &weights); }
//
//  double getPathIntegral2D(const int& attribute, const bool& reciprocal,
//          const double* firstPoint, const double* lastPoint, const double& pointSpacing,
//          const double& earthRadius,
//          const GeoTessInterpolatorType& horizontalType, map<int, double>& weights)
//  { return getPathIntegral2D(attribute, reciprocal, firstPoint, lastPoint, pointSpacing, earthRadius, horizontalType, &weights); }
 
 
    bool testLayerRadii();
 
 
 
};
// end class GeoTessModel
 
}// end namespace geotess
 
#endif  // GEOTESSMODEL_OBJECT_H