bool needsUpdate(GrabberScript* script, uint updateFreq)
{
QDateTime now = QDateTime::currentDateTime();
QDateTime then = lastUpdate(script);
return then.addSecs(updateFreq * 60 * 60) < now;
}
void QLClient::listen() {
IO::QuakeLink::RequestFormat rf = _config->gzip ?
(_config->native ? IO::QuakeLink::rfGZNative : IO::QuakeLink::rfGZXML) :
(_config->native ? IO::QuakeLink::rfNative : IO::QuakeLink::rfXML);
// activate socket timeout if keepAlive was requested
if ( _config->options & IO::QuakeLink::opKeepAlive ) {
if ( _sock ) {
_sock->setTimeout(60);
}
else {
SEISCOMP_ERROR("%sinstance not initialized", _logPrefix.c_str());
return;
}
}
while ( !interrupted() ) {
// determine start time of request
Core::Time from;
string filter = _config->filter;
if ( _backLog > 0 ) {
Core::Time minTime = Core::Time::GMT() - Core::TimeSpan(_backLog);
from = lastUpdate();
if ( !from.valid() || from < minTime )
from = minTime;
if ( !filter.empty() )
filter += " AND ";
filter += "UPDATED > " + from.toString(IO::QuakeLink::RequestTimeFormat);
}
// start request
try {
select(from.valid(), Core::Time(), Core::Time(), rf, filter);
}
catch ( Core::GeneralException& e) {
if ( interrupted() )
break;
SEISCOMP_DEBUG("%sselect exception: %s", _logPrefix.c_str(), e.what());
}
_sock->close(); // clears interrupt flag
SEISCOMP_WARNING("%sQuakeLink connection closed, trying to reconnect "
"in 5s", _logPrefix.c_str());
for ( int i = 0; i < 50; ++i ) {
usleep(100000); // 100ms
if ( interrupted() )
break;
}
}
if ( interrupted() )
SEISCOMP_INFO("%sQuakeLink connection interrupted", _logPrefix.c_str());
_sock->close();
}
void SPxSolver::qualRedCostViolation(Real& maxviol, Real& sumviol) const
{
maxviol = 0.0;
sumviol = 0.0;
int i;
// TODO: y = c_B * B^-1 => coSolve(y, c_B)
// redcost = c_N - yA_N
// solve system "x = e_i^T * B^-1" to get i'th row of B^-1
// DVector y( nRows() );
// basis().coSolve( x, spx->unitVector( i ) );
// DVector rdcost( nCols() );
#if 0 // un-const
if (lastUpdate() > 0)
factorize();
computePvec();
if (type() == ENTER)
computeTest();
#endif
if (type() == ENTER)
{
for(i = 0; i < dim(); ++i)
{
Real x = coTest()[i];
if (x < 0.0)
{
sumviol -= x;
if (x < maxviol)
maxviol = x;
}
}
for(i = 0; i < coDim(); ++i)
{
Real x = test()[i];
if (x < 0.0)
{
sumviol -= x;
if (x < maxviol)
maxviol = x;
}
}
}
else
{
assert(type() == LEAVE);
for(i = 0; i < dim(); ++i)
{
Real x = fTest()[i];
if (x < 0.0)
{
sumviol -= x;
if (x < maxviol)
maxviol = x;
}
}
}
maxviol *= -1;
}
//+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+
//| From IPFTest |
//+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+
bool PFTestSplitByAmount::Proceed(IObject* pCont,
PreciseTimeValue timeStart,
PreciseTimeValue& timeEnd,
Object* pSystem,
INode* pNode,
INode* actionNode,
IPFIntegrator* integrator,
BitArray& testResult,
Tab<float>& testTime)
{
int contIndex;
if (!hasParticleContainer(pCont, contIndex)) return false;
_lastUpdate(contIndex) = timeEnd.TimeValue();
bool exactStep = IsExactIntegrationStep(timeEnd, pSystem);
// update all other systems to the current time; everybody should be in sync
// for proper accumulation amounts
int i;
for(i=0; i<allParticleContainers().Count(); i++) {
if (allParticleContainer(i) == pCont) continue;
if (allSystemNode(i) == pNode) continue;
if (lastUpdate(i) == timeEnd.TimeValue()) continue;
TimeValue timeToUpdateTo = timeEnd.TimeValue();
allSystemNode(i)->NotifyDependents(FOREVER, PartID(&timeToUpdateTo), kPFMSG_UpdateToTime, NOTIFY_ALL, TRUE );
}
// get channel container interface
IChannelContainer* chCont;
chCont = GetChannelContainerInterface(pCont);
if (chCont == NULL) return false;
// acquire absolutely necessary particle channels
IParticleChannelAmountR* chAmount = GetParticleChannelAmountRInterface(pCont);
if (chAmount == NULL) return false; // can't find number of particles in the container
IParticleChannelNewR* chNew = GetParticleChannelNewRInterface(pCont);
if (chNew == NULL) return false; // can't find "new" property of particles in the container
// acquire TestSplitByAmount private particle channel; if not present then create it
IParticleChannelBoolW* chTestW = (IParticleChannelBoolW*)chCont->EnsureInterface(PARTICLECHANNELTESTSPLITBYAMOUNTW_INTERFACE,
ParticleChannelBool_Class_ID,
true, PARTICLECHANNELTESTSPLITBYAMOUNTR_INTERFACE,
PARTICLECHANNELTESTSPLITBYAMOUNTW_INTERFACE, false,
actionNode, (Object*)this);
IParticleChannelBoolR* chTestR = (IParticleChannelBoolR*)chCont->GetPrivateInterface(PARTICLECHANNELTESTSPLITBYAMOUNTR_INTERFACE, (Object*)this);
if ((chTestR == NULL) || (chTestW == NULL)) return false; // can't set test value for newly entered particles
int count = chAmount->Count();
// check if all particles are "old". If some particles are "new" then we
// have to calculate test values for those.
if (!chNew->IsAllOld())
{
RandGenerator* randGen = randLinker().GetRandGenerator(pCont);
if (randGen == NULL) return false;
int testType = pblock()->GetInt(kSplitByAmount_testType, timeStart);
float fraction = GetPFFloat(pblock(), kSplitByAmount_fraction, timeStart);
int everyN = GetPFInt(pblock(), kSplitByAmount_everyN, timeStart);
int firstN = pblock()->GetInt(kSplitByAmount_firstN, timeStart);
bool perSource = (pblock()->GetInt(kSplitByAmount_perSource, timeStart) != 0);
int curWentThru = perSource ? wentThruTotal(pNode) : wentThruTotal();
// number of "first N" particles is adjusted by multiplier coefficient
// of the master particle system. This is done to make "first N"
// parameter to be consistent to "total" number of particles acclaimed
// by a birth operator
IPFSystem* pfSys = PFSystemInterface(pSystem);
if (pfSys == NULL) return false; // no handle for PFSystem interface
firstN *= pfSys->GetMultiplier(timeStart);
for(i=0; i<count; i++) {
if (chNew->IsNew(i)) { // calculate test value only for new particles
bool sendOut = false;
switch(testType) {
case kSplitByAmount_testType_fraction:
sendOut = (randGen->Rand01() <= fraction);
break;
case kSplitByAmount_testType_everyN:
_wentThruAccum(contIndex) += 1;
if (wentThruAccum(contIndex) >= everyN) {
sendOut = true;
_wentThruAccum(contIndex) = 0;
}
break;
case kSplitByAmount_testType_firstN:
_wentThruTotal(contIndex) += 1;
if (curWentThru++ < firstN) sendOut = true;
break;
case kSplitByAmount_testType_afterFirstN:
_wentThruTotal(contIndex) += 1;
if (curWentThru++ >= firstN) sendOut = true;
break;
}
chTestW->SetValue(i, sendOut);
}
}
}
// check all particles by predefined test channel
testResult.SetSize(count);
testResult.ClearAll();
testTime.SetCount(count);
if (exactStep) {
for(i=0; i<count; i++)
{
if (chTestR->GetValue(i)) {
testResult.Set(i);
testTime[i] = 0.0f;
}
}
}
return true;
}
