SCRUG-NA/2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[seiscomp, scanloc] Install, add .gitignore

Browse Source
This commit is contained in:
Dirk Rössler
2025-10-09 15:07:02 +02:00
commit 20f5301bb1
2848 changed files with 1315858 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
include/seiscomp/datamodel/strongmotion/api.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef SC_STRONGMOTION_API_H
#define SC_STRONGMOTION_API_H
#if defined(WIN32) && (defined(SC_STRONGMOTION_SHARED) || defined(SC_ALL_SHARED))
# if defined(SC_STRONGMOTION_EXPORTS)
# define SC_STRONGMOTION_API __declspec(dllexport)
# define SC_STRONGMOTION_TEMPLATE_EXPORT
# else
# define SC_STRONGMOTION_API __declspec(dllimport)
# define SC_STRONGMOTION_TEMPLATE_EXPORT extern
# endif
#else
# define SC_STRONGMOTION_API
# define SC_STRONGMOTION_TEMPLATE_EXPORT
#endif
#endif

120
include/seiscomp/datamodel/strongmotion/contact.h Normal file
View File

@ -0,0 +1,120 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_CONTACT_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_CONTACT_H
#include <string>
#include <seiscomp/core/baseobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(Contact);
class SC_STRONGMOTION_API Contact : public Core::BaseObject {
DECLARE_SC_CLASS(Contact);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
Contact();
//! Copy constructor
Contact(const Contact& other);
//! Destructor
~Contact();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
Contact& operator=(const Contact& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const Contact& other) const;
bool operator!=(const Contact& other) const;
//! Wrapper that calls operator==
bool equal(const Contact& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setName(const std::string& name);
const std::string& name() const;
void setForename(const std::string& forename);
const std::string& forename() const;
void setAgency(const std::string& agency);
const std::string& agency() const;
void setDepartment(const std::string& department);
const std::string& department() const;
void setAddress(const std::string& address);
const std::string& address() const;
void setPhone(const std::string& phone);
const std::string& phone() const;
void setEmail(const std::string& email);
const std::string& email() const;
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
std::string _name;
std::string _forename;
std::string _agency;
std::string _department;
std::string _address;
std::string _phone;
std::string _email;
};
}
}
}
#endif

91
include/seiscomp/datamodel/strongmotion/databasereader.h Normal file
View File

@ -0,0 +1,91 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_DATABASEREADER_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_DATABASEREADER_H
#include <seiscomp/datamodel/object.h>
#include <seiscomp/datamodel/databasequery.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
class StrongMotionParameters;
class SimpleFilter;
class FilterParameter;
class Record;
class SimpleFilterChainMember;
class PeakMotion;
class StrongOriginDescription;
class EventRecordReference;
class Rupture;
DEFINE_SMARTPOINTER(StrongMotionReader);
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
/** \brief Database reader class for the scheme classes
* This class uses a database interface to read objects from a database.
* Different database backends can be implemented by creating a driver
* in seiscomp/services/database.
*/
class SC_STRONGMOTION_API StrongMotionReader : public DatabaseQuery {
// ----------------------------------------------------------------------
// Xstruction
// ----------------------------------------------------------------------
public:
//! Constructor
StrongMotionReader(Seiscomp::IO::DatabaseInterface* dbDriver);
//! Destructor
~StrongMotionReader();
// ----------------------------------------------------------------------
// Read methods
// ----------------------------------------------------------------------
public:
StrongMotionParameters* loadStrongMotionParameters();
int load(StrongMotionParameters*);
int loadSimpleFilters(StrongMotionParameters*);
int loadRecords(StrongMotionParameters*);
int loadStrongOriginDescriptions(StrongMotionParameters*);
int load(SimpleFilter*);
int loadFilterParameters(SimpleFilter*);
int load(Record*);
int loadSimpleFilterChainMembers(Record*);
int loadPeakMotions(Record*);
int load(StrongOriginDescription*);
int loadEventRecordReferences(StrongOriginDescription*);
int loadRuptures(StrongOriginDescription*);
};
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
}
}
}
#endif

161
include/seiscomp/datamodel/strongmotion/eventrecordreference.h Normal file
View File

