void
MMO_Expression_::_addDeps (Dependencies deps, DEP_Type type, Index index)
{
DEP_Type vectorType = DEP_STATE_VECTOR;
if (type == DEP_DISCRETE)
{
vectorType = DEP_DISCRETE_VECTOR;
}
else if (type == DEP_ALGEBRAIC)
{
vectorType = DEP_ALGEBRAIC_VECTOR;
}
for (Index *idx = deps->begin (type); !deps->end (type);
idx = deps->next (type))
{
Index dIdx (*idx);
if (dIdx.hasRange ())
{
// TODO: Agregar las dependencias vectoriales con el rango correcto cuando no
// estan definidas en el mismo rango que la discreta.
Index vi (index);
vi.setOffset (dIdx.offset ());
_deps->insert (vi, vectorType);
}
else
{
_deps->insert (dIdx, type);
}
}
}
long ConditionsMappedUserPool<MAPPING>::compute(const Dependencies& deps, void* user_param) {
long num_updates = 0;
if ( !deps.empty() ) {
typedef Dependencies _D;
ConditionsDependencyHandler handler(m_manager.ptr(), *this, deps, user_param);
ConditionsPool* pool = m_manager->registerIOV(*m_iov.iovType, m_iov.keyData);
// Loop over the dependencies and check if they have to be upgraded
for(_D::const_iterator i = deps.begin(); i!=deps.end(); ++i) {
key_type key = (*i).first;
typename MAPPING::iterator j = m_conditions.find(key);
if ( j != m_conditions.end() ) {
Condition::Object* cond = (*j).second;
if ( IOV::key_is_contained(m_iov.keyData,cond->iov->keyData) )
continue;
/// This condition is no longer valid. remove it! Will be added again afterwards.
m_conditions.erase(j);
}
const ConditionDependency* d = (*i).second.get();
Condition::Object* cond = handler(d);
m_manager->registerUnlocked(pool, cond); // Would bulk update be more efficient?
++num_updates;
}
}
return num_updates;
}
void JSONJob::execute()
{
std::shared_ptr<Project> proj = project();
const Path root = proj->path();
const Dependencies deps = proj->dependencies();
// error() << deps.keys();
assert(proj);
const SymbolMap &map = proj->symbols();
write("{");
bool firstObject = true;
for (Dependencies::const_iterator it = deps.begin(); it != deps.end(); ++it) {
const Path path = Location::path(it->first);
if (path.startsWith(root) && (match.isEmpty() || match.match(path))) {
const Location loc(it->first, 0);
const int srcRootLength = project()->path().size();
if (firstObject) {
firstObject = false;
} else {
write(",");
}
write<64>("\"%s\":[", path.constData() + srcRootLength);
bool firstSymbol = true;
SymbolMap::const_iterator sit = map.lower_bound(loc);
while (sit != map.end() && sit->first.fileId() == it->first) {
Location targetLocation;
SymbolInfo target = sit->second.bestTarget(map, 0, &targetLocation);
const String type = sit->second.kindSpelling();
if (firstSymbol) {
firstSymbol = false;
} else {
write(",");
}
if (!targetLocation.isNull()) {
write<256>("{\"location\":%s,\"type\":\"%s\",\"target\":%s}",
toJSON(sit->first, it->first, sit->second.symbolLength, srcRootLength).constData(), type.constData(),
toJSON(targetLocation, it->first, target.symbolLength, srcRootLength).constData());
} else {
write<256>("{\"location\":%s,\"type\":\"%s\"}",
toJSON(sit->first, it->first, sit->second.symbolLength, srcRootLength).constData(), type.constData());
}
++sit;
}
write("]");
}
}
write("}");
}
void
MMO_Expression_::_traverseAlgebraics (Dependencies deps, Index derivativeIndex,
Dependencies derivativeDeps,
map<Index, Index> *states,
map<Index, Index> *discretes,
Index variableChange, DEP_Type type,
int value)
{
for (Index *idx = deps->begin (type); !deps->end (type);
idx = deps->next (type))
{
list<MMO_Equation> algEqs = _data->algebraics ()->equation (*idx);
list<MMO_Equation>::iterator algEq;
if (type == DEP_ALGEBRAIC_VECTOR_DEF)
{
derivativeDeps->insert (*idx, DEP_ALGEBRAIC_VECTOR);
}
int algValue = -1;
for (algEq = algEqs.begin (); algEq != algEqs.end (); algEq++)
{
Index algebraicIdx = *idx;
if (value >= 0 && idx->hasRange ())
{
algebraicIdx = idx->indexValue (value);
}
if (!(*algEq)->exp()->deps()->autonomous())
{
_deps->setAutonomous(false);
}
Index variableCh;
int f = (*algEq)->lhs ().factor ();
int c = (*algEq)->lhs ().operConstant ();
if (f != 0 && type == DEP_ALGEBRAIC_DEF)
{
if (f != 1 || c != 0)
{
variableCh.setFactor (f);
variableCh.setConstant (-c);
variableCh.setLow ((*algEq)->lhs ().low () * f + c);
variableCh.setHi ((*algEq)->lhs ().hi () * f + c);
}
}
Index algebraicIndex = (*algEq)->lhs ();
if (variableChange.isSet ())
{
algebraicIndex = (*algEq)->lhs ().applyVariableChange (
variableChange);
algebraicIdx = idx->applyVariableChange (variableChange);
algebraicIdx.setLow (variableChange.low ());
algebraicIdx.setHi (variableChange.hi ());
}
Intersection is = algebraicIndex.intersection (algebraicIdx);
if (is.type () != IDX_DISJOINT)
{
Index algKey = algebraicIdx;
Index equationIndex;
equationIndex.setOffset (_equationIndex++);
if (is.hasRange ())
{
equationIndex.setRange ();
equationIndex.setLow (is.low ());
equationIndex.setHi (is.hi ());
algKey.setRange ();
algKey.setHi (equationIndex.hi ());
algKey.setLow (equationIndex.low ());
}
else
{
equationIndex.setConstant (is.modelicaValue ());
if (is.type () == IDX_CONSTANT_BA)
{
algKey.setConstant (is.modelicaValue () + is.begin ());
algValue = is.modelicaValue ();
}
else if (is.type () == IDX_CONSTANT_AB)
{
algKey.setConstant (is.modelicaValue () + is.begin ());
algValue = is.modelicaValue ();
}
else
{
algKey.setConstant (is.modelicaValue ());
}
algKey.setLow (1);
algKey.setHi (1);
algKey.setFactor (0);
}
if (type == DEP_ALGEBRAIC_DEF)
{
derivativeDeps->insert (algKey, DEP_ALGEBRAIC);
}
_addAlgebriacDeps (algKey, (*algEq), equationIndex,
derivativeIndex, derivativeDeps, states,
discretes, variableCh, algValue);
}
}
}
}
void
MMO_Expression_::_addAlgebriacDeps (Index algIndex, MMO_Equation equation,
Index equationIndex, Index derivativeIndex,
Dependencies derivativeDeps,
map<Index, Index> *states,
map<Index, Index> *discretes,
Index variableChange, int value)
{
stringstream buffer;
string indent;
string variableString = equation->lhs ().variable (algIndex, "i");
Dependencies deps = equation->exp ()->deps ();
map<Index, Index> &stateVariables = *states;
Index eqIndex = equationIndex;
for (Index *idx = deps->begin (DEP_STATE); !deps->end (DEP_STATE);
idx = deps->next (DEP_STATE))
{
if (stateVariables.find (*idx) == stateVariables.end ()
|| equation->lhs ().variableChange (algIndex))
{
Index stateIndex = Index (
idx->applyVariableChange (
equation->lhs ().variableIndex (algIndex)));
stateVariables[*idx] = *idx;
eqIndex.setOffset (_equationIndex++);
if (idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[i];
derivativeDeps->insert (stateIndex, eqIndex, DEP_ALGEBRAIC_STATE);
}
else if (!idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[N];
derivativeDeps->insert (stateIndex, eqIndex, DEP_ALGEBRAIC_STATE);
}
else if (idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[i];
if (derivativeIndex.hasRange ())
{
Index newEqIndex = eqIndex;
newEqIndex.setRange ();
newEqIndex.setLow (derivativeIndex.low ());
newEqIndex.setHi (derivativeIndex.hi ());
derivativeDeps->insert (
stateIndex.indexValue (
stateIndex.value (algIndex.constant ())),
newEqIndex, DEP_ALGEBRAIC_STATE);
}
else
{
derivativeDeps->insert (
stateIndex.indexValue (
stateIndex.value (algIndex.constant ())),
eqIndex, DEP_ALGEBRAIC_STATE);
}
}
else if (!idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[N];
if (derivativeIndex.hasRange () && !algIndex.isArray())
{
Index newEqIndex = eqIndex;
newEqIndex.setRange ();
newEqIndex.setLow (derivativeIndex.low ());
newEqIndex.setHi (derivativeIndex.hi ());
derivativeDeps->insert (stateIndex,
newEqIndex, DEP_ALGEBRAIC_STATE);
}
else
{
derivativeDeps->insert (stateIndex, eqIndex, DEP_ALGEBRAIC_STATE);
}
}
}
}
map<Index, Index> &discreteVariables = *discretes;
for (Index *idx = deps->begin (DEP_DISCRETE); !deps->end (DEP_DISCRETE); idx =
deps->next (DEP_DISCRETE))
{
if (discreteVariables.find (*idx) == discreteVariables.end ()
|| equation->lhs ().variableChange (algIndex))
{
Index discreteIndex = Index (
idx->applyVariableChange (
equation->lhs ().variableIndex (algIndex)));
discreteVariables[*idx] = *idx;
eqIndex.setOffset (_equationIndex++);
if (idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[i];
derivativeDeps->insert (discreteIndex, eqIndex,
DEP_ALGEBRAIC_DISCRETE);
}
else if (!idx->hasRange () && eqIndex.hasRange ())
{
// X[i] = B[N];
derivativeDeps->insert (discreteIndex, eqIndex,
DEP_ALGEBRAIC_DISCRETE);
}
else if (idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[i];
derivativeDeps->insert (
discreteIndex.indexValue (
discreteIndex.value (discreteIndex.constant ())),
eqIndex, DEP_ALGEBRAIC_DISCRETE);
}
else if (!idx->hasRange () && !eqIndex.hasRange ())
{
// X[N] = B[N];
derivativeDeps->insert (discreteIndex, eqIndex,
DEP_ALGEBRAIC_DISCRETE);
}
}
}
for (Index *idx = deps->begin (DEP_STATE_VECTOR);
!deps->end (DEP_STATE_VECTOR); idx = deps->next (DEP_STATE_VECTOR))
{
derivativeDeps->insert (*idx, DEP_STATE_VECTOR);
}
for (Index *idx = deps->begin (DEP_DISCRETE_VECTOR);
!deps->end (DEP_DISCRETE_VECTOR); idx = deps->next (DEP_DISCRETE_VECTOR))
{
derivativeDeps->insert (*idx, DEP_DISCRETE_VECTOR);
}
_traverseAlgebraics (deps, derivativeIndex, derivativeDeps, states, discretes,
variableChange, DEP_ALGEBRAIC_DEF, value);
_traverseAlgebraics (deps, derivativeIndex, derivativeDeps, states, discretes,
variableChange, DEP_ALGEBRAIC_VECTOR_DEF, value);
}
