UncertaintyPDU.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 UncertaintyPDU_H
#define UncertaintyPDU_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <string>
#include <vector>
#include <list>
#include <map>
 
#include "SLBMGlobals.h"
#include "IFStreamAscii.h"
#include "IFStreamBinary.h"
#include "UncertaintyPIU.h"
#include "CpuTimer.h"
 
using namespace std;
 
// **** _BEGIN SLBM NAMESPACE_ **************************************************
 
namespace slbm {
 
    // **** _LOCAL INCLUDES_ *******************************************************
 
    class SLBM_EXP UncertaintyPDU
    {
 
    public:
 
        UncertaintyPDU();
 
        UncertaintyPDU(int phase);
 
        UncertaintyPDU(const string& phase);
 
        UncertaintyPDU(string modelPath, int phase);
 
        // \brief Parameterized constructor that loads path dependent model error
        UncertaintyPDU(string modelPath, const string& phase);
 
        UncertaintyPDU(const UncertaintyPDU& u);
 
        virtual ~UncertaintyPDU();
 
        UncertaintyPDU& operator=(const UncertaintyPDU& u);
 
        virtual bool operator == (const UncertaintyPDU& other) const;
        virtual bool operator != (const UncertaintyPDU& other) const { return !(*this == other); } ;
 
        bool operator!=(const UncertaintyPDU& other) { return !(*this == other); }
 
        static UncertaintyPDU* getUncertainty(ifstream& input, int phase);
 
        static UncertaintyPDU* getUncertainty(ifstream& input, const string& phase);
 
        static UncertaintyPDU* getUncertainty(geotess::IFStreamAscii& input);
 
        static UncertaintyPDU* getUncertainty(geotess::IFStreamBinary& input);
 
        static UncertaintyPDU* getUncertainty(const string& modelPath, int phase);
 
        void readFile(ifstream& fin);
 
        void readFile(geotess::IFStreamAscii& fin);
 
        void readFile(geotess::IFStreamBinary& fin);
 
        void writeFile(geotess::IFStreamAscii& output);
 
        void writeFile(geotess::IFStreamBinary& fout);
 
        void writeFile(const string& directoryName);
        
        int getPhase() const {
            return phaseNum;
        }
 
        const string getPhaseStr() const {
            return getPhase(phaseNum);
        }
 
        const string& getLoadedFileName() const {
            return fname;
        }
 
        const string& getGridId() const {
            return gridId;
        }
 
        double getUncertainty(double distance,
            const vector<int>& crustNodeIds, const vector<double>& crustWeights,
            const vector<int>& headWaveNodeIds, const vector<double>& headWaveWeights,
            const vector<vector<int> >& headWaveNodeNeighbors, const bool& calcRandomError = false,
            bool printDebugInfo = false);
 
        bool isRandomErrorDefined() const {
            return (pathUncRandomError.size() > 0);
        }
 
        string toStringTable();
 
        string toStringFile();
 
        static string getPhase(const int& phaseIndex)
        {
            return UncertaintyPIU::getPhase(phaseIndex);
        }
 
        static int getPhase(const string& phase)
        {
            return UncertaintyPIU::getPhase(phase);
        }
 
        vector<double>& getPathUncCrustError() {
            return pathUncCrustError;
        }
 
        const vector<double>& getPathUncCrustError() const {
            return pathUncCrustError;
        }
 
        vector<vector<double> >& getPathUncRandomError() {
            return pathUncRandomError;
        }
 
        const vector<vector<double> >& getPathUncRandomError() const {
            return pathUncRandomError;
        }
 
        vector<double>& getPathUncDistanceBins() {
            return pathUncDistanceBins;
        }
 
        const vector<double>& getPathUncDistanceBins() const {
            return pathUncDistanceBins;
        }
 
        vector<vector<double> >& getPathUncModelError() {
            return pathUncModelError;
        }
 
        const vector<vector<double> >& getPathUncModelError() const {
            return pathUncModelError;
        }
 
        vector<vector<double> >& getPathUncBias() {
            return pathUncBias;
        }
 
        const vector<vector<double> >& getPathUncBias() const {
            return pathUncBias;
        }
 
        string toString();
 
        map<string, string> properties;
 
        vector<string>  keys;
        
 
    private:
 
        void readFile(const string& filename);
 
        string fname;
 
        int phaseNum;
 
        string gridId;
 
        vector<double> pathUncCrustError;
 
        vector<double> pathUncDistanceBins;
 
        vector<vector<double> > pathUncRandomError;
 
        vector<vector<double> > pathUncModelError;
 
        vector<vector<double> > pathUncBias;
 
    };
 
} // end slbm namespace
 
#endif // UncertaintyPDU_H