@ -0,0 +1,161 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_EVENTRECORDREFERENCE_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_EVENTRECORDREFERENCE_H
#include <string>
#include <seiscomp/datamodel/realquantity.h>
#include <seiscomp/datamodel/object.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(EventRecordReference);
class StrongOriginDescription;
class SC_STRONGMOTION_API EventRecordReference : public Object {
DECLARE_SC_CLASS(EventRecordReference);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
EventRecordReference();
//! Copy constructor
EventRecordReference(const EventRecordReference& other);
//! Custom constructor
EventRecordReference(const std::string& recordID);
EventRecordReference(const std::string& recordID,
const OPT(RealQuantity)& campbellDistance,
const OPT(RealQuantity)& ruptureToStationAzimuth,
const OPT(RealQuantity)& ruptureAreaDistance,
const OPT(RealQuantity)& JoynerBooreDistance,
const OPT(RealQuantity)& closestFaultDistance,
const OPT(double)& preEventLength,
const OPT(double)& postEventLength);
//! Destructor
~EventRecordReference();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
EventRecordReference& operator=(const EventRecordReference& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const EventRecordReference& other) const;
bool operator!=(const EventRecordReference& other) const;
//! Wrapper that calls operator==
bool equal(const EventRecordReference& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setRecordID(const std::string& recordID);
const std::string& recordID() const;
void setCampbellDistance(const OPT(RealQuantity)& campbellDistance);
RealQuantity& campbellDistance();
const RealQuantity& campbellDistance() const;
void setRuptureToStationAzimuth(const OPT(RealQuantity)& ruptureToStationAzimuth);
RealQuantity& ruptureToStationAzimuth();
const RealQuantity& ruptureToStationAzimuth() const;
void setRuptureAreaDistance(const OPT(RealQuantity)& ruptureAreaDistance);
RealQuantity& ruptureAreaDistance();
const RealQuantity& ruptureAreaDistance() const;
void setJoynerBooreDistance(const OPT(RealQuantity)& JoynerBooreDistance);
RealQuantity& JoynerBooreDistance();
const RealQuantity& JoynerBooreDistance() const;
void setClosestFaultDistance(const OPT(RealQuantity)& closestFaultDistance);
RealQuantity& closestFaultDistance();
const RealQuantity& closestFaultDistance() const;
void setPreEventLength(const OPT(double)& preEventLength);
double preEventLength() const;
void setPostEventLength(const OPT(double)& postEventLength);
double postEventLength() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
StrongOriginDescription* strongOriginDescription() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
std::string _recordID;
OPT(RealQuantity) _campbellDistance;
OPT(RealQuantity) _ruptureToStationAzimuth;
OPT(RealQuantity) _ruptureAreaDistance;
OPT(RealQuantity) _joynerBooreDistance;
OPT(RealQuantity) _closestFaultDistance;
OPT(double) _preEventLength;
OPT(double) _postEventLength;
};
}
}
}
#endif

118
include/seiscomp/datamodel/strongmotion/fileresource.h Normal file
View File

@ -0,0 +1,118 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_FILERESOURCE_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_FILERESOURCE_H
#include <seiscomp/datamodel/creationinfo.h>
#include <string>
#include <seiscomp/core/baseobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(FileResource);
class SC_STRONGMOTION_API FileResource : public Core::BaseObject {
DECLARE_SC_CLASS(FileResource);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
FileResource();
//! Copy constructor
FileResource(const FileResource& other);
//! Destructor
~FileResource();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
FileResource& operator=(const FileResource& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const FileResource& other) const;
bool operator!=(const FileResource& other) const;
//! Wrapper that calls operator==
bool equal(const FileResource& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setCreationInfo(const OPT(CreationInfo)& creationInfo);
CreationInfo& creationInfo();
const CreationInfo& creationInfo() const;
void setClass(const std::string& Class);
const std::string& Class() const;
void setType(const std::string& type);
const std::string& type() const;
void setFilename(const std::string& filename);
const std::string& filename() const;
void setUrl(const std::string& url);
const std::string& url() const;
void setDescription(const std::string& description);
const std::string& description() const;
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
OPT(CreationInfo) _creationInfo;
std::string _class;
std::string _type;
std::string _filename;
std::string _url;
std::string _description;
};
}
}
}
#endif

122
include/seiscomp/datamodel/strongmotion/filterparameter.h Normal file
View File

@ -0,0 +1,122 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_FILTERPARAMETER_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_FILTERPARAMETER_H
#include <string>
#include <seiscomp/datamodel/realquantity.h>
#include <seiscomp/datamodel/object.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(FilterParameter);
class SimpleFilter;
class SC_STRONGMOTION_API FilterParameter : public Object {
DECLARE_SC_CLASS(FilterParameter);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
FilterParameter();
//! Copy constructor
FilterParameter(const FilterParameter& other);
//! Destructor
~FilterParameter();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
FilterParameter& operator=(const FilterParameter& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const FilterParameter& other) const;
bool operator!=(const FilterParameter& other) const;
//! Wrapper that calls operator==
bool equal(const FilterParameter& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setValue(const RealQuantity& value);
RealQuantity& value();
const RealQuantity& value() const;
void setName(const std::string& name);
const std::string& name() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
SimpleFilter* simpleFilter() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
RealQuantity _value;
std::string _name;
};
}
}
}
#endif

