void FileProjections::readProjectionsInfo() { // Prepare nodes NodeMap* nodeList = graph->getNodeMap(); unsigned count = nodeList->size(); if (!count) return; unsigned oldSize = projectionsList->size(); bool isProjectionsWasEmpty = !oldSize; projectionsList->resize(count, nullptr); projectionsList->shrink_to_fit(); auto oldStart = projectionsList->begin(); auto oldEnd = projectionsList->begin() + oldSize; auto it = nodeList->begin(); Projection* pr; ProjectionsReader reader(*this); std::string saveName(graphFileName); unsigned nameSize = saveName.size(); bool someMissing = false, someReaded = false; startProcess(0u, count - 1); unsigned currentId; unsigned pos = oldSize; for(unsigned i = 0u; i < count; ++i, ++it) { if (isInterrupted()) { projectionStatus = Status::PARTIAL; return; } updateProgress(i); currentId = it->first; pr = nullptr; // Projection exist - skip if (!isProjectionsWasEmpty) { auto e = std::lower_bound(oldStart, oldEnd, currentId, Projection::lessById); if (e != oldEnd && (*e)->getId() == currentId) { pr = *e; } } if (!pr) { pr = new Projection(currentId); (*projectionsList)[pos] = pr; ++pos; } ProjectionsReader::projectionFileName(saveName, nameSize, currentId); bool result = reader.readProjectionInfo(saveName.data(), pr); if (result) { someReaded = true; } else { someMissing = true; if (reader.getLastError() == ProjectionsReader::Error::TYPE) { lastError = Error::TYPE; } } } if (someReaded) { projectionStatus = someMissing ? Status::PARTIAL : Status::ALL; } else { projectionStatus = Status::EMPTY; } // check that list was not empty and some new projections added if (oldSize && oldSize != count) { auto end = projectionsList->end(); std::sort(oldStart, end, Projection::less); } completeProcess(); }
void FileProjections::createAllProjections() { if (graph->isEmpty()) { return; } if(isMemoryUsed()) { Projections::createAllProjections(); return; } // Prepare nodes NodeMap* nodeList = graph->getNodeMap(); unsigned count = nodeList->size(); if (!count) return; ProjectionsWriter writer(*this); setWorker(&writer, true); startProcess(0u, count - 1); unsigned oldSize = projectionsList->size(); bool isWasEmpty = !oldSize; projectionsList->resize(count, nullptr); projectionsList->shrink_to_fit(); auto oldStart = projectionsList->begin(); auto oldEnd = projectionsList->begin() + oldSize; auto it = nodeList->begin(); Projection* pr; std::string saveName(graphFileName); unsigned nameSize = saveName.size(); unsigned currentId; unsigned pos = oldSize; for(unsigned i = 0u; i < count; ++i, ++it) { if (isInterrupted()) { projectionStatus = Status::PARTIAL; // if interrupted on null filled projections, shrink list projectionsList->resize(pos); break; } updateProgress(i); currentId = it->first; pr = nullptr; // Projection exist - skip if (!isWasEmpty) { auto e = std::lower_bound(oldStart, oldEnd, currentId, Projection::lessById); if (e != oldEnd && (*e)->getId() == currentId) { pr = *e; if (pr->fileExist()) continue; } } if (!pr) { pr = new Projection(currentId); (*projectionsList)[pos] = pr; ++pos; } pr->createProjection(*graph); if (pr->isInterrupted()) { continue; } ProjectionsReader::projectionFileName(saveName, nameSize, currentId); bool result = writer.saveProjection(saveName.data(), pr); if (result) { pr->setFileExist(true); } // stay loaded last projection if (count - i > 1) { pr->clear(); } else { loadedProjection = pr; } } if (!isWasEmpty) { auto end = projectionsList->end(); std::sort(oldStart, end, Projection::less); } if (!isInterrupted()) projectionStatus = Status::ALL; completeProcess(); }
void Cvode::CVodeCore() { _idid = CVodeReInit(_cvodeMem, _tCurrent, _CV_y); _idid = CVodeSetStopTime(_cvodeMem, _tEnd); _idid = CVodeSetInitStep(_cvodeMem, 1e-12); if (_idid < 0) throw ModelicaSimulationError(SOLVER,"CVode::ReInit"); bool writeEventOutput = (_settings->getGlobalSettings()->getOutputPointType() == OPT_ALL); bool writeOutput = !(_settings->getGlobalSettings()->getOutputPointType() == OPT_NONE); while ((_solverStatus & ISolver::CONTINUE) && !_interrupt ) { _cv_rt = CVode(_cvodeMem, _tEnd, _CV_y, &_tCurrent, CV_ONE_STEP); _idid = CVodeGetNumSteps(_cvodeMem, &_locStps); if (_idid != CV_SUCCESS) throw ModelicaSimulationError(SOLVER,"CVodeGetNumSteps failed. The cvode mem pointer is NULL"); _idid = CVodeGetLastStep(_cvodeMem, &_h); if (_idid != CV_SUCCESS) throw ModelicaSimulationError(SOLVER,"CVodeGetLastStep failed. The cvode mem pointer is NULL"); //set completed step to system and check if terminate was called if(_continuous_system->stepCompleted(_tCurrent)) _solverStatus = DONE; //Check if there was at least one output-point within the last solver interval // -> Write output if true if (writeOutput) { writeCVodeOutput(_tCurrent, _h, _locStps); } #ifdef RUNTIME_PROFILING MEASURETIME_REGION_DEFINE(cvodeStepCompletedHandler, "CVodeStepCompleted"); if(MeasureTime::getInstance() != NULL) { MEASURETIME_START(measuredFunctionStartValues, cvodeStepCompletedHandler, "CVodeStepCompleted"); } #endif #ifdef RUNTIME_PROFILING if(MeasureTime::getInstance() != NULL) { MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[5], cvodeStepCompletedHandler); } #endif // Perform state selection bool state_selection = stateSelection(); if (state_selection) _continuous_system->getContinuousStates(_z); _zeroFound = false; // Check if step was successful if (check_flag(&_cv_rt, "CVode", 1)) { _solverStatus = ISolver::SOLVERERROR; break; } // A root was found if ((_cv_rt == CV_ROOT_RETURN) && !isInterrupted()) { // CVode is setting _tCurrent to the time where the first event occurred double _abs = fabs(_tLastEvent - _tCurrent); _zeroFound = true; if ((_abs < 1e-3) && _event_n == 0) { _tLastEvent = _tCurrent; _event_n++; } else if ((_abs < 1e-3) && (_event_n >= 1 && _event_n < 500)) { _event_n++; } else if ((_abs >= 1e-3)) { //restart event counter _tLastEvent = _tCurrent; _event_n = 0; } else throw ModelicaSimulationError(EVENT_HANDLING,"Number of events exceeded in time interval " + to_string(_abs) + " at time " + to_string(_tCurrent)); // CVode has interpolated the states at time 'tCurrent' _time_system->setTime(_tCurrent); // To get steep steps in the result file, two value points (P1 and P2) must be added // // Y | (P2) X........... // | : // | : // |........X (P1) // |----------------------------------> // | ^ t // _tCurrent // Write the values of (P1) if (writeEventOutput) { _continuous_system->evaluateAll(IContinuous::CONTINUOUS); writeToFile(0, _tCurrent, _h); } _idid = CVodeGetRootInfo(_cvodeMem, _zeroSign); for (int i = 0; i < _dimZeroFunc; i++) _events[i] = bool(_zeroSign[i]); if (_mixed_system->handleSystemEvents(_events)) { // State variables were reinitialized, thus we have to give these values to the cvode-solver // Take care about the memory regions, _z is the same like _CV_y _continuous_system->getContinuousStates(_z); } } if ((_zeroFound || state_selection)&& !isInterrupted()) { // Write the values of (P2) if (writeEventOutput) { // If we want to write the event-results, we should evaluate the whole system again _continuous_system->evaluateAll(IContinuous::CONTINUOUS); writeToFile(0, _tCurrent, _h); } _idid = CVodeReInit(_cvodeMem, _tCurrent, _CV_y); if (_idid < 0) throw ModelicaSimulationError(SOLVER,"CVode::ReInit()"); // Der Eventzeitpunkt kann auf der Endzeit liegen (Time-Events). In diesem Fall wird der Solver beendet, da CVode sonst eine interne Warnung schmeißt if (_tCurrent == _tEnd) _cv_rt = CV_TSTOP_RETURN; if(_continuous_system->stepCompleted(_tCurrent)) _solverStatus = DONE; } // Zähler für die Anzahl der ausgegebenen Schritte erhöhen ++_outStps; _tLastSuccess = _tCurrent; if (_cv_rt == CV_TSTOP_RETURN) { _time_system->setTime(_tEnd); //Solver has finished calculation - calculate the final values _continuous_system->setContinuousStates(NV_DATA_S(_CV_y)); _continuous_system->evaluateAll(IContinuous::CONTINUOUS); if(writeOutput) writeToFile(0, _tEnd, _h); _accStps += _locStps; _solverStatus = DONE; } } }
/** @param fileName the file to open @param continueOnErrors whether to continue or immediately bail upon an error @param noFileNotFoundMessage whether or not to log if we find a file (we normally want to but for robot param files that'd be too annoying since we test for a lot of files) @param errorBuffer buffer to put errors into if not NULL. Only the first error is saved, and as soon as this function is called it immediately empties the errorBuffer @param errorBufferLen the length of @a errorBuffer */ AREXPORT bool ArFileParser::parseFile(const char *fileName, bool continueOnErrors, bool noFileNotFoundMessage, char *errorBuffer, size_t errorBufferLen) { myInterruptMutex.lock(); myIsInterrupted = false; myInterruptMutex.unlock(); FILE *file = NULL; char line[10000]; bool ret = true; if (errorBuffer) errorBuffer[0] = '\0'; std::string realFileName; if (fileName[0] == '/' || fileName[0] == '\\') { realFileName = fileName; } else { realFileName = myBaseDir; realFileName += fileName; } ArLog::log(ArLog::Verbose, "Opening file %s from fileName given %s and base directory %s", realFileName.c_str(), fileName, myBaseDir.c_str()); //char *buf = new char[4096]; if ((file = ArUtil::fopen(realFileName.c_str(), "r")) == NULL) { if (errorBuffer != NULL) snprintf(errorBuffer, errorBufferLen, "cannot open file %s", fileName); if (!noFileNotFoundMessage) ArLog::log(ArLog::Terse, "ArFileParser::parseFile: Could not open file %s to parse file.", realFileName.c_str()); return false; } /** if( setvbuf( file, buf, _IOFBF, sizeof( buf ) ) != 0 ) printf( "Incorrect type or size of buffer for file\n" ); //else // printf( "'file' now has a buffer of 1024 bytes\n" ); **/ resetCounters(); // read until the end of the file while (!isInterrupted() && (fgets(line, sizeof(line), file) != NULL)) { if (!parseLine(line, errorBuffer, errorBufferLen)) { ArLog::log(ArLog::Terse, "## Last error on line %d of file '%s'", myLineNumber, realFileName.c_str()); ret = false; if (!continueOnErrors) break; } } fclose(file); return ret; }
LDL_int LDL_numeric /* returns n if successful, k if D (k,k) is zero */ ( LDL_int n, /* A and L are n-by-n, where n >= 0 */ LDL_int Ap [ ], /* input of size n+1, not modified */ LDL_int Ai [ ], /* input of size nz=Ap[n], not modified */ scs_float Ax [ ], /* input of size nz=Ap[n], not modified */ LDL_int Lp [ ], /* input of size n+1, not modified */ LDL_int Parent [ ], /* input of size n, not modified */ LDL_int Lnz [ ], /* output of size n, not defn. on input */ LDL_int Li [ ], /* output of size lnz=Lp[n], not defined on input */ scs_float Lx [ ], /* output of size lnz=Lp[n], not defined on input */ scs_float D [ ], /* output of size n, not defined on input */ scs_float Y [ ], /* workspace of size n, not defn. on input or output */ LDL_int Pattern [ ],/* workspace of size n, not defn. on input or output */ LDL_int Flag [ ], /* workspace of size n, not defn. on input or output */ LDL_int P [ ], /* optional input of size n */ LDL_int Pinv [ ] /* optional input of size n */ ) { scs_float yi, l_ki ; LDL_int i, k, p, kk, p2, len, top ; for (k = 0 ; k < n ; k++) { if(isInterrupted()) { scs_printf("interrupt detected in factorization\n"); return -1; } /* compute nonzero Pattern of kth row of L, in topological order */ Y [k] = 0.0 ; /* Y(0:k) is now all zero */ top = n ; /* stack for pattern is empty */ Flag [k] = k ; /* mark node k as visited */ Lnz [k] = 0 ; /* count of nonzeros in column k of L */ kk = (P) ? (P [k]) : (k) ; /* kth original, or permuted, column */ p2 = Ap [kk+1] ; for (p = Ap [kk] ; p < p2 ; p++) { i = (Pinv) ? (Pinv [Ai [p]]) : (Ai [p]) ; /* get A(i,k) */ if (i <= k) { Y [i] += Ax [p] ; /* scatter A(i,k) into Y (sum duplicates) */ for (len = 0 ; Flag [i] != k ; i = Parent [i]) { Pattern [len++] = i ; /* L(k,i) is nonzero */ Flag [i] = k ; /* mark i as visited */ } while (len > 0) Pattern [--top] = Pattern [--len] ; } } /* compute numerical values kth row of L (a sparse triangular solve) */ D [k] = Y [k] ; /* get D(k,k) and clear Y(k) */ Y [k] = 0.0 ; for ( ; top < n ; top++) { i = Pattern [top] ; /* Pattern [top:n-1] is pattern of L(:,k) */ yi = Y [i] ; /* get and clear Y(i) */ Y [i] = 0.0 ; p2 = Lp [i] + Lnz [i] ; for (p = Lp [i] ; p < p2 ; p++) { Y [Li [p]] -= Lx [p] * yi ; } l_ki = yi / D [i] ; /* the nonzero entry L(k,i) */ D [k] -= l_ki * yi ; Li [p] = k ; /* store L(k,i) in column form of L */ Lx [p] = l_ki ; Lnz [i]++ ; /* increment count of nonzeros in col i */ } if (D [k] == 0.0) return (k) ; /* failure, D(k,k) is zero */ } return (n) ; /* success, diagonal of D is all nonzero */ }