TypeSet getGreatestCommonSubtypes(const TypeSet& set) { // handle the empty set if (set.empty()) return set; // handle the all set => empty set (since no common sub-type) if (set.isAll()) return TypeSet(); TypeSet res; auto it = set.begin(); res.insert(*it); ++it; // refine sub-set step by step for(;it != set.end(); ++it) { TypeSet tmp; for(const Type& cur : res) { tmp.insert(getGreatestCommonSubtypes(cur, *it)); } res = tmp; } // done return res; }
void visit(const Type& type) const { if (isSubtypeOf(type, b)) { res.insert(type); } else { TypeVisitor<void>::visit(type); } }
TypeSet getLeastCommonSupertypes(const Type& a, const Type& b) { // make sure they are in the same type environment assert(a.getTypeEnvironment().isType(a) && a.getTypeEnvironment().isType(b)); // if they are equal it is easy if (a == b) { return TypeSet(a); } // equally simple - check whether one is a sub-type of the other if (isSubtypeOf(a,b)) { return TypeSet(b); } if (isSubtypeOf(b,a)) { return TypeSet(a); } // harder: no obvious relation => hard way TypeSet superTypes; TypeSet all = a.getTypeEnvironment().getAllTypes(); for(const Type& cur : all) { if (isSubtypeOf(a, cur) && isSubtypeOf(b, cur)) { superTypes.insert(cur); } } // filter out non-least super types TypeSet res; for(const Type& cur : superTypes) { bool least = !any_of(superTypes, [&](const Type& t) { return t != cur && isSubtypeOf(t, cur); }); if (least) res.insert(cur); } return res; }
TypeSet getGreatestCommonSubtypes(const TypeSet& a, const TypeSet& b) { // special cases if (a.empty()) return a; if (b.empty()) return b; if (a.isAll()) return b; if (b.isAll()) return a; // compute pairwise greatest common sub types TypeSet res; for(const Type& x : a) { for(const Type& y : b) { res.insert(getGreatestCommonSubtypes(x,y)); } } return res; }
/** * Run an optimization step. */ size_t OptimizationImpl::optimize(Scope& scope) { TypeList to_optimize; single_impls->get_interfaces(to_optimize); for (auto intf : to_optimize) { auto& intf_data = single_impls->get_single_impl_data(intf); TRACE(INTF, 3, "(OPT) %s => %s\n", SHOW(intf), SHOW(intf_data.cls)); if (intf_data.is_escaped()) continue; auto escape = can_optimize(intf, intf_data); if (escape != EscapeReason::NO_ESCAPE) { single_impls->escape_interface(intf, escape); continue; } do_optimize(intf, intf_data); optimized.insert(intf); } // make a new scope deleting all single impl interfaces Scope new_scope; for (auto cls : scope) { if (optimized.find(cls->get_type()) != optimized.end()) continue; new_scope.push_back(cls); } scope.swap(new_scope); return optimized.size(); }
TypeSet TypeEnvironment::getAllTypes() const { TypeSet res; for(const auto& cur : types) res.insert(*cur.second); return res; }
bool CalculateAmplitudes::process() { //_ui.btnOK->setEnabled(false); _processors.clear(); _ui.table->setRowCount(0); Core::TimeWindow acTimeWindow; if ( !_origin || (_recomputeAmplitudes && !_thread) ) return false; if ( _amplitudeTypes.empty() ) return false; _timeWindow = Core::TimeWindow(); /* TypeSet wantedAmpTypes; wantedAmpTypes.insert("MLv"); wantedAmpTypes.insert("mb"); wantedAmpTypes.insert("mB"); wantedAmpTypes.insert("Mwp"); try { vector<string> amps = SCApp->configGetStrings("amplitudes"); wantedAmpTypes.clear(); wantedAmpTypes.insert(amps.begin(), amps.end()); } catch (...) {} */ QApplication::setOverrideCursor(QCursor(Qt::WaitCursor)); if ( _thread ) _thread->connect(); typedef pair<PickCPtr, double> PickStreamEntry; // Typedef a pickmap that maps a streamcode to a pick typedef map<string, PickStreamEntry> PickStreamMap; // This map is needed to find the earliest P pick of // a certain stream PickStreamMap pickStreamMap; for ( size_t i = 0; i < _origin->arrivalCount(); ++i ) { Arrival *ar = _origin->arrival(i); double weight = 1.; try { weight = ar->weight(); } catch (Seiscomp::Core::ValueException) {} if ( Util::getShortPhaseName(ar->phase().code()) != 'P' || weight < 0.5 ) { continue; } Pick *pick = Pick::Find(ar->pickID()); if ( !pick ) { // cerr << " - Skipping arrival " << i << " -> no pick found" << endl; continue; } double dist = -1; try { dist = ar->distance(); } catch ( Core::ValueError &e ) { try { Client::StationLocation loc; double azi1, azi2; loc = Client::Inventory::Instance()->stationLocation(pick->waveformID().networkCode(), pick->waveformID().stationCode(), pick->time().value()); Math::Geo::delazi(loc.latitude, loc.longitude, _origin->latitude(), _origin->longitude(), &dist, &azi1, &azi2); } catch ( Core::GeneralException &e ) {} } DataModel::WaveformStreamID wfid = pick->waveformID(); // Strip the component code because every AmplitudeProcessor // will use its own component to pick the amplitude on wfid.setChannelCode(wfid.channelCode().substr(0,2)); string streamID = waveformIDToStdString(wfid); PickStreamEntry &e = pickStreamMap[streamID]; // When there is already a pick registered for this stream which has // been picked earlier, ignore the current pick if ( e.first && e.first->time().value() < pick->time().value() ) continue; e.first = pick; e.second = dist; } for ( PickStreamMap::iterator it = pickStreamMap.begin(); it != pickStreamMap.end(); ++it ) { PickCPtr pick = it->second.first; double dist = it->second.second; _ui.comboFilterType->clear(); _ui.comboFilterType->addItem("- Any -"); for ( TypeSet::iterator ita = _amplitudeTypes.begin(); ita != _amplitudeTypes.end(); ++ita ) _ui.comboFilterType->addItem(ita->c_str()); if ( _recomputeAmplitudes ) { for ( TypeSet::iterator ita = _amplitudeTypes.begin(); ita != _amplitudeTypes.end(); ++ita ) addProcessor(*ita, pick.get(), dist); } else { string streamID = waveformIDToStdString(pick->waveformID()); TypeSet usedTypes; if ( !_amplitudes.empty() ) { iterator_range itp; itp = _amplitudes.equal_range(pick->publicID()); for ( iterator it = itp.first; it != itp.second; ) { AmplitudePtr amp = it->second.first; // The amplitude type is not one of the wanted types if ( _amplitudeTypes.find(amp->type()) == _amplitudeTypes.end() ) { ++it; continue; } // Already has an amplitude of this type processed if ( usedTypes.find(amp->type()) != usedTypes.end() ) { ++it; continue; } usedTypes.insert(amp->type()); int row = addProcessingRow(waveformIDToStdString(amp->waveformID()), amp->type()); setMessage(row, "read from cache"); setValue(row, amp->amplitude().value()); ++it; } } bool foundAmplitudes = false; if ( _externalAmplitudeCache ) { iterator_range itp; itp = _externalAmplitudeCache->equal_range(pick->publicID()); for ( iterator ita = itp.first; ita != itp.second; ++ita ) { AmplitudePtr amp = ita->second.first; // The amplitude type is not one of the wanted types if ( _amplitudeTypes.find(amp->type()) == _amplitudeTypes.end() ) continue; // Already has an amplitude of this type processed if ( usedTypes.find(amp->type()) != usedTypes.end() ) { checkPriority(ita->second); continue; } usedTypes.insert(amp->type()); int row = addProcessingRow(waveformIDToStdString(amp->waveformID()), amp->type()); setMessage(row, "read from cache"); setValue(row, amp->amplitude().value()); _amplitudes.insert(PickAmplitudeMap::value_type(ita->first, ita->second)); } } if ( _query && !foundAmplitudes ) { DatabaseIterator it = _query->getAmplitudesForPick(pick->publicID()); for ( ; *it; ++it ) { AmplitudePtr amp = Amplitude::Cast(*it); if ( !amp ) continue; foundAmplitudes = true; // The amplitude type is not one of the wanted types if ( _amplitudeTypes.find(amp->type()) == _amplitudeTypes.end() ) continue; // Already has an amplitude of this type processed if ( usedTypes.find(amp->type()) != usedTypes.end() ) { checkPriority(AmplitudeEntry(amp, false)); continue; } usedTypes.insert(amp->type()); int row = addProcessingRow(waveformIDToStdString(amp->waveformID()), amp->type()); setMessage(row, "read from database"); setValue(row, amp->amplitude().value()); _amplitudes.insert(PickAmplitudeMap::value_type(pick->publicID(), AmplitudeEntry(amp, false))); } } if ( !foundAmplitudes ) { EventParameters *ep = EventParameters::Cast(PublicObject::Find("EventParameters")); if ( ep ) { for ( size_t i = 0; i < ep->amplitudeCount(); ++i ) { Amplitude *amp = ep->amplitude(i); if ( amp->pickID() != pick->publicID() ) continue; // The amplitude type is not one of the wanted types if ( _amplitudeTypes.find(amp->type()) == _amplitudeTypes.end() ) continue; // Already has an amplitude of this type processed if ( usedTypes.find(amp->type()) != usedTypes.end() ) { checkPriority(AmplitudeEntry(amp, false)); continue; } usedTypes.insert(amp->type()); int row = addProcessingRow(waveformIDToStdString(amp->waveformID()), amp->type()); setMessage(row, "read from memory"); setValue(row, amp->amplitude().value()); _amplitudes.insert(PickAmplitudeMap::value_type(pick->publicID(), AmplitudeEntry(amp, false))); } } } TypeSet remainingTypes; set_difference(_amplitudeTypes.begin(), _amplitudeTypes.end(), usedTypes.begin(), usedTypes.end(), inserter(remainingTypes, remainingTypes.begin())); for ( TypeSet::iterator ita = remainingTypes.begin(); ita != remainingTypes.end(); ++ita ) { if ( _thread ) addProcessor(*ita, pick.get(), dist); else { int row = addProcessingRow(streamID, *ita); setError(row, "missing"); } } } } _ui.table->resizeColumnsToContents(); _ui.table->resizeRowsToContents(); if ( _thread && _timeWindow ) { _thread->setTimeWindow(_timeWindow); _thread->start(); } //else // _ui.btnOK->setEnabled(true); QApplication::restoreOverrideCursor(); return true; }