163
include/seiscomp/datamodel/strongmotion/literaturesource.h Normal file
View File

@ -0,0 +1,163 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_LITERATURESOURCE_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_LITERATURESOURCE_H
#include <string>
#include <seiscomp/core/baseobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(LiteratureSource);
class SC_STRONGMOTION_API LiteratureSource : public Core::BaseObject {
DECLARE_SC_CLASS(LiteratureSource);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
LiteratureSource();
//! Copy constructor
LiteratureSource(const LiteratureSource& other);
//! Custom constructor
LiteratureSource(const std::string& title);
LiteratureSource(const std::string& title,
const std::string& firstAuthorName,
const std::string& firstAuthorForename,
const std::string& secondaryAuthors,
const std::string& doi,
const OPT(int)& year,
const std::string& in_title,
const std::string& editor,
const std::string& place,
const std::string& language,
const OPT(int)& tome,
const OPT(int)& page_from,
const OPT(int)& page_to);
//! Destructor
~LiteratureSource();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
operator std::string&();
operator const std::string&() const;
//! Copies the metadata of other to this
LiteratureSource& operator=(const LiteratureSource& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const LiteratureSource& other) const;
bool operator!=(const LiteratureSource& other) const;
//! Wrapper that calls operator==
bool equal(const LiteratureSource& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setTitle(const std::string& title);
const std::string& title() const;
void setFirstAuthorName(const std::string& firstAuthorName);
const std::string& firstAuthorName() const;
void setFirstAuthorForename(const std::string& firstAuthorForename);
const std::string& firstAuthorForename() const;
void setSecondaryAuthors(const std::string& secondaryAuthors);
const std::string& secondaryAuthors() const;
void setDoi(const std::string& doi);
const std::string& doi() const;
void setYear(const OPT(int)& year);
int year() const;
void setInTitle(const std::string& inTitle);
const std::string& inTitle() const;
void setEditor(const std::string& editor);
const std::string& editor() const;
void setPlace(const std::string& place);
const std::string& place() const;
void setLanguage(const std::string& language);
const std::string& language() const;
void setTome(const OPT(int)& tome);
int tome() const;
void setPageFrom(const OPT(int)& pageFrom);
int pageFrom() const;
void setPageTo(const OPT(int)& pageTo);
int pageTo() const;
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
std::string _title;
std::string _firstAuthorName;
std::string _firstAuthorForename;
std::string _secondaryAuthors;
std::string _doi;
OPT(int) _year;
std::string _inTitle;
std::string _editor;
std::string _place;
std::string _language;
OPT(int) _tome;
OPT(int) _pageFrom;
OPT(int) _pageTo;
};
}
}
}
#endif

140
include/seiscomp/datamodel/strongmotion/peakmotion.h Normal file
View File

@ -0,0 +1,140 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_PEAKMOTION_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_PEAKMOTION_H
#include <seiscomp/datamodel/timequantity.h>
#include <string>
#include <seiscomp/datamodel/realquantity.h>
#include <seiscomp/datamodel/object.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(PeakMotion);
class Record;
class SC_STRONGMOTION_API PeakMotion : public Object {
DECLARE_SC_CLASS(PeakMotion);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
PeakMotion();
//! Copy constructor
PeakMotion(const PeakMotion& other);
//! Destructor
~PeakMotion();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
PeakMotion& operator=(const PeakMotion& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const PeakMotion& other) const;
bool operator!=(const PeakMotion& other) const;
//! Wrapper that calls operator==
bool equal(const PeakMotion& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setMotion(const RealQuantity& motion);
RealQuantity& motion();
const RealQuantity& motion() const;
void setType(const std::string& type);
const std::string& type() const;
void setPeriod(const OPT(double)& period);
double period() const;
void setDamping(const OPT(double)& damping);
double damping() const;
void setMethod(const std::string& method);
const std::string& method() const;
void setAtTime(const OPT(TimeQuantity)& atTime);
TimeQuantity& atTime();
const TimeQuantity& atTime() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Record* record() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
RealQuantity _motion;
std::string _type;
OPT(double) _period;
OPT(double) _damping;
std::string _method;
OPT(TimeQuantity) _atTime;
};
}
}
}
#endif

236
include/seiscomp/datamodel/strongmotion/record.h Normal file
View File

