RSTT  3.1.0
Regional Seismic Travel Time
TauPSite.h
Go to the documentation of this file.
1 //- ****************************************************************************
2 //-
3 //- Copyright 2009 National Technology & Engineering Solutions of Sandia, LLC
4 //- (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
5 //- Government retains certain rights in this software.
6 //-
7 //- BSD Open Source License
8 //- All rights reserved.
9 //-
10 //- Redistribution and use in source and binary forms, with or without
11 //- modification, are permitted provided that the following conditions are met:
12 //-
13 //- 1. Redistributions of source code must retain the above copyright notice,
14 //- this list of conditions and the following disclaimer.
15 //-
16 //- 2. Redistributions in binary form must reproduce the above copyright
17 //- notice, this list of conditions and the following disclaimer in the
18 //- documentation and/or other materials provided with the distribution.
19 //-
20 //- 3. Neither the name of the copyright holder nor the names of its
21 //- contributors may be used to endorse or promote products derived from
22 //- this software without specific prior written permission.
23 //-
24 //- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 //- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 //- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 //- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
28 //- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 //- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 //- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 //- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 //- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 //- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 //- POSSIBILITY OF SUCH DAMAGE.
35 //-
36 //- ****************************************************************************
37 
38 #ifndef TAUPSITE_H
39 #define TAUPSITE_H
40 
41 // **** _SYSTEM INCLUDES_ ******************************************************
42 
43 #include <vector>
44 #include <map>
45 #include <set>
46 
47 using namespace std;
48 // use standard library objects
49 
50 // **** _LOCAL INCLUDES_ *******************************************************
51 
52 #include "TauPGlobals.h"
53 
54 #include "Brents.h"
55 #include "TauPSiteFunctionals.h"
56 
57 // **** _BEGIN TAUP NAMESPACE_ *************************************************
58 
59 namespace taup {
60 
61 // **** _FORWARD REFERENCES_ ***************************************************
62 
63 class TPVelocityLayer;
64 class TravelTimeResult;
65 
66 // **** _CLASS CONSTANTS_ ******************************************************
67 
68 
69 // *****************************************************************************
70 //
80 //
118 //
119 // *****************************************************************************
121 {
122  public:
123 
124  // **** _PUBLIC LIFECYCLES_ ************************************************
125 
128 
131  TauPSite(const string& staname, const string& phase);
132 
134  TauPSite(const TauPSite& tps);
135 
137  virtual ~TauPSite();
138 
139  // **** _PUBLIC OPERATORS_ *************************************************
140 
143 
144  // **** _PUBLIC METHODS_ ***************************************************
145 
147  void setSiteDepth(double depth);
148 
151  void setVelocityModels(const vector<TPVelocityLayer*>& vm);
152 
159 
166  void appendConstVelocityModel(double c, double rt, double rb,
167  const string& layrnam = "");
168 
175  void appendLinearVelocityModel(double a0, double a1,
176  double rt, double rb,
177  const string& layrnam = "",
178  double normradius = 1.0);
179 
186  void appendQuadraticVelocityModel(double a0, double a1,
187  double a2,
188  double rt, double rb,
189  const string& layrnam = "",
190  double normradius = 1.0);
191 
198  void appendCubicVelocityModel(double a0, double a1,
199  double a2, double a3,
200  double rt, double rb,
201  const string& layrnam = "",
202  double normradius = 1.0);
203 
207 
211  void calculateTravelTimes(double srcdist, double srcdepth,
212  bool evalderivs = true);
213 
217 
220  double getFirstTravelTime() const;
221 
227 
228  TravelTimeResult* getTravelTimeResult(const string& phase,
229  bool matchPhase);
230  //- Returns the travel time result with the input matching phase.
231  //- If the matching phase was not found and matchPhase is true a NULL
232  //- pointer is returned. If the matching phase was not found and matchPhase
233  //- is false then the first arrival travel time result is returned.
234 
235  double getTravelTime(const string& phase,
236  bool matchPhase) const;
237  //- Returns the travel time with the input matching phase.
238  //- If the matching phase was not found and matchPhase is true a travel
239  //- time result of -1 is returned. If the matching phase was not found and
240  //- matchPhase is false then the first arrival travel time is returned.
241 
244  const map<double, TravelTimeResult*>& getAllTravelTimes() const;
245 
251  //
256  bool integrateDistance(double p, double& d,
257  bool bottom_pass = false);
258 
263  bool integrateDistance(double p, double r, double& d);
264 
269  bool integrateDistance(double p, double r1, double r2, double& d);
270 
276  //
281  bool integrateTime(double p, double& d,
282  bool bottom_pass = false);
283 
288  bool integrateTime(double p, double r, double& d);
289 
296  bool integrateTime(double p, double r1, double r2, double& t);
297 
300  virtual void writeData(const string& filename) const;
301 
305  //
312  void writeLayerData(int i, ostream& os, int n,
313  double f0 = 0.0, double f1 = 1.0);
314 
316  void dumpLocalSrcRcvrLayers(ostream& os);
317 
319  void dumpLayerInfo(ostream& os);
320 
322  string toString() const;
323 
325  virtual void toStream(ostream& os, string indent) const;
326 
327  // **** _PUBLIC PROPERTIES_ ************************************************
328 
330  static string class_name();
331 
333  virtual string get_class_name() const;
334 
336  virtual int class_size() const;
337 
339  static string commonName();
340 
342  virtual string getCommonName() const;
343 
345  const string& getName() const;
346 
348  const string& getPhase() const;
349 
351  void setModelName(const string& modname);
352 
354  const string& getModelName() const;
355 
357  void setEarthRadius(double r);
358 
360  double getEarthRadius() const;
361 
363  void setBrentsTolerance(double tol);
364 
366  double getBrentsTolerance() const;
367 
369  const vector<TPVelocityLayer*>& getVelocityModels() const;
370 
372  virtual int64 get_memory() const;
373 
375  virtual int64 get_alloc_memory() const;
376 
377  // **** _PUBLIC INQUIRIES_ *************************************************
378 
379  private:
380 
381  // **** _PRIVATE METHODS_ **************************************************
382 
385  virtual void writeData(ostream& os) const;
386 
389  void clearTTRMap();
390 
393  TravelTimeResult* saveResultI(double pB, double pI, double dist,
394  int i, bool isUpper, bool isLower);
395 
399  TravelTimeResult* saveResult(double p, int i,
400  bool isintrfcupper, bool isintrfclower,
401  bool isspltlower, bool isspltupper,
402  bool isturningzero);
403 
408  void findLimits();
409 
411  void debugOutZeros(int n, double p0, double p1);
412 
413  //**************************************************************************
414  //**** Begin: Derivative Evaluation Functions ******************************
415  //**************************************************************************
416 
417  // Derivative calculation occurs in the function evaluateDerivatives(...).
418  // The initial call is made by calculateTravelTimes(...). The arguments
419  // assume that a valid travel time has been evaluated for some layer whose
420  // top and bottom ray parameter is given by pT and pB, respectively. The
421  // valid travel time is passed in as T00. The travel time was evaluated at
422  // dist and depth. The derivatives will be determined numerically
423  // by calculating travel times at steps away from dist and depth using the
424  // step sizes edist and edepth. The derivatives are returned in the array
425  // derivs[] and include derivs[0] = dT/dDist, derivs[1] = dT/dDpth,
426  // derivs[2] = d^2T/dDist/dDpth, and derivs[3] = d^2T/dDist^2. The travel
427  // time is assumed to correspond to a turning ray unless the diffracted
428  // ray parameter (pI) is input as a non-negative value (defaults to -1.0).
429  //
430  // On entry the function evaluateDerivatives(...) assumes that the
431  // TPZeroFunctional object has had its top ray parameter set to pT.
432  // It immediately calls evalDerivsPrimary(...) which calls the function
433  // layeredTravelTime(...) at the four primary stencil locations. If
434  // successful it immediately returns with the derivatives stored in derivs[].
435  //
436  // If one or more of the stencil locations cannot be evaluated for the input
437  // layer then one or two alternate stencils are tried, These include B and A,
438  // B and C, E and F, and E and D. If any are successful the function returns
439  // with the evaluated derivatives. Each pair is selected based on the point
440  // that failed during the primary evaluation. If both alternates also fail
441  // then the function reEvaluateDerivatives(...) is called which reduces the
442  // step sizes (edist and edepth) by 1/2 and recalls evaluateDerivatives(...)
443  // recursively. Each recursive call increments a counter which, if it exceeds
444  // 5, will trip an error condition which causes a return without evaluting
445  // the derivatives. The derivative function calling sequence is shown in the
446  // diagram below.
447  //
448  // initial call
449  // |
450  // |--> evaluateDerivatives <--|
451  // | {
452  // | evalDerivsPrimary ------->|
453  // | evalDerivsAlternateA ---->|
454  // | evalDerivsAlternateB ---->|
455  // | evalDerivsAlternateC ---->|----> layeredTravelTime
456  // | evalDerivsAlternateD ---->|
457  // | evalDerivsAlternateE ---->|
458  // | evalDerivsAlternateF ---->|
459  // |
460  // |<-- reEvaluateDerivatives
461  // }
462  //
463 
475  //
494  void evaluateDerivatives(double pT, double pB, double T00,
495  double dist, double depth,
496  double edist, double edepth,
497  double* derivs, double pI = -1.0,
498  int derivcnt = 0);
499 
504  void reEvaluateDerivatives(double pT, double pB, double T00,
505  double dist, double depth,
506  double edist, double edepth,
507  double* derivs, double pI,
508  int derivcnt);
509 
513  //
537  int evalDerivsPrimary(double pT, double pB, double T00,
538  double dist, double depth,
539  double edist, double edepth,
540  double* derivs, double pI);
541 
546  //
570  int evalDerivsAlternateA(double pT, double pB, double T00,
571  double dist, double depth,
572  double edist, double edepth,
573  double* derivs, double pI);
574 
579  //
603  int evalDerivsAlternateB(double pT, double pB, double T00,
604  double dist, double depth,
605  double edist, double edepth,
606  double* derivs, double pI);
607 
612  //
636  int evalDerivsAlternateC(double pT, double pB, double T00,
637  double dist, double depth,
638  double edist, double edepth,
639  double* derivs, double pI);
640 
645  //
669  int evalDerivsAlternateD(double pT, double pB, double T00,
670  double dist, double depth,
671  double edist, double edepth,
672  double* derivs, double pI);
673 
678  //
702  int evalDerivsAlternateE(double pT, double pB, double T00,
703  double dist, double depth,
704  double edist, double edepth,
705  double* derivs, double pI);
706 
711  //
735  int evalDerivsAlternateF(double pT, double pB, double T00,
736  double dist, double depth,
737  double edist, double edepth,
738  double* derivs, double pI);
739 
749  double layeredTravelTime(double pT, double pB, double dist,
750  double depth, double& T, double pI);
751 
752  //**************************************************************************
753  //**** End: Derivative Evaluation Functions ********************************
754  //**************************************************************************
755 
756  // **** _PRIVATE DATA_ *****************************************************
757 
760  static int tpsClassCount;
761 
763  static const double tpsDerivStepSize;
764 
766  static const double tpsBrentsZeroInTol;
767 
770  static vector<TravelTimeResult*> tpsReuseTTR;
771 
776  vector<TPVelocityLayer*> tpsVLayer;
777 
781  bool tpsIsVelModlOwned;
782 
784  string tpsRcvrName;
785 
787  string tpsRcvrPhase;
788 
790  string tpsModelName;
791 
793  double tpsRcvrRad;
794 
796  double tpsRcvrDepth;
797 
799  double tpsSrcRad;
800 
802  double tpsSrcDepth;
803 
805  double tpsDist;
806 
808  double tpsLastDist;
809 
811  double tpsLastDepth;
812 
815  TPZeroFunctional tpsZeroF;
816 
821 
827  map<double, TravelTimeResult*> tpsTTR;
828 
829 }; // TauPSite End Definition
830 
831 // *****************************************************************************
832 // **** TravelTimeResult Definition ********************************************
833 // *****************************************************************************
834 
835 // *****************************************************************************
836 //
841 //
842 // *****************************************************************************
844 {
845  public:
846 
849 
851  string toString(string indent = "") const;
852 
854  void toStream(ostream& os, string indent = "") const;
855 
858 
861  string ttrPhaseName;
862 
866  string ttrPhaseEval;
867 
870  string ttrRayType;
871 
873  int ttrLayerIndex; // Xn
874 
878  bool ttrIsInterfaceUpper; // Xni+
879 
883  bool ttrIsInterfaceLower; // Xni-
884 
887  bool ttrIsSplitUpper; // Xnb+
888 
891  bool ttrIsSplitLower; // Xnb- ... else Xnb
892 
894  double ttrP;
895 
897  double ttrR;
898 
900  double ttrV;
901 
903  double ttrT;
904 
906  double ttrDRay;
907 
909  double ttrTRay;
910 
912  double ttrDSrc;
913 
915  double ttrTSrc;
916 
918  double ttrDRcvr;
919 
921  double ttrTRcvr;
922 
924  double ttrDIntrfc;
925 
927  double ttrTIntrfc;
928 
934  double ttrDerivs[4];
935 
936  private:
937 };
938 
939 // *****************************************************************************
940 // **** _INLINE FUNCTION IMPLEMENTATIONS_ **************************************
941 // *****************************************************************************
942 
943 // **** _FUNCTION DESCRIPTION_ *************************************************
944 //
946 //
947 // *****************************************************************************
948 inline string TauPSite::class_name()
949 {
950  return "TauPSite";
951 }
952 
953 // **** _FUNCTION DESCRIPTION_ *************************************************
954 //
956 //
957 // *****************************************************************************
958 inline string TauPSite::get_class_name() const
959 {
960  return class_name();
961 }
962 
963 // **** _FUNCTION DESCRIPTION_ *************************************************
964 //
966 //
967 // *****************************************************************************
968 inline int TauPSite::class_size() const
969 {
970  return (int) sizeof(TauPSite);
971 }
972 
973 // **** _FUNCTION DESCRIPTION_ *************************************************
974 //
976 //
977 // *****************************************************************************
978 inline string TauPSite::commonName()
979 {
980  return ("1-D Radial TauP Travel Time Site Model");
981 }
982 
983 // **** _FUNCTION DESCRIPTION_ *************************************************
984 //
986 //
987 // *****************************************************************************
988 inline string TauPSite::getCommonName() const
989 {
990  return commonName();
991 }
992 
993 // **** _FUNCTION DESCRIPTION_ *************************************************
994 //
996 //
997 // *****************************************************************************
998 inline int64 TauPSite::get_memory() const
999 {
1000  return (sizeof(TauPSite) + TauPSite::get_alloc_memory());
1001 }
1002 
1003 // **** _FUNCTION DESCRIPTION_ *************************************************
1004 //
1006 //
1007 // *****************************************************************************
1008 inline const string& TauPSite::getName() const
1009 {
1010  return tpsRcvrName;
1011 }
1012 
1013 // **** _FUNCTION DESCRIPTION_ *************************************************
1014 //
1016 //
1017 // *****************************************************************************
1018 inline const string& TauPSite::getPhase() const
1019 {
1020  return tpsRcvrPhase;
1021 }
1022 
1023 // **** _FUNCTION DESCRIPTION_ *************************************************
1024 //
1026 //
1027 // *****************************************************************************
1028 inline void TauPSite::setModelName(const string& modname)
1029 {
1030  tpsModelName = modname;
1031 }
1032 
1033 // **** _FUNCTION DESCRIPTION_ *************************************************
1034 //
1036 //
1037 // *****************************************************************************
1038 inline const string& TauPSite::getModelName() const
1039 {
1040  return tpsModelName;
1041 }
1042 
1043 // **** _FUNCTION DESCRIPTION_ *************************************************
1044 //
1046 //
1047 // *****************************************************************************
1048 inline const vector<TPVelocityLayer*>& TauPSite::getVelocityModels() const
1049 {
1050  return tpsVLayer;
1051 }
1052 
1053 // **** _FUNCTION DESCRIPTION_ *************************************************
1054 //
1056 //
1057 // *****************************************************************************
1058 inline void TauPSite::setEarthRadius(double r)
1059 {
1060  tpsZeroF.setPlanetRadius(r);
1061 }
1062 
1063 // **** _FUNCTION DESCRIPTION_ *************************************************
1064 //
1066 //
1067 // *****************************************************************************
1068 inline double TauPSite::getEarthRadius() const
1069 {
1070  return tpsZeroF.getPlanetRadius();
1071 }
1072 
1073 // **** _FUNCTION DESCRIPTION_ *************************************************
1074 //
1076 //
1077 // *****************************************************************************
1078 inline void TauPSite::setBrentsTolerance(double tol)
1079 {
1080  tpsZeroIn.setTolerance(tol);
1081 }
1082 
1083 // **** _FUNCTION DESCRIPTION_ *************************************************
1084 //
1086 //
1087 // *****************************************************************************
1088 inline double TauPSite::getBrentsTolerance() const
1089 {
1090  return tpsZeroIn.getTolerance();
1091 }
1092 
1093 // **** _FUNCTION DESCRIPTION_ *************************************************
1094 //
1097 // *****************************************************************************
1098 inline const map<double, TravelTimeResult*>& TauPSite::getAllTravelTimes() const
1099 {
1100  return tpsTTR;
1101 }
1102 
1103 } // end namespace taup
1104 
1105 #endif // TAUPSITE_H
taup::TauPSite::getFirstTravelTimeResult
TravelTimeResult * getFirstTravelTimeResult()
Returns the first travel time result. If no travel time exists a NULL pointer is returned.
taup::TravelTimeResult::toString
string toString(string indent="") const
Dump TTR to string.
taup::TauPSite::appendCubicVelocityModel
void appendCubicVelocityModel(double a0, double a1, double a2, double a3, double rt, double rb, const string &layrnam="", double normradius=1.0)
Appends a new OWNED cubic velocity model to the profile stack. If this is the first entry a new model...
taup::TravelTimeResult::ttrVelLayer
TPVelocityLayer * ttrVelLayer
The velocity layer within which the ray turned.
Definition: TauPSite.h:857
taup::TravelTimeResult::ttrIsInterfaceUpper
bool ttrIsInterfaceUpper
Definition: TauPSite.h:878
taup::TravelTimeResult::ttrTIntrfc
double ttrTIntrfc
The time along the layer boundary if ttrIsInterface is true.
Definition: TauPSite.h:927
taup::TauPSite::toString
string toString() const
Print object data to string.
taup::TravelTimeResult::ttrTSrc
double ttrTSrc
The surface-to-source ray time.
Definition: TauPSite.h:915
taup::TauPSite::clearVelocityModels
void clearVelocityModels()
Clears all velocity models from the current profile. If the models are OWNED they are deleted.
taup::TauPSite::integrateTime
bool integrateTime(double p, double &d, bool bottom_pass=false)
Returns the total integrated travel time of a ray with ray parameter p in the input parameter t....
taup
Definition: TauPException.h:48
taup::TravelTimeResult::ttrV
double ttrV
The velocity at the turning point.
Definition: TauPSite.h:900
taup::TPZeroFunctional
The primary layer search functional used by Brents zeroIn(...) function to find layers that contain a...
Definition: TauPSiteFunctionals.h:151
TauPGlobals.h
taup::TauPSite::TauPSite
TauPSite()
Default Constructor.
taup::TravelTimeResult
A public container (struct) that holds the result of a specific ray that satisfied the source distanc...
Definition: TauPSite.h:844
taup::TauPSite::getTravelTime
double getTravelTime(const string &phase, bool matchPhase) const
taup::TauPSite::writeLayerData
void writeLayerData(int i, ostream &os, int n, double f0=0.0, double f1=1.0)
This function writes out the surface to surface distance for waves turning in layer i of the input wa...
taup::TauPSite::appendLinearVelocityModel
void appendLinearVelocityModel(double a0, double a1, double rt, double rb, const string &layrnam="", double normradius=1.0)
Appends a new OWNED linear velocity model to the profile stack. If this is the first entry a new mode...
taup::TravelTimeResult::ttrDRcvr
double ttrDRcvr
The surface-to-receiver ray distance.
Definition: TauPSite.h:918
taup::TauPSite
Definition: TauPSite.h:121
taup::TravelTimeResult::ttrR
double ttrR
The ray turning radius.
Definition: TauPSite.h:897
taup::TauPSite::integrateDistance
bool integrateDistance(double p, double r1, double r2, double &d)
Returns the total integrated distance of a ray with ray parameter p in the input parameter d....
taup::TauPSite::integrateDistance
bool integrateDistance(double p, double &d, bool bottom_pass=false)
Returns the total integrated distance of a ray with ray parameter p in the input parameter d....
taup::TravelTimeResult::ttrRayType
string ttrRayType
A string that contains "Turning", "UpGoing", or "DownGoing" indicating the type of ray stored by this...
Definition: TauPSite.h:870
taup::TauPSite::operator=
TauPSite & operator=(const TauPSite &tps)
Assignment operator.
taup::TravelTimeResult::ttrPhaseName
string ttrPhaseName
The velocity layers input provided phase name if given. Else the string is empty.
Definition: TauPSite.h:861
taup::TauPSite::getTravelTimeResult
TravelTimeResult * getTravelTimeResult(const string &phase, bool matchPhase)
taup::TauPSite::dumpLocalSrcRcvrLayers
void dumpLocalSrcRcvrLayers(ostream &os)
Debug function to output source receiver local conditions.
taup::TauPSite::writeData
virtual void writeData(const string &filename) const
Writes the TauPSite as a standard ASCII file in CLR format (see TauPModel function readData for a des...
taup::TauPSite::integrateDistance
bool integrateDistance(double p, double r, double &d)
Returns the total integrated distance of a ray with ray parameter p in the input parameter d....
taup::TauPSite::setSiteDepth
void setSiteDepth(double depth)
Sets 'this' sites depth.
util::Brents
Class supports Brents zeroF and minF functions that finds the root of or minimum (maximum) of a provi...
Definition: Brents.h:77
taup::TauPSite::appendConstVelocityModel
void appendConstVelocityModel(double c, double rt, double rb, const string &layrnam="")
Appends a new OWNED constant velocity model to the profile stack. If this is the first entry a new mo...
taup::TauPSite::appendVelocityModel
void appendVelocityModel(TPVelocityLayer *vm)
Appends another velocity model to the profile for 'this' TauPSite. If this is the first then model po...
Brents.h
taup::TravelTimeResult::toStream
void toStream(ostream &os, string indent="") const
Dump TTR to stream.
taup::TauPSite::setVelocityModels
void setVelocityModels(const vector< TPVelocityLayer * > &vm)
Sets the velocity models for 'this' TauPSite ... model ownership is set to NOT OWNED (tpsIsVelModlOwn...
taup::TauPSite::dumpLayerInfo
void dumpLayerInfo(ostream &os)
Debug function to output layer information.
taup::TravelTimeResult::ttrIsInterfaceLower
bool ttrIsInterfaceLower
Definition: TauPSite.h:883
taup::TauPSite::toStream
virtual void toStream(ostream &os, string indent) const
Print object data to input stream os.
taup::TauPSite::calculateTravelTimes
void calculateTravelTimes(double srcdist, double srcdepth, bool evalderivs=true)
Calculates travel times for all valid phases at the input distance and depth. This is the primary wor...
taup::TauPSite::TauPSite
TauPSite(const string &staname, const string &phase)
Standard Constructor. Sets the station name and phase represented by this TauPSite.
taup::TravelTimeResult::ttrTRcvr
double ttrTRcvr
The surface-to-receiver ray time.
Definition: TauPSite.h:921
taup::TauPSite::appendQuadraticVelocityModel
void appendQuadraticVelocityModel(double a0, double a1, double a2, double rt, double rb, const string &layrnam="", double normradius=1.0)
Appends a new OWNED quadratic velocity model to the profile stack. If this is the first entry a new m...
taup::TauPSite::TauPSite
TauPSite(const TauPSite &tps)
Copy Constructor.
taup::TravelTimeResult::ttrTRay
double ttrTRay
The surface-to-surface ray time.
Definition: TauPSite.h:909
TAUP_EXP
#define TAUP_EXP
Definition: TauPGlobals.h:69
taup::TravelTimeResult::TravelTimeResult
TravelTimeResult()
Default constructor.
Definition: TauPSite.h:848
TauPSiteFunctionals.h
taup::TauPSite::getFirstNonDiffractedTravelTime
double getFirstNonDiffractedTravelTime() const
Returns the first travel time (smallest) for the last call to calculateTravelTimes(dist,...
taup::TravelTimeResult::ttrDSrc
double ttrDSrc
The surface-to-source ray distance.
Definition: TauPSite.h:912
taup::TauPSite::integrateTime
bool integrateTime(double p, double r, double &d)
Returns the total integrated travel time of a ray with ray parameter p in the input parameter t....
taup::TravelTimeResult::ttrT
double ttrT
The total travel time of the ray from source to receiver.
Definition: TauPSite.h:903
taup::TravelTimeResult::ttrP
double ttrP
The ray parameter (slowness) of the ray.
Definition: TauPSite.h:894
taup::TravelTimeResult::ttrIsSplitLower
bool ttrIsSplitLower
A boolean, which if true, defines the ray as turning in the lower half of a retrograde layer.
Definition: TauPSite.h:891
taup::TauPSite::~TauPSite
virtual ~TauPSite()
Destructor.
taup::TauPSite::integrateTime
bool integrateTime(double p, double r1, double r2, double &t)
Returns the total integrated travel time of a ray with ray parameter p in the input parameter d....
taup::TauPSite::get_alloc_memory
virtual int64 get_alloc_memory() const
Returns the total heap allocated memory resource for this TauPSite.
taup::TravelTimeResult::ttrPhaseEval
string ttrPhaseEval
The velocity layers evaluated default name. This string is never empty. This will be Xnb,...
Definition: TauPSite.h:866
taup::TPVelocityLayer
Abstract base class velocity layer model inherited by all concrete velocity layer classes....
Definition: TPVelocityModels.h:265
taup::TravelTimeResult::ttrDRay
double ttrDRay
The surface-to-surface ray distance.
Definition: TauPSite.h:906
taup::TauPSite::getFirstTravelTime
double getFirstTravelTime() const
Returns the first travel time (smallest) for the last call to calculateTravelTimes(dist,...
taup::TravelTimeResult::ttrLayerIndex
int ttrLayerIndex
The index of the velocity layer within which the ray turned.
Definition: TauPSite.h:873
taup::TravelTimeResult::ttrDIntrfc
double ttrDIntrfc
The distance along the layer boundary if ttrIsInterface is true.
Definition: TauPSite.h:924
taup::TravelTimeResult::ttrIsSplitUpper
bool ttrIsSplitUpper
A boolean, which if true, defines the ray as turning in the upper half of a retrograde layer.
Definition: TauPSite.h:887