TauPSiteFunctionals.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 TAUPSITEFNCTNLS_H
#define TAUPSITEFNCTNLS_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <vector>
#include <map>
#include <set>
#include <cmath>
 
using namespace std;
// use standard library objects
 
// **** _LOCAL INCLUDES_ *******************************************************
 
// **** _BEGIN TAUP NAMESPACE_ *************************************************
 
namespace taup {
 
// **** _FORWARD REFERENCES_ ***************************************************
 
class TauPSite;
 
// **** _CLASS CONSTANTS_ ******************************************************
 
// *****************************************************************************
// **** SplitDistance Definition ***********************************************
// *****************************************************************************
 
// *****************************************************************************
//
//
// *****************************************************************************
class SplitDistance
{
  public:
 
    SplitDistance(TauPSite* tps) : sdTPS(tps) {};
 
    SplitDistance(const SplitDistance& sd) : sdTPS(sd.sdTPS) {};
 
    virtual ~SplitDistance() {};
 
    SplitDistance& operator=(const SplitDistance& sd) {return *this;};
 
    double operator()(double p);
 
  private:
 
    TauPSite* sdTPS;
 
}; // SplitDistance End Definition
 
// *****************************************************************************
// **** TPZeroFunctional Definition ********************************************
// *****************************************************************************
 
// *****************************************************************************
//
//
//
// *****************************************************************************
class TPZeroFunctional
{
  public:
 
    // **** _PUBLIC LIFECYCLES_ ************************************************
 
    TPZeroFunctional() : tpzTPS(NULL), tpzRSrc(0.0), tpzRSrcSgn(1.0),
                         tpzRRcvr(0.0), tpzRRcvrSgn(1.0), tpzPLast(-1.0),
                         tpzDLast(-1.0), tpzD(0.0), tpzPT(0.0),
                         tpzRayLegDist(0.0), tpzRayLegTime(0.0),
                         tpzSrcLegDist(0.0), tpzSrcLegTime(0.0),
                         tpzRcvrLegDist(0.0), tpzRcvrLegTime(0.0),
                         tpzIsTurningZero(true), tpzIsRayLegValid(false),
                         tpzIsRcvrLegValid(false), tpzIsSrcLegValid(false),
                         tpzRadius(EARTH_RAD) {};
 
    TPZeroFunctional(TauPSite* tps) :
                     tpzTPS(tps), tpzRSrc(0.0), tpzRSrcSgn(1.0),
                     tpzRRcvr(0.0), tpzRRcvrSgn(1.0), tpzPLast(-1.0),
                     tpzDLast(-1.0), tpzD(0.0), tpzPT(0.0),
                     tpzRayLegDist(0.0), tpzRayLegTime(0.0),
                     tpzSrcLegDist(0.0), tpzSrcLegTime(0.0),
                     tpzRcvrLegDist(0.0), tpzRcvrLegTime(0.0),
                     tpzIsTurningZero(true), tpzIsRayLegValid(false),
                     tpzIsRcvrLegValid(false), tpzIsSrcLegValid(false),
                     tpzRadius(EARTH_RAD) {};
 
    TPZeroFunctional(const TPZeroFunctional& tpzf) :
                     tpzTPS(tpzf.tpzTPS),
                     tpzRSrc(tpzf.tpzRSrc), tpzRSrcSgn(tpzf.tpzRSrcSgn),
                     tpzRRcvr(tpzf.tpzRRcvr), tpzRRcvrSgn(tpzf.tpzRRcvrSgn),
                     tpzPLast(tpzf.tpzPLast), tpzDLast(tpzf.tpzDLast),
                     tpzD(tpzf.tpzD), tpzPT(tpzf.tpzPT),
                     tpzRayLegDist(tpzf.tpzRayLegDist),
                     tpzRayLegTime(tpzf.tpzRayLegTime),
                     tpzSrcLegDist(tpzf.tpzSrcLegDist),
                     tpzSrcLegTime(tpzf.tpzSrcLegTime),
                     tpzRcvrLegDist(tpzf.tpzRcvrLegDist),
                     tpzRcvrLegTime(tpzf.tpzRcvrLegTime),
                     tpzIsTurningZero(tpzf.tpzIsTurningZero),
                     tpzIsRayLegValid(tpzf.tpzIsRayLegValid),
                     tpzIsRcvrLegValid(tpzf.tpzIsRcvrLegValid),
                     tpzIsSrcLegValid(tpzf.tpzIsSrcLegValid),
                     tpzRadius(tpzf.tpzRadius) {};
 