@ -0,0 +1,236 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_RECORD_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_RECORD_H
#include <seiscomp/datamodel/creationinfo.h>
#include <string>
#include <seiscomp/datamodel/waveformstreamid.h>
#include <seiscomp/datamodel/strongmotion/fileresource.h>
#include <vector>
#include <seiscomp/datamodel/timequantity.h>
#include <seiscomp/datamodel/strongmotion/contact.h>
#include <seiscomp/datamodel/strongmotion/simplefilterchainmember.h>
#include <seiscomp/datamodel/notifier.h>
#include <seiscomp/datamodel/publicobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(Record);
DEFINE_SMARTPOINTER(SimpleFilterChainMember);
DEFINE_SMARTPOINTER(PeakMotion);
class StrongMotionParameters;
class SC_STRONGMOTION_API Record : public PublicObject {
DECLARE_SC_CLASS(Record);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
protected:
//! Protected constructor
Record();
public:
//! Copy constructor
Record(const Record& other);
//! Constructor with publicID
Record(const std::string& publicID);
//! Destructor
~Record();
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static Record* Create();
static Record* Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static Record* Find(const std::string& publicID);
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Record& operator=(const Record& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const Record& other) const;
bool operator!=(const Record& other) const;
//! Wrapper that calls operator==
bool equal(const Record& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setCreationInfo(const OPT(CreationInfo)& creationInfo);
CreationInfo& creationInfo();
const CreationInfo& creationInfo() const;
void setGainUnit(const std::string& gainUnit);
const std::string& gainUnit() const;
void setDuration(const OPT(double)& duration);
double duration() const;
void setStartTime(const TimeQuantity& startTime);
TimeQuantity& startTime();
const TimeQuantity& startTime() const;
void setOwner(const OPT(Contact)& owner);
Contact& owner();
const Contact& owner() const;
void setResampleRateNumerator(const OPT(int)& resampleRateNumerator);
int resampleRateNumerator() const;
void setResampleRateDenominator(const OPT(int)& resampleRateDenominator);
int resampleRateDenominator() const;
void setWaveformID(const WaveformStreamID& waveformID);
WaveformStreamID& waveformID();
const WaveformStreamID& waveformID() const;
void setWaveformFile(const OPT(FileResource)& waveformFile);
FileResource& waveformFile();
const FileResource& waveformFile() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
/**
* Add an object.
* @param obj The object pointer
* @return true The object has been added
* @return false The object has not been added
* because it already exists in the list
* or it already has another parent
*/
bool add(SimpleFilterChainMember* obj);
bool add(PeakMotion* obj);
/**
* Removes an object.
* @param obj The object pointer
* @return true The object has been removed
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(SimpleFilterChainMember* obj);
bool remove(PeakMotion* obj);
/**
* Removes an object of a particular class.
* @param i The object index
* @return true The object has been removed
* @return false The index is out of bounds
*/
bool removeSimpleFilterChainMember(size_t i);
bool removeSimpleFilterChainMember(const SimpleFilterChainMemberIndex& i);
bool removePeakMotion(size_t i);
//! Retrieve the number of objects of a particular class
size_t simpleFilterChainMemberCount() const;
size_t peakMotionCount() const;
//! Index access
//! @return The object at index i
SimpleFilterChainMember* simpleFilterChainMember(size_t i) const;
SimpleFilterChainMember* simpleFilterChainMember(const SimpleFilterChainMemberIndex& i) const;
PeakMotion* peakMotion(size_t i) const;
//! Find an object by its unique attribute(s)
PeakMotion* findPeakMotion(PeakMotion* peakMotion) const;
StrongMotionParameters* strongMotionParameters() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
//! Implement PublicObject interface
bool updateChild(Object* child);
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
OPT(CreationInfo) _creationInfo;
std::string _gainUnit;
OPT(double) _duration;
TimeQuantity _startTime;
OPT(Contact) _owner;
OPT(int) _resampleRateNumerator;
OPT(int) _resampleRateDenominator;
WaveformStreamID _waveformID;
OPT(FileResource) _waveformFile;
// Aggregations
std::vector<SimpleFilterChainMemberPtr> _simpleFilterChainMembers;
std::vector<PeakMotionPtr> _peakMotions;
DECLARE_SC_CLASSFACTORY_FRIEND(Record);
};
}
}
}
#endif

231
include/seiscomp/datamodel/strongmotion/rupture.h Normal file
View File

