// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool StationMagnitudeContribution::detachFrom(PublicObject* object) {
if ( object == NULL ) return false;
// check all possible parents
Magnitude* magnitude = Magnitude::Cast(object);
if ( magnitude != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return magnitude->remove(this);
// The object has not been added locally so it must be looked up
else {
StationMagnitudeContribution* child = magnitude->stationMagnitudeContribution(index());
if ( child != NULL )
return magnitude->remove(child);
else {
SEISCOMP_DEBUG("StationMagnitudeContribution::detachFrom(Magnitude): stationMagnitudeContribution has not been found");
return false;
}
}
}
SEISCOMP_ERROR("StationMagnitudeContribution::detachFrom(%s) -> wrong class type", object->className());
return false;
}
Numerical::Numerical(const FileSystem::Project& file,
const Magnitude& mag,
const Math::Real timeStep,
const Math::Real finalTime)
: FileSystem::Project(file) {
if(mag.is<Numerical>()) {
operator=(*mag.castTo<Numerical>());
return;
}
std::size_t nSteps;
if (timeStep != 0.0) {
nSteps = (std::size_t)std::abs(finalTime / timeStep);
} else {
nSteps = defaultNumberOfSteps;
std::cerr << "WARNING @ Numerical: "
<< "Attempting to build a "
<< "numerical magnitude with a 0.0 step."
<< "Using default number of steps instead: " << nSteps
<< std::endl;
mag.printInfo();
}
std::ofstream out;
out.open(file.c_str());
Math::Real time = 0.0;
for (std::size_t i = 0; i < nSteps; i++) {
// Determines if neigh values are aligned with current.
std::vector<std::pair<Math::Real,Math::Real>> preAndPost;
const Math::Real tPre = time - timeStep;
const Math::Real tPost = time + timeStep;
preAndPost.push_back(
std::pair<Math::Real,Math::Real>(tPre, mag.evaluate(tPre)));
preAndPost.push_back(
std::pair<Math::Real,Math::Real>(tPost, mag.evaluate(tPost)));
const Math::Real interpolated =
Math::Function::LinearInterpolation<Math::Real,Math::Real>(
preAndPost)(time);
const Math::Real current = mag.evaluate(time);
bool isAligned = Math::Util::equal(current, interpolated,
0.0, std::numeric_limits<Math::Real>::epsilon());
// bool isAligned = (current == interpolated);
//
if (!isAligned || i == nSteps-1) {
out << time << " " << current << std::endl;
}
//
time += timeStep;
}
out.close();
Magnitude::operator=(
Magnitude(
new Math::Function::LinearInterpolation<Math::Real,Math::Real>(
file)));
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool StationMagnitudeContribution::attachTo(PublicObject* parent) {
if ( parent == NULL ) return false;
// check all possible parents
Magnitude* magnitude = Magnitude::Cast(parent);
if ( magnitude != NULL )
return magnitude->add(this);
SEISCOMP_ERROR("StationMagnitudeContribution::attachTo(%s) -> wrong class type", parent->className());
return false;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool Comment::attachTo(PublicObject* parent) {
if ( parent == NULL ) return false;
// check all possible parents
MomentTensor* momentTensor = MomentTensor::Cast(parent);
if ( momentTensor != NULL )
return momentTensor->add(this);
FocalMechanism* focalMechanism = FocalMechanism::Cast(parent);
if ( focalMechanism != NULL )
return focalMechanism->add(this);
Amplitude* amplitude = Amplitude::Cast(parent);
if ( amplitude != NULL )
return amplitude->add(this);
Magnitude* magnitude = Magnitude::Cast(parent);
if ( magnitude != NULL )
return magnitude->add(this);
StationMagnitude* stationMagnitude = StationMagnitude::Cast(parent);
if ( stationMagnitude != NULL )
return stationMagnitude->add(this);
Pick* pick = Pick::Cast(parent);
if ( pick != NULL )
return pick->add(this);
Event* event = Event::Cast(parent);
if ( event != NULL )
return event->add(this);
Origin* origin = Origin::Cast(parent);
if ( origin != NULL )
return origin->add(this);
Parameter* parameter = Parameter::Cast(parent);
if ( parameter != NULL )
return parameter->add(this);
ParameterSet* parameterSet = ParameterSet::Cast(parent);
if ( parameterSet != NULL )
return parameterSet->add(this);
Stream* stream = Stream::Cast(parent);
if ( stream != NULL )
return stream->add(this);
SensorLocation* sensorLocation = SensorLocation::Cast(parent);
if ( sensorLocation != NULL )
return sensorLocation->add(this);
Station* station = Station::Cast(parent);
if ( station != NULL )
return station->add(this);
Network* network = Network::Cast(parent);
if ( network != NULL )
return network->add(this);
SEISCOMP_ERROR("Comment::attachTo(%s) -> wrong class type", parent->className());
return false;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool Origin::updateChild(Object* child) {
Comment* commentChild = Comment::Cast(child);
if ( commentChild != NULL ) {
Comment* commentElement = comment(commentChild->index());
if ( commentElement != NULL ) {
*commentElement = *commentChild;
return true;
}
return false;
}
// Do not know how to fetch child of type CompositeTime without an index
Arrival* arrivalChild = Arrival::Cast(child);
if ( arrivalChild != NULL ) {
Arrival* arrivalElement = arrival(arrivalChild->index());
if ( arrivalElement != NULL ) {
*arrivalElement = *arrivalChild;
return true;
}
return false;
}
StationMagnitude* stationMagnitudeChild = StationMagnitude::Cast(child);
if ( stationMagnitudeChild != NULL ) {
StationMagnitude* stationMagnitudeElement
= StationMagnitude::Cast(PublicObject::Find(stationMagnitudeChild->publicID()));
if ( stationMagnitudeElement && stationMagnitudeElement->parent() == this ) {
*stationMagnitudeElement = *stationMagnitudeChild;
return true;
}
return false;
}
Magnitude* magnitudeChild = Magnitude::Cast(child);
if ( magnitudeChild != NULL ) {
Magnitude* magnitudeElement
= Magnitude::Cast(PublicObject::Find(magnitudeChild->publicID()));
if ( magnitudeElement && magnitudeElement->parent() == this ) {
*magnitudeElement = *magnitudeChild;
return true;
}
return false;
}
return false;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool Origin::add(Magnitude* magnitude) {
if ( magnitude == NULL )
return false;
// Element has already a parent
if ( magnitude->parent() != NULL ) {
SEISCOMP_ERROR("Origin::add(Magnitude*) -> element has already a parent");
return false;
}
if ( PublicObject::IsRegistrationEnabled() ) {
Magnitude* magnitudeCached = Magnitude::Find(magnitude->publicID());
if ( magnitudeCached ) {
if ( magnitudeCached->parent() ) {
if ( magnitudeCached->parent() == this )
SEISCOMP_ERROR("Origin::add(Magnitude*) -> element with same publicID has been added already");
else
SEISCOMP_ERROR("Origin::add(Magnitude*) -> element with same publicID has been added already to another object");
return false;
}
else
magnitude = magnitudeCached;
}
}
// Add the element
_magnitudes.push_back(magnitude);
magnitude->setParent(this);
// Create the notifiers
if ( Notifier::IsEnabled() ) {
NotifierCreator nc(OP_ADD);
magnitude->accept(&nc);
}
// Notify registered observers
childAdded(magnitude);
return true;
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool Comment::detachFrom(PublicObject* object) {
if ( object == NULL ) return false;
// check all possible parents
MomentTensor* momentTensor = MomentTensor::Cast(object);
if ( momentTensor != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return momentTensor->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = momentTensor->comment(index());
if ( child != NULL )
return momentTensor->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(MomentTensor): comment has not been found");
return false;
}
}
}
FocalMechanism* focalMechanism = FocalMechanism::Cast(object);
if ( focalMechanism != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return focalMechanism->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = focalMechanism->comment(index());
if ( child != NULL )
return focalMechanism->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(FocalMechanism): comment has not been found");
return false;
}
}
}
Amplitude* amplitude = Amplitude::Cast(object);
if ( amplitude != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return amplitude->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = amplitude->comment(index());
if ( child != NULL )
return amplitude->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Amplitude): comment has not been found");
return false;
}
}
}
Magnitude* magnitude = Magnitude::Cast(object);
if ( magnitude != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return magnitude->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = magnitude->comment(index());
if ( child != NULL )
return magnitude->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Magnitude): comment has not been found");
return false;
}
}
}
StationMagnitude* stationMagnitude = StationMagnitude::Cast(object);
if ( stationMagnitude != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return stationMagnitude->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = stationMagnitude->comment(index());
if ( child != NULL )
return stationMagnitude->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(StationMagnitude): comment has not been found");
return false;
}
}
}
Pick* pick = Pick::Cast(object);
if ( pick != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return pick->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = pick->comment(index());
if ( child != NULL )
return pick->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Pick): comment has not been found");
return false;
}
}
}
Event* event = Event::Cast(object);
if ( event != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return event->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = event->comment(index());
if ( child != NULL )
return event->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Event): comment has not been found");
return false;
}
}
}
Origin* origin = Origin::Cast(object);
if ( origin != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return origin->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = origin->comment(index());
if ( child != NULL )
return origin->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Origin): comment has not been found");
return false;
}
}
}
Parameter* parameter = Parameter::Cast(object);
if ( parameter != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return parameter->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = parameter->comment(index());
if ( child != NULL )
return parameter->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Parameter): comment has not been found");
return false;
}
}
}
ParameterSet* parameterSet = ParameterSet::Cast(object);
if ( parameterSet != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return parameterSet->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = parameterSet->comment(index());
if ( child != NULL )
return parameterSet->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(ParameterSet): comment has not been found");
return false;
}
}
}
Stream* stream = Stream::Cast(object);
if ( stream != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return stream->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = stream->comment(index());
if ( child != NULL )
return stream->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Stream): comment has not been found");
return false;
}
}
}
SensorLocation* sensorLocation = SensorLocation::Cast(object);
if ( sensorLocation != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return sensorLocation->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = sensorLocation->comment(index());
if ( child != NULL )
return sensorLocation->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(SensorLocation): comment has not been found");
return false;
}
}
}
Station* station = Station::Cast(object);
if ( station != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return station->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = station->comment(index());
if ( child != NULL )
return station->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Station): comment has not been found");
return false;
}
}
}
Network* network = Network::Cast(object);
if ( network != NULL ) {
// If the object has been added already to the parent locally
// just remove it by pointer
if ( object == parent() )
return network->remove(this);
// The object has not been added locally so it must be looked up
else {
Comment* child = network->comment(index());
if ( child != NULL )
return network->remove(child);
else {
SEISCOMP_DEBUG("Comment::detachFrom(Network): comment has not been found");
return false;
}
}
}
SEISCOMP_ERROR("Comment::detachFrom(%s) -> wrong class type", object->className());
return false;
}