    virtual ~TPZeroFunctional() {};
 
    // **** _PUBLIC OPERATORS_ *************************************************
 
    TPZeroFunctional& operator=(const TPZeroFunctional& tpzf)
    {
      // set all values from tpzf into this TPZeroFunctional
 
      tpzD              = tpzf.tpzD;
      tpzPT             = tpzf.tpzPT;
      tpzRSrc           = tpzf.tpzRSrc;
      tpzRSrcSgn        = tpzf.tpzRSrcSgn;
      tpzRRcvr          = tpzf.tpzRRcvr;
      tpzRRcvrSgn       = tpzf.tpzRRcvrSgn;
      tpzPLast          = tpzf.tpzPLast;
      tpzDLast          = tpzf.tpzDLast;
      tpzRayLegDist     = tpzf.tpzRayLegDist;
      tpzRayLegTime     = tpzf.tpzRayLegTime;
      tpzSrcLegDist     = tpzf.tpzSrcLegDist;
      tpzSrcLegTime     = tpzf.tpzSrcLegTime;
      tpzRcvrLegDist    = tpzf.tpzRcvrLegDist;
      tpzRcvrLegTime    = tpzf.tpzRcvrLegTime;
      tpzRadius         = tpzf.tpzRadius;
      tpzTPS            = tpzf.tpzTPS;
      tpzIsTurningZero  = tpzf.tpzIsTurningZero;
      tpzIsRayLegValid  = tpzf.tpzIsRayLegValid;
      tpzIsRcvrLegValid = tpzf.tpzIsRcvrLegValid;
      tpzIsSrcLegValid  = tpzf.tpzIsSrcLegValid;
      tpzPLast          = -1.0;
 
      // exit
 
      return *this;
    };
 
    double operator()(double p)
    {
      // calculate new zero in condition if p is different than last
      // call
 
      if (p != tpzPLast)
      {
        // save p and new zero in condition
 
        tpzPLast = p;
        distance(p);
        if (tpzIsTurningZero)
          tpzDLast = getTurningZero();
        else
          tpzDLast = getUpGoingZero();
      }
 
      // return zero in condition at p
 
      return tpzDLast;
    };
 
    // **** _PUBLIC METHODS_ ***************************************************
 
    void      setTurningZero()
    {
      tpzIsTurningZero = true;
    };
 
    bool      isTurningZero()
    {
      return tpzIsTurningZero;
    };
 
    double    getTurningZero()
    {
      return (tpzD - (2.0 * tpzRayLegDist - tpzRSrcSgn * tpzSrcLegDist -
                      tpzRRcvrSgn * tpzRcvrLegDist));
    };
 
    bool      isTurningRayValid()
    {
      return (tpzIsRayLegValid && tpzIsRcvrLegValid && tpzIsSrcLegValid);
    };
 
    void      setUpGoingZero()
    {
      tpzIsTurningZero = false;
    };
 
    bool      isUpGoingZero()
    {
      return !tpzIsTurningZero;
    };
 
    double    getUpGoingZero()
    {
      //return (tpzD - fabs(tpzRSrcSgn * tpzSrcLegDist -
      //                    tpzRRcvrSgn * tpzRcvrLegDist));
      return (tpzD - tpzSrcLegDist);
    };
 
    bool      isUpGoingRayValid()
    {
      return (tpzIsRcvrLegValid && tpzIsSrcLegValid);
    };
 
    double    getMinP();
 