@ -0,0 +1,231 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_RUPTURE_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_RUPTURE_H
#include <string>
#include <seiscomp/datamodel/strongmotion/surfacerupture.h>
#include <seiscomp/datamodel/strongmotion/literaturesource.h>
#include <seiscomp/datamodel/realquantity.h>
#include <seiscomp/datamodel/strongmotion/types.h>
#include <seiscomp/datamodel/publicobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(Rupture);
class StrongOriginDescription;
class SC_STRONGMOTION_API Rupture : public PublicObject {
DECLARE_SC_CLASS(Rupture);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
protected:
//! Protected constructor
Rupture();
public:
//! Copy constructor
Rupture(const Rupture& other);
//! Constructor with publicID
Rupture(const std::string& publicID);
//! Destructor
~Rupture();
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static Rupture* Create();
static Rupture* Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static Rupture* Find(const std::string& publicID);
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
Rupture& operator=(const Rupture& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const Rupture& other) const;
bool operator!=(const Rupture& other) const;
//! Wrapper that calls operator==
bool equal(const Rupture& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setWidth(const OPT(RealQuantity)& width);
RealQuantity& width();
const RealQuantity& width() const;
void setDisplacement(const OPT(RealQuantity)& displacement);
RealQuantity& displacement();
const RealQuantity& displacement() const;
void setRiseTime(const OPT(RealQuantity)& riseTime);
RealQuantity& riseTime();
const RealQuantity& riseTime() const;
void setVtToVs(const OPT(RealQuantity)& vtToVs);
RealQuantity& vtToVs();
const RealQuantity& vtToVs() const;
void setShallowAsperityDepth(const OPT(RealQuantity)& shallowAsperityDepth);
RealQuantity& shallowAsperityDepth();
const RealQuantity& shallowAsperityDepth() const;
void setShallowAsperity(const OPT(bool)& shallowAsperity);
bool shallowAsperity() const;
void setLiteratureSource(const OPT(LiteratureSource)& literatureSource);
LiteratureSource& literatureSource();
const LiteratureSource& literatureSource() const;
void setSlipVelocity(const OPT(RealQuantity)& slipVelocity);
RealQuantity& slipVelocity();
const RealQuantity& slipVelocity() const;
void setStrike(const OPT(RealQuantity)& strike);
RealQuantity& strike();
const RealQuantity& strike() const;
void setLength(const OPT(RealQuantity)& length);
RealQuantity& length();
const RealQuantity& length() const;
void setArea(const OPT(RealQuantity)& area);
RealQuantity& area();
const RealQuantity& area() const;
void setRuptureVelocity(const OPT(RealQuantity)& ruptureVelocity);
RealQuantity& ruptureVelocity();
const RealQuantity& ruptureVelocity() const;
void setStressdrop(const OPT(RealQuantity)& stressdrop);
RealQuantity& stressdrop();
const RealQuantity& stressdrop() const;
void setMomentReleaseTop5km(const OPT(RealQuantity)& momentReleaseTop5km);
RealQuantity& momentReleaseTop5km();
const RealQuantity& momentReleaseTop5km() const;
void setFwHwIndicator(const OPT(FwHwIndicator)& fwHwIndicator);
FwHwIndicator fwHwIndicator() const;
void setRuptureGeometryWKT(const std::string& ruptureGeometryWKT);
const std::string& ruptureGeometryWKT() const;
void setFaultID(const std::string& faultID);
const std::string& faultID() const;
void setSurfaceRupture(const OPT(SurfaceRupture)& surfaceRupture);
SurfaceRupture& surfaceRupture();
const SurfaceRupture& surfaceRupture() const;
void setCentroidReference(const std::string& centroidReference);
const std::string& centroidReference() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
StrongOriginDescription* strongOriginDescription() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
//! Implement PublicObject interface
bool updateChild(Object* child);
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
OPT(RealQuantity) _width;
OPT(RealQuantity) _displacement;
OPT(RealQuantity) _riseTime;
OPT(RealQuantity) _vtToVs;
OPT(RealQuantity) _shallowAsperityDepth;
OPT(bool) _shallowAsperity;
OPT(LiteratureSource) _literatureSource;
OPT(RealQuantity) _slipVelocity;
OPT(RealQuantity) _strike;
OPT(RealQuantity) _length;
OPT(RealQuantity) _area;
OPT(RealQuantity) _ruptureVelocity;
OPT(RealQuantity) _stressdrop;
OPT(RealQuantity) _momentReleaseTop5km;
OPT(FwHwIndicator) _fwHwIndicator;
std::string _ruptureGeometryWKT;
std::string _faultID;
OPT(SurfaceRupture) _surfaceRupture;
std::string _centroidReference;
DECLARE_SC_CLASSFACTORY_FRIEND(Rupture);
};
}
}
}
#endif

184
include/seiscomp/datamodel/strongmotion/simplefilter.h Normal file
View File

