UncertaintyPIU.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 UncertaintyPIU_H
#define UncertaintyPIU_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <string>
#include <vector>
 
#include "SLBMGlobals.h"
#include "DataBuffer.h"
#include "IFStreamAscii.h"
#include "IFStreamBinary.h"
 
using namespace std;
 
// **** _BEGIN SLBM NAMESPACE_ **************************************************
 
namespace slbm {
 
// **** _LOCAL INCLUDES_ *******************************************************
 
class SLBM_EXP UncertaintyPIU
{
 
public:
 
    UncertaintyPIU();
 
    UncertaintyPIU(const int& phase, const int& attribute);
 
    UncertaintyPIU(const string& phase, const string& attribute);
 
    // \brief Parameterized constructor that loads model error
    UncertaintyPIU(string modelPath, const string& phase, int phasenum);
 
    UncertaintyPIU(string modelPath, const int& phase, const int& attribute);
 
    UncertaintyPIU(util::DataBuffer& buffer);
 
    UncertaintyPIU(const UncertaintyPIU& u);
 
    static UncertaintyPIU* getUncertaintyPIU(ifstream& input, const int& phase, const int& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(ifstream& input, const string& phase, const string& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(geotess::IFStreamAscii& input, const int& phase, const int& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(geotess::IFStreamAscii& input, const string& phase, const string& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(geotess::IFStreamBinary& input, const int& phase, const int& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(geotess::IFStreamBinary& input, const string& phase, const string& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(util::DataBuffer& input, const int& phase, const int& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(util::DataBuffer& input, const string& phase, const string& attribute);
 
    static UncertaintyPIU* getUncertaintyPIU(const string& directoryName, const int& phase, const int& attribute);
 
    virtual ~UncertaintyPIU();
 
    UncertaintyPIU& operator=(const UncertaintyPIU& u);
 
    virtual bool operator == (const UncertaintyPIU& other) const;
 
    virtual bool operator != (const UncertaintyPIU& other) const { return !(*this == other); } ;
 
    bool operator!=(const UncertaintyPIU& other) { return !(*this == other); }
 
    void readFile(ifstream& fin);
 
    void readFile(geotess::IFStreamAscii& fin);
 
    void writeFile(geotess::IFStreamAscii& output);
 
    void readFile(geotess::IFStreamBinary& fin);
 
    void writeFile(geotess::IFStreamBinary& fout);
 
    int getPhase();
 
    string getPhaseStr();
 
    int getAttribute();
 
    string getAttributeStr();
 
    double getUncertainty(const double& distance, double depth = 0.0);
 
    double getVariance(const double& distance, double depth = 0.0);
 
    // for which the model errors are defined.
    // for which the model errors are defined.
    vector<double>& getDistances() {return errDistances; };
 
    // for which the model errors are defined, in km.
    // for which the model errors are defined, in km.
    vector<double>& getDepths() { return errDepths; }
 
    // corresponding to the defined depths (first index) and angular distances.
    // corresponding to the defined depths (first index) and angular distances.
    vector<vector<double> >& getValues() { return errVal; }
 
    void writeFile(const string& directoryName);
 
    string toStringTable();
 
    string toStringFile();
 
    static string getPhase(const int& phaseIndex)
    {
        switch(phaseIndex)
        {
        case 0:
            return "Pn";
        case 1:
            return "Sn";
        case 2:
            return "Pg";
        case 3:
            return "Lg";
        default:
            return "XX";
        }
    }
 
    static string getAttribute(const int& attributeIndex)
    {
        switch(attributeIndex)
        {
        case 0:
            return "TT";
        case 1:
            return "Sh";
        case 2:
            return "Az";
        default:
            return "XX";
        }
    }
 
    static int getPhase(const string& phase)
    {
        if (phase == "Pn") return Pn;
        if (phase == "Sn") return Sn;
        if (phase == "Pg") return Pg;
        if (phase == "Lg") return Lg;
        return -1;
    }
 
    static int getAttribute(const string& attribute)
    {
        if (attribute == "TT") return TT;
        if (attribute == "Sh") return SH;
        if (attribute == "Az") return AZ;
        return -1;
    }
 
    int getBufferSize();
 
    void serialize(util::DataBuffer& buffer);
 
    void deserialize(util::DataBuffer& buffer);
 
    //  /**
    //   * Retrieve reference count;
    //   */
    //  int getReferenceCount() { return refCount; }
    //
    //  /**
    //   * Add reference count;
    //   */
    //  void addReference() { ++refCount; }
    //
    //  /**
    //   * Remove reference count.
    //   * @return the reference count after decrement.
    //   */
    //  int removeReference();
    //
    //  /**
    //   * Returns true if reference count is zero.
    //   */
    //  bool isNotReferenced() { return (refCount == 0); }
 
private:
 
    //int refCount;
 
    double getUncertainty(double f, int idist, int idepth);
 
    double getVariance(double f, int idist, int idepth);
 
    //
    //
    //
    void getIndex(double x, const vector<double>& v, int& index, double& w);
 
    void readFile(const string& filename);
 
    string fname;
 
    int phaseNum;
 
    int attributeNum;
 
    // for which the model errors are defined.
    // for which the model errors are defined.
    vector<double> errDistances;
 
    // for which the model errors are defined.
    // for which the model errors are defined.
    vector<double> errDepths;
 
    // corresponding to the defined depths (first index) and angular distances.
    // corresponding to the defined depths (first index) and angular distances.
    vector<vector<double> > errVal;
 
};
 
inline int UncertaintyPIU::getPhase()
{
    return phaseNum;
}
 
inline int UncertaintyPIU::getAttribute()
{
    return attributeNum;
}
 
inline string UncertaintyPIU::getPhaseStr()
{
    return getPhase(phaseNum);
}
 
inline string UncertaintyPIU::getAttributeStr()
{
    return getAttribute(attributeNum);
}
 
inline double UncertaintyPIU::getUncertainty(double f, int idist, int idepth)
{
    return (f * (errVal[idepth][idist+1] - errVal[idepth][idist]) +
            errVal[idepth][idist]);
}
 
inline double UncertaintyPIU::getVariance(double f, int idist, int idepth)
{
    return (f * (errVal[idepth][idist+1] * errVal[idepth][idist+1] -
            errVal[idepth][idist] * errVal[idepth][idist]) +
            errVal[idepth][idist] * errVal[idepth][idist]);
}
 
} // end slbm namespace
 
#endif // Uncertainty_H