RSTT: rstt/SLBM/include/TauPSite.h Source File

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 // *****************************************************************************
120 class TAUP_EXP TauPSite
121 {
122 public:
123
124 // **** _PUBLIC LIFECYCLES_ ************************************************
125
127 TauPSite();
128
131 TauPSite(const string& staname, const string& phase);
132
134 TauPSite(const TauPSite& tps);
135
137 virtual ~TauPSite();
138
139 // **** _PUBLIC OPERATORS_ *************************************************
140
142 TauPSite& operator=(const TauPSite& tps);
143
144 // **** _PUBLIC METHODS_ ***************************************************
145
147 void setSiteDepth(double depth);
148
151 void setVelocityModels(const vector<TPVelocityLayer*>& vm);
152
158 void appendVelocityModel(TPVelocityLayer* vm);
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
206 void clearVelocityModels();
207
211 void calculateTravelTimes(double srcdist, double srcdepth,
212 bool evalderivs = true);
213
216 TravelTimeResult* getFirstTravelTimeResult();
217
220 double getFirstTravelTime() const;
221
226 double getFirstNonDiffractedTravelTime() const;
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
820 util::Brents<TPZeroFunctional> tpsZeroIn;
821
827 map<double, TravelTimeResult*> tpsTTR;
828
829 }; // TauPSite End Definition
830
831 // *****************************************************************************
832 // **** TravelTimeResult Definition ********************************************
833 // *****************************************************************************
834
835 // *****************************************************************************
836 //
841 //
842 // *****************************************************************************
843 class TAUP_EXP TravelTimeResult
844 {
845 public:
846
848 TravelTimeResult() {};
849
851 string toString(string indent = "") const;
852
854 void toStream(ostream& os, string indent = "") const;
855
857 TPVelocityLayer* ttrVelLayer;
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