@ -0,0 +1,184 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_SIMPLEFILTER_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_SIMPLEFILTER_H
#include <vector>
#include <string>
#include <seiscomp/datamodel/notifier.h>
#include <seiscomp/datamodel/publicobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(SimpleFilter);
DEFINE_SMARTPOINTER(FilterParameter);
class StrongMotionParameters;
class SC_STRONGMOTION_API SimpleFilter : public PublicObject {
DECLARE_SC_CLASS(SimpleFilter);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
protected:
//! Protected constructor
SimpleFilter();
public:
//! Copy constructor
SimpleFilter(const SimpleFilter& other);
//! Constructor with publicID
SimpleFilter(const std::string& publicID);
//! Destructor
~SimpleFilter();
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static SimpleFilter* Create();
static SimpleFilter* Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static SimpleFilter* Find(const std::string& publicID);
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
SimpleFilter& operator=(const SimpleFilter& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const SimpleFilter& other) const;
bool operator!=(const SimpleFilter& other) const;
//! Wrapper that calls operator==
bool equal(const SimpleFilter& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setType(const std::string& type);
const std::string& type() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
/**
* Add an object.
* @param obj The object pointer
* @return true The object has been added
* @return false The object has not been added
* because it already exists in the list
* or it already has another parent
*/
bool add(FilterParameter* obj);
/**
* Removes an object.
* @param obj The object pointer
* @return true The object has been removed
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(FilterParameter* obj);
/**
* Removes an object of a particular class.
* @param i The object index
* @return true The object has been removed
* @return false The index is out of bounds
*/
bool removeFilterParameter(size_t i);
//! Retrieve the number of objects of a particular class
size_t filterParameterCount() const;
//! Index access
//! @return The object at index i
FilterParameter* filterParameter(size_t i) const;
//! Find an object by its unique attribute(s)
FilterParameter* findFilterParameter(FilterParameter* filterParameter) const;
StrongMotionParameters* strongMotionParameters() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
//! Implement PublicObject interface
bool updateChild(Object* child);
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
std::string _type;
// Aggregations
std::vector<FilterParameterPtr> _filterParameters;
DECLARE_SC_CLASSFACTORY_FRIEND(SimpleFilter);
};
}
}
}
#endif

162
include/seiscomp/datamodel/strongmotion/simplefilterchainmember.h Normal file
View File

@ -0,0 +1,162 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_SIMPLEFILTERCHAINMEMBER_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_SIMPLEFILTERCHAINMEMBER_H
#include <string>
#include <seiscomp/datamodel/object.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(SimpleFilterChainMember);
class Record;
class SC_STRONGMOTION_API SimpleFilterChainMemberIndex {
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
SimpleFilterChainMemberIndex();
SimpleFilterChainMemberIndex(int sequenceNo);
//! Copy constructor
SimpleFilterChainMemberIndex(const SimpleFilterChainMemberIndex&);
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
bool operator==(const SimpleFilterChainMemberIndex&) const;
bool operator!=(const SimpleFilterChainMemberIndex&) const;
// ------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------
public:
int sequenceNo;
};
class SC_STRONGMOTION_API SimpleFilterChainMember : public Object {
DECLARE_SC_CLASS(SimpleFilterChainMember);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
SimpleFilterChainMember();
//! Copy constructor
SimpleFilterChainMember(const SimpleFilterChainMember& other);
//! Destructor
~SimpleFilterChainMember();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
SimpleFilterChainMember& operator=(const SimpleFilterChainMember& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const SimpleFilterChainMember& other) const;
bool operator!=(const SimpleFilterChainMember& other) const;
//! Wrapper that calls operator==
bool equal(const SimpleFilterChainMember& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setSequenceNo(int sequenceNo);
int sequenceNo() const;
void setSimpleFilterID(const std::string& simpleFilterID);
const std::string& simpleFilterID() const;
// ------------------------------------------------------------------
// Index management
// ------------------------------------------------------------------
public:
//! Returns the object's index
const SimpleFilterChainMemberIndex& index() const;
//! Checks two objects for equality regarding their index
bool equalIndex(const SimpleFilterChainMember* lhs) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
Record* record() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Index
SimpleFilterChainMemberIndex _index;
// Attributes
std::string _simpleFilterID;
};
}
}
}
#endif

165
include/seiscomp/datamodel/strongmotion/strongmotionparameters.h Normal file
View File