    void      setTauPSite(TauPSite* tps)
    {
      tpzTPS = tps;
      tpzPLast = -1.0;
    };
 
    TauPSite& getTauPSite()
    {
      return *tpzTPS;
    };
 
    void      setPlanetRadius(double pr)
    {
      tpzRadius = pr;
      tpzPLast = -1.0;
    };
 
    double    getPlanetRadius() const
    {
      return tpzRadius;
    };
 
    void      setSourceRadius(double r)
    {
      tpzRSrcSgn = setRadius(r);
      tpzRSrc    = r;
      tpzPLast = -1.0;
    };
 
    double    getSourceRadius() const
    {
      return tpzRSrc;
    }
 
    void      setSourceDepth(double d)
    {
      setSourceRadius(tpzRadius - d);
    };
 
    double    getSourceDepth() const
    {
      return tpzRadius - tpzRSrc;
    }
 
    void      setReceiverRadius(double r)
    {
      tpzRRcvrSgn = setRadius(r);
      tpzRRcvr    = r;
      tpzPLast = -1.0;
    };
 
    double    getReceiverRadius() const
    {
      return tpzRRcvr;
    }
 
    void      setReceiverDepth(double d)
    {
      setReceiverRadius(tpzRadius - d);
    };
 
    double    getReceiverDepth() const
    {
      return tpzRadius - tpzRRcvr;
    }
 
    void      setDist(double d)
    {
      tpzD = d;
      tpzPLast = -1.0;
    };
 
    double    getDist() const
    {
      return tpzD;
    };
 
    void      setPTop(double p)
    {
      tpzPT = p;
      tpzPLast = -1.0;
    };
 
    double    getPTop() const
    {
      return tpzPT;
    };
 
    void      distance(double p);
 
    double    time(double p);
 
    double getRayDistance() const {return tpzRayLegDist;};
 
    double getRayTime() const {return tpzRayLegTime;};
 
    double getSourceLegDistance() const {return tpzRSrcSgn * tpzSrcLegDist;};
 
    double getSourceLegTime() const {return tpzRSrcSgn * tpzSrcLegTime;};
 
    double getReceiverLegDistance() const
    {
      return tpzRRcvrSgn * tpzRcvrLegDist;
    };
 
    double getReceiverLegTime() const {return tpzRRcvrSgn * tpzRcvrLegTime;};
 
    int    getSourceLayerId() const {return getRadiusLayerId(tpzRSrc);};
 
    int    getReceiverLayerId() const {return getRadiusLayerId(tpzRRcvr);};
 
    int    getRadiusLayerId(double r) const;
 
  private:
 
    // **** _PRIVATE METHODS_ **************************************************
 
    double    setRadius(double& r)
    {
      double rsgn = 1.0;
 
      // if the input radius exceeds the maximum planet radius then
      // this is an elevated source ... set r to depth and
      // reverse the sign
 
      if (r > tpzRadius)
      {
        r = 2.0 * tpzRadius - r;
        rsgn = -1.0;
      }
      return rsgn;
    };
 
    // **** _PRIVATE DATA_ *****************************************************
 
    TauPSite* tpzTPS;
 
    double tpzRSrc;
 
    double tpzRSrcSgn;
 
    double tpzRRcvr;
 
    double tpzRRcvrSgn;
 
    double tpzPLast;
 
    double tpzDLast;
 
    double tpzD;
 
    double tpzPT;
 
    double tpzRayLegDist;
 
    double tpzRayLegTime;
 
    double tpzSrcLegDist;
 
    double tpzSrcLegTime;
 
     double tpzRcvrLegDist;
 
     double tpzRcvrLegTime;
 
     bool   tpzIsTurningZero;
 
    bool   tpzIsRayLegValid;
 
    bool   tpzIsRcvrLegValid;
 
    bool   tpzIsSrcLegValid;
 
    double tpzRadius;
 
}; // end TPZeroFunctional Definition
 
} // end namespace taup
 
#endif // TAUPSITEFNCTNLS_H