@ -0,0 +1,165 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_STRONGMOTIONPARAMETERS_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_STRONGMOTIONPARAMETERS_H
#include <vector>
#include <seiscomp/datamodel/notifier.h>
#include <seiscomp/datamodel/publicobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(StrongMotionParameters);
DEFINE_SMARTPOINTER(SimpleFilter);
DEFINE_SMARTPOINTER(Record);
DEFINE_SMARTPOINTER(StrongOriginDescription);
class SC_STRONGMOTION_API StrongMotionParameters : public PublicObject {
DECLARE_SC_CLASS(StrongMotionParameters);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
StrongMotionParameters();
//! Copy constructor
StrongMotionParameters(const StrongMotionParameters& other);
//! Destructor
~StrongMotionParameters();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
StrongMotionParameters& operator=(const StrongMotionParameters& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const StrongMotionParameters& other) const;
bool operator!=(const StrongMotionParameters& other) const;
//! Wrapper that calls operator==
bool equal(const StrongMotionParameters& other) const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
/**
* Add an object.
* @param obj The object pointer
* @return true The object has been added
* @return false The object has not been added
* because it already exists in the list
* or it already has another parent
*/
bool add(SimpleFilter* obj);
bool add(Record* obj);
bool add(StrongOriginDescription* obj);
/**
* Removes an object.
* @param obj The object pointer
* @return true The object has been removed
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(SimpleFilter* obj);
bool remove(Record* obj);
bool remove(StrongOriginDescription* obj);
/**
* Removes an object of a particular class.
* @param i The object index
* @return true The object has been removed
* @return false The index is out of bounds
*/
bool removeSimpleFilter(size_t i);
bool removeRecord(size_t i);
bool removeStrongOriginDescription(size_t i);
//! Retrieve the number of objects of a particular class
size_t simpleFilterCount() const;
size_t recordCount() const;
size_t strongOriginDescriptionCount() const;
//! Index access
//! @return The object at index i
SimpleFilter* simpleFilter(size_t i) const;
Record* record(size_t i) const;
StrongOriginDescription* strongOriginDescription(size_t i) const;
//! Find an object by its unique attribute(s)
SimpleFilter* findSimpleFilter(const std::string& publicID) const;
Record* findRecord(const std::string& publicID) const;
StrongOriginDescription* findStrongOriginDescription(const std::string& publicID) const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
//! Implement PublicObject interface
bool updateChild(Object* child);
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Aggregations
std::vector<SimpleFilterPtr> _simpleFilters;
std::vector<RecordPtr> _records;
std::vector<StrongOriginDescriptionPtr> _strongOriginDescriptions;
DECLARE_SC_CLASSFACTORY_FRIEND(StrongMotionParameters);
};
}
}
}
#endif

37
include/seiscomp/datamodel/strongmotion/strongmotionparameters_package.h Normal file
View File

@ -0,0 +1,37 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_STRONGMOTIONPARAMETERS_PACKAGE_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_STRONGMOTIONPARAMETERS_PACKAGE_H
#include <seiscomp/datamodel/strongmotion/filterparameter.h>
#include <seiscomp/datamodel/strongmotion/simplefilter.h>
#include <seiscomp/datamodel/strongmotion/simplefilterchainmember.h>
#include <seiscomp/datamodel/strongmotion/peakmotion.h>
#include <seiscomp/datamodel/strongmotion/record.h>
#include <seiscomp/datamodel/strongmotion/eventrecordreference.h>
#include <seiscomp/datamodel/strongmotion/rupture.h>
#include <seiscomp/datamodel/strongmotion/strongorigindescription.h>
#include <seiscomp/datamodel/strongmotion/strongmotionparameters.h>
#endif

202
include/seiscomp/datamodel/strongmotion/strongorigindescription.h Normal file
View File

@ -0,0 +1,202 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_STRONGORIGINDESCRIPTION_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_STRONGORIGINDESCRIPTION_H
#include <seiscomp/datamodel/creationinfo.h>
#include <vector>
#include <string>
#include <seiscomp/datamodel/notifier.h>
#include <seiscomp/datamodel/publicobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(StrongOriginDescription);
DEFINE_SMARTPOINTER(EventRecordReference);
DEFINE_SMARTPOINTER(Rupture);
class StrongMotionParameters;
class SC_STRONGMOTION_API StrongOriginDescription : public PublicObject {
DECLARE_SC_CLASS(StrongOriginDescription);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
protected:
//! Protected constructor
StrongOriginDescription();
public:
//! Copy constructor
StrongOriginDescription(const StrongOriginDescription& other);
//! Constructor with publicID
StrongOriginDescription(const std::string& publicID);
//! Destructor
~StrongOriginDescription();
// ------------------------------------------------------------------
// Creators
// ------------------------------------------------------------------
public:
static StrongOriginDescription* Create();
static StrongOriginDescription* Create(const std::string& publicID);
// ------------------------------------------------------------------
// Lookup
// ------------------------------------------------------------------
public:
static StrongOriginDescription* Find(const std::string& publicID);
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
//! No changes regarding child objects are made
StrongOriginDescription& operator=(const StrongOriginDescription& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const StrongOriginDescription& other) const;
bool operator!=(const StrongOriginDescription& other) const;
//! Wrapper that calls operator==
bool equal(const StrongOriginDescription& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setOriginID(const std::string& originID);
const std::string& originID() const;
void setWaveformCount(const OPT(int)& waveformCount);
int waveformCount() const;
void setCreationInfo(const OPT(CreationInfo)& creationInfo);
CreationInfo& creationInfo();
const CreationInfo& creationInfo() const;
// ------------------------------------------------------------------
// Public interface
// ------------------------------------------------------------------
public:
/**
* Add an object.
* @param obj The object pointer
* @return true The object has been added
* @return false The object has not been added
* because it already exists in the list
* or it already has another parent
*/
bool add(EventRecordReference* obj);
bool add(Rupture* obj);
/**
* Removes an object.
* @param obj The object pointer
* @return true The object has been removed
* @return false The object has not been removed
* because it does not exist in the list
*/
bool remove(EventRecordReference* obj);
bool remove(Rupture* obj);
/**
* Removes an object of a particular class.
* @param i The object index
* @return true The object has been removed
* @return false The index is out of bounds
*/
bool removeEventRecordReference(size_t i);
bool removeRupture(size_t i);
//! Retrieve the number of objects of a particular class
size_t eventRecordReferenceCount() const;
size_t ruptureCount() const;
//! Index access
//! @return The object at index i
EventRecordReference* eventRecordReference(size_t i) const;
Rupture* rupture(size_t i) const;
//! Find an object by its unique attribute(s)
EventRecordReference* findEventRecordReference(EventRecordReference* eventRecordReference) const;
Rupture* findRupture(const std::string& publicID) const;
StrongMotionParameters* strongMotionParameters() const;
//! Implement Object interface
bool assign(Object* other);
bool attachTo(PublicObject* parent);
bool detachFrom(PublicObject* parent);
bool detach();
//! Creates a clone
Object* clone() const;
//! Implement PublicObject interface
bool updateChild(Object* child);
void accept(Visitor*);
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
std::string _originID;
OPT(int) _waveformCount;
OPT(CreationInfo) _creationInfo;
// Aggregations
std::vector<EventRecordReferencePtr> _eventRecordReferences;
std::vector<RupturePtr> _ruptures;
DECLARE_SC_CLASSFACTORY_FRIEND(StrongOriginDescription);
};
}
}
}
#endif

106
include/seiscomp/datamodel/strongmotion/surfacerupture.h Normal file
View File

@ -0,0 +1,106 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_SURFACERUPTURE_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_SURFACERUPTURE_H
#include <string>
#include <seiscomp/datamodel/strongmotion/literaturesource.h>
#include <seiscomp/core/baseobject.h>
#include <seiscomp/core/exceptions.h>
#include <seiscomp/datamodel/strongmotion/api.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
DEFINE_SMARTPOINTER(SurfaceRupture);
class SC_STRONGMOTION_API SurfaceRupture : public Core::BaseObject {
DECLARE_SC_CLASS(SurfaceRupture);
DECLARE_SERIALIZATION;
DECLARE_METAOBJECT;
// ------------------------------------------------------------------
// Xstruction
// ------------------------------------------------------------------
public:
//! Constructor
SurfaceRupture();
//! Copy constructor
SurfaceRupture(const SurfaceRupture& other);
//! Destructor
~SurfaceRupture();
// ------------------------------------------------------------------
// Operators
// ------------------------------------------------------------------
public:
//! Copies the metadata of other to this
SurfaceRupture& operator=(const SurfaceRupture& other);
//! Checks for equality of two objects. Childs objects
//! are not part of the check.
bool operator==(const SurfaceRupture& other) const;
bool operator!=(const SurfaceRupture& other) const;
//! Wrapper that calls operator==
bool equal(const SurfaceRupture& other) const;
// ------------------------------------------------------------------
// Setters/Getters
// ------------------------------------------------------------------
public:
void setObserved(bool observed);
bool observed() const;
void setEvidence(const std::string& evidence);
const std::string& evidence() const;
void setLiteratureSource(const OPT(LiteratureSource)& literatureSource);
LiteratureSource& literatureSource();
const LiteratureSource& literatureSource() const;
// ------------------------------------------------------------------
// Implementation
// ------------------------------------------------------------------
private:
// Attributes
bool _observed;
std::string _evidence;
OPT(LiteratureSource) _literatureSource;
};
}
}
}
#endif

52
include/seiscomp/datamodel/strongmotion/types.h Normal file
View File

@ -0,0 +1,52 @@
/***************************************************************************
* Copyright (C) by ETHZ/SED *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as published*
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This software is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Affero General Public License for more details. *
* *
* Developed by gempa GmbH *
***************************************************************************/
// This file was created by a source code generator.
// Do not modify the contents. Change the definition and run the generator
// again!
#ifndef SEISCOMP_DATAMODEL_STRONGMOTION_TYPES_H
#define SEISCOMP_DATAMODEL_STRONGMOTION_TYPES_H
#include <seiscomp/core/enumeration.h>
namespace Seiscomp {
namespace DataModel {
namespace StrongMotion {
MAKEENUM(
FwHwIndicator,
EVALUES(
footwall,
hangingwall
),
ENAMES(
"footwall",
"hanging wall"
)
);
}
}
}
#endif