void dynNetwork::readParameter ( string parameterString, string fileName )
{
cout << "Reading from:" << fileName << endl;
cyclicStream *in = new cyclicStream ( fileName );
boost::function<baseType () > r = boost::bind ( &cyclicStream::readBaseType,in );
networkElementType theNodeType = params<baseType>::getNodeTypeFromString ( parameterString );
cout << "Reading parameter \"" << parameterString << "\" for NodeType " << theNodeType << endl;
nodeList vl;
nodeIterator vi;
verticesMatching (vl, theNodeType);
for (vi = vl.begin();vi!= vl.end(); vi ++)
{
// START Änderung by hdickten 08.06.2009
// if (theNodes[i]->getNodeInfo().theNodeType == theNodeType)
// if ((theNodes[i]->getNodeInfo().theNodeKind & _dynNode_) != 0) // langsam, bin zu faul
// ENDE Änderung
#ifdef debug
cout << "Writing parameter \"" << parameterString << "\"["<< i <<"]=" << r << endl;
#endif
// Änderung 10.06.2009: Pointertyp geändert (HD) -> funktioniert nun
//((params<baseType>*)theNodes[i])->randomizeParameter(parameterString, theNodeType, r);
( ( dynamic_cast<dynNode*>( node::theNodes[*vi] )->randomizeParameter ( parameterString, theNodeType, r )));
}
delete in;
}
void network::verticesMatching(nodeList &res, node *n)
{
// TODO bug ?
// throw "stub verticesSimilar";
if (n == network::stdNode)
verticesMatching (res, _dynNode_);
else
{
networkElementType nodeType= n->getNodeInfo().theNodeType;
nodeIterator vi;
for(vi = theNodes.begin(); vi != theNodes.end(); vi++) // if n has standard parameter -> match if node type is equal
{
dynNode *x = (dynNode*)node::theNodes[*vi];
if ( ((dynNode*) n)->isStandard())
{
if (node::theNodes[*vi]->getNodeInfo().theNodeType == nodeType)
res.insert(*vi);
}
else // if n has specified parameter -> match after node type and parameters
{
if ((node::theNodes[*vi]->getNodeInfo().theNodeType == nodeType) &&
(( x-> row == ((dynNode*)n)-> params<baseType>::row) || ( x->compareSheets( x-> row , ((dynNode*)n)-> params<baseType>::row) ))) // match nodes, if their parameter are the same.
res.insert(*vi);
}
}
}
}
void createNetwork::addRandomEdgesDegreeDistributionDirected ( function <double () > r , edgeBlueprint *l)
{
nodeList vl;
verticesMatching (vl,_dynNode_);
nodeIterator it;
vector <nodeDescriptor> nodeStubs;
unsigned int numberLinks;
for (it = vl.begin(); it != vl.end(); it++)
{
numberLinks = r();
for (unsigned int i = 0; i < numberLinks ; i++)
nodeStubs.push_back(*it);
}
// shuffle the stub-list with Fisher-Yates
unsigned int j;
nodeDescriptor swap;
for (unsigned int i = nodeStubs.size()-1; i > 1 ; i = i - 1)
{
j = gslNoise::getUniformInt (0, i);
swap = nodeStubs [j];
nodeStubs [j] = nodeStubs[i];
nodeStubs [i] = swap;
}
for (unsigned int i = 0 ; i < nodeStubs.size() / 2; i++ )
link ( nodeStubs[2 * i], nodeStubs [ 2 * i + 1], l);
}
void statisticsNetwork::closenessCentrality ( string filename ) // funktioniert nur für komplett verbundene Netzwerke korrekt
{
nodeIterator vi;
network::nodeList vl;
verticesMatching(vl, _dynNode_);
unsigned int i;
double distSum;
vector <double> CC (vl.size());
vector<baseType> distance;
distance.resize(vl.size());
for( vi=vl.begin() ; vi!=vl.end() ; vi++ )
{
dijkstra( distance, vl, *vi );
distSum=0;
for ( i=0 ; i<vl.size() ; i++ )
distSum = distSum + distance[i];
CC[ *vi -*vl.begin() ] = (vl.size()-1) / distSum ;
}
ofstream out(filename.c_str());
for( i=0 ; i<vl.size() ; i++)
out << CC[i] << endl ;
}
void network::edgesBetween(list< edgeDescriptor > &res, nodeKind sourceNodeKind, nodeKind targetNodeKind)
{
nodeIterator va;
nodeList vl;
verticesMatching (vl, sourceNodeKind);
for (va = vl.begin(); va != vl.end(); va++)
edgesBetween(res, node::theNodes[*va]->getNumber(), targetNodeKind);
}
void network::edgesBetween(edgeList &res, networkElementType sourceNodeType, networkElementType targetNodeType)
{
nodeList vl;
verticesMatching (vl, sourceNodeType);
for (nodeIterator va = vl.begin(); va != vl.end(); va++)
edgesBetween(res, node::theNodes[*va]->getNumber(), sourceNodeType);
}
void network::clean ( )
{
evolveList.clear();
upkeepList.clear();
enterList.clear();
dynNode *nod;
nodeList vl;
nodeIterator it;
verticesMatching(vl,_dynNode_);
for (it = vl.begin(); it != vl.end(); it ++)
{
nod = ( dynamic_cast<dynNode*>( node::theNodes[*it]));
nod->clean ( );
if ( nod->timeEvolution() )
evolveList.push_back ( nod );
if ( nod->requiresUpkeep())
upkeepList.push_back (nod);
}
set <int> streamNumbers;
streamOutNode *sn;
nodeList vl2;
verticesMatching(vl2,_outNode_);
for (it =vl2.begin(); it != vl2.end(); ++it)
{
sn = dynamic_cast<streamOutNode*> (node::theNodes[*it]);
if (sn && !streamNumbers.count(sn->localStreamNumber))
{
enterList.push_back(sn);
streamNumbers.insert(sn->localStreamNumber);
}
}
}
void createNetwork::normalizeInputs (baseType r)
{
nodeIterator it;
nodeList dynNodes;
verticesMatching(dynNodes, _dynNode_);
for (it = dynNodes.begin(); it != dynNodes.end(); ++it)
dynNode::lookUp(*it)->normalizeInWeightSum(r);
network::clean();
}
void createNetwork::normalizeInputs (baseType r)
{
nodeIterator it;
nodeList dynNodes;
verticesMatching(dynNodes, _dynNode_);
for (it = dynNodes.begin(); it != dynNodes.end(); it++)
nodeBlueprint::theNodes[*it]->normalizeInWeightSum(r);
network::clean();
}
void dynNetwork::realignAtEventSignature (string inputFilename, string outputFilename, networkElementType nt, baseType epsilon, unsigned int eventNumber, unsigned int skip)
{
nodeList * vl = new nodeList();
verticesMatching(*vl, nt);
realign *r = new realign ( inputFilename, outputFilename, vl, epsilon, skip);
insertVisiterAtSignature( bind(&realign::realignPeriodically, r), eventNumber);
}
void dynNetwork::realignWhenDistant (string inputFilename, string outputFilename, networkElementType nt, baseType epsilon, unsigned int eventNumber, unsigned int multi)
{
nodeList * vl = new nodeList();
verticesMatching(*vl, nt);
realign *r = new realign ( inputFilename, outputFilename, vl, epsilon, multi);
insertVisiter( bind(&realign::realignWhenDistant, r), eventNumber);
// insertVisiter( bind(&dynNetwork::snapshot, this), eventNumber);
}
void network::addEdges (nodeKind sourceNodeKind, nodeDescriptor target, edgeBlueprint *l)
{
nodeIterator it;
nodeList vl;
verticesMatching(vl,sourceNodeKind);
for (it = vl.begin(); it != vl.end(); it++)
addEdge(*it,target, l);
}
void statisticsNetwork::degreeCentrality( string filename )
{
network::nodeIterator it;
network::nodeList vl;
verticesMatching(vl, _dynNode_);
ofstream out (filename.c_str() );
for( it = vl.begin(); it != vl.end(); it++)
out << node::theNodes[*it]->degree() <<endl;
out.close();
}
void network::addEdges (nodeDescriptor source, int targetNodeType, edgeBlueprint *l)
{
nodeIterator it;
nodeList vl;
verticesMatching(vl,targetNodeType);
for (it = vl.begin(); it != vl.end(); it++)
addEdge(source, *it, l);
}
void dynNetwork::randomizeParameter ( string s,function<baseType () > r )
{
networkElementType n = params<baseType>::getNodeTypeFromString ( s );
nodeIterator it;
nodeList vl;
verticesMatching (vl, n);
for (it = vl.begin();it != vl.end(); it ++)
( ( dynamic_cast<dynNode*>( node::theNodes[*it] )->randomizeParameter ( s,n,r )));
}
void network::removeNodes (nodeBlueprint *n)
{
nodeList vl;
verticesMatching (vl, n);
nodeIterator vi;
for (vi = vl.begin(); vi != vl.end(); vi++ )
{
delete node::theNodes[*vi];
node::theNodes[*vi] = 0; // remove from lookup table in node
theNodes.erase (*vi); // remove from the network
}
}
void network::remove ( nodeKind theNodeKind )
{
nodeList vl;
verticesMatching (vl, theNodeKind);
nodeIterator vi;
for (vi = vl.begin(); vi != vl.end(); vi++ )
{
delete dynNode::lookUp(*vi);
// dynNode::lookUp(*vi) = 0; // remove from lookup table in node
theNodes.erase (*vi); // remove from the network
}
}
bool statisticsNetwork::isConnected()
{
if( isDirected() )
{
cout << "Warning! This network is directed. This function cannout make a statement about connectivity.";
cout << "\n";
return false;
}
network::nodeList vl;
network::nodeIterator vi;
verticesMatching(vl, _dynNode_ );
unsigned int n,i;
n = vl.size();
vector<unsigned int> connect;
connect.resize(n);
nodeDescriptor v,t;
for (vi=vl.begin(); vi!=vl.end(); vi++)
{
connect[0]=1;
for( i=1; i<n; i++)
{
connect[i]=0;
}
vector<unsigned int> Sub;
Sub.push_back(*vi+1); // Knotennummern um +1 verschoben um nicht 0 zu pushen
for( i=0; i<Sub.size(); i++)
{
v = Sub[i]-1;
for( node::edgeDescriptor l=0; l<node::theNodes[v]->degree() ; l++)
{
t = node::theNodes[v]->getTarget(l)->getNumber();
if (connect[ t - *vl.begin()] == 0)
{
connect[ t - *vl.begin() ] = 1;
Sub.push_back(t+1);
}
}
}
if( n!=Sub.size() )
return false;
}
return true;
}
void statisticsNetwork::saveAdjacencyList(string fileName)
{
ofstream out(fileName.c_str());
network::nodeIterator it;
network::nodeList vl;
verticesMatching(vl, _dynNode_);
out << vl.size() << "\n";
for( it = vl.begin(); it != vl.end(); it++)
for( node::edgeDescriptor l=0; l<node::theNodes[*it]->degree() ;l++)
if (isInsideNetwork(getTarget (*it, l) ))
out << *it <<' '<< node::theNodes[*it]->getTarget(l)->getNumber() <<' '<< node::theNodes[*it]->getWeight(l) <<"\n";
// VERÄNDERT
//
// node::edgeDescriptor ea, ee;
// for ( it = theNodes.begin() ; it != theNodes.end() ; it++)
// {
//
// ea = 0;
// ee = node::theNodes[*it] ->degree();
//
// // for (; ea != ee; ea++)
//// {
// // Ausgabe der Nodenummer:
// out << *it << " ";
//
// //Ausgabe der jeweiligen Edge
// node::theNodes[*it]->printEdgeStatistics(out, network::edgeVerbosity());
// out << endl;
// // ENDE
//// out << endl;
//
// /* VERALTET
// out << i << " " <<(*ea)->target->getNumber() << " ";
// if ((*ea)->getEdgeInfo().theEdgeKind & _weighted_)
// out << ((weightedEdge*)(*ea))->getWeight() << "\n";
// else
// out << "\n";
// */
//// }
// }
out.close();
}
void statisticsNetwork::saveAdjacencyMatrix (string fileName)
{
nodeIterator vi;
nodeIterator vj;
nodeList vl;
verticesMatching(vl, _dynNode_);
ofstream out(fileName.c_str());
for (vi = vl.begin(); vi != vl.end(); vi++)
{
for (vj = vl.begin(); vj != vl.end(); vj++)
{
out << linkStrength(*vi, *vj) << " ";
}
out << "\n";
}
}
void createNetwork::normalizeOutputs (baseType r)
{
nodeIterator it;
nodeList dynNodes;
verticesMatching(dynNodes, _dynNode_);
unsigned int degree;
for (it = dynNodes.begin(); it != dynNodes.end(); it++)
{
degree = nodeBlueprint::theNodes[*it]->degree();
for (unsigned int i = 0 ; i < nodeBlueprint::theNodes[*it]->degree(); i ++)
{
nodeBlueprint::theNodes[*it]->setWeight (i, r / degree);
}
}
}
void dynNetwork::randomizeStatesVec ( nodeBlueprint *n ,vector <boost::function<baseType () > > r )
{
if (r.size() == 1)
while (r.size() < n->dimension())
r.push_back(r[0]);
if (r.size() != n->dimension())
throw "wrong dimension for randomizeStates!";
nodeList vl;
nodeIterator it;
verticesMatching(vl,n);
for ( it = vl.begin(); it != vl.end(); it ++)
dynamic_cast<dynNode*>( node::theNodes[*it] ) ->randomizeState ( r );
}
void createNetwork::normalizeOutputs (baseType r)
{
nodeIterator it;
nodeList dynNodes;
verticesMatching(dynNodes, _dynNode_);
unsigned int degree;
for (it = dynNodes.begin(); it != dynNodes.end(); ++it)
{
degree = dynNode::lookUp(*it)->degree();
for (unsigned int i = 0 ; i < dynNode::lookUp(*it)->degree(); i ++)
{
dynNode::lookUp(*it)->setWeight (i, r / degree);
}
}
}
baseType statisticsNetwork::meanPathLength() // funktioniert nur für komplett verbundene Netzwerke korrekt
{
network::nodeIterator vi;
network::nodeList vl;
verticesMatching(vl, _dynNode_);
unsigned int i;
double distSum=0;
vector<baseType> distance;
distance.resize(vl.size());
for( vi=vl.begin() ; vi!=vl.end() ; vi++ )
{
dijkstra( distance, vl, *vi);
for( i=0 ; i< vl.size() ; i++)
distSum = distSum + distance[i];
}
return distSum / (vl.size()-1) / vl.size();
}
void network::clean ( )
{
evolveList.clear();
upkeepList.clear();
dynNode *nod;
nodeList vl;
nodeIterator it;
verticesMatching(vl,_dynNode_);
for (it = vl.begin(); it != vl.end(); it ++)
{
nod = ( dynamic_cast<dynNode*>( node::theNodes[*it]));
nod->clean ( );
if ( nod->timeEvolution() )
evolveList.push_back ( nod );
if ( nod->requiresUpkeep())
upkeepList.push_back (nod);
}
}
void dynNetwork::noiseToStatesVec ( nodeBlueprint *n ,vector <boost::function<baseType () > > r )
{
if (r.size() == 1)
while (r.size() < n->dimension())
r.push_back(r[0]);
if (r.size() != n->dimension())
throw "wrong dimension for randomizeStates!";
nodeList vl;
verticesMatching (vl, n);
nodeIterator vi;
vector <baseType> argList(n->dimension());
for (vi = vl.begin();vi != vl.end(); vi++ )
{
for (unsigned int i = 0; i < n->dimension() ; i++)
{
argList[i] = getState (*vi, i) + r[i]();
}
setInitialConditionVec (*vi, argList);
}
}
bool network::isDirected()
{
nodeIterator vi, vj;
network::nodeList vl;
verticesMatching(vl, _dynNode_ );
bool res = false;
for(vi=vl.begin(); vi!=vl.end(); vi++)
{
for(vj=vl.begin(); vj!=vi; vj++)
{
if( network::linkStrength(*vi,*vj) != network::linkStrength(*vj,*vi) )
{
res = true;
break;
}
}
}
return res;
}
bool network::isGraph()
{
nodeList vl;
nodeIterator vi;
verticesMatching (vl, _dynNode_);
edgeList el;
for (vi = vl.begin(); vi != vl.end(); vi++)
{
edgesBetween (el, *vi, _dynNode_);
// el.sort ([&](edgeDescriptor l, edgeDescriptor r) -> bool { return getTarget(l) < getTarget (r); } )
el.sort (compareByTargets);
edgeIterator ePrev = el.begin();
if (getTarget (*ePrev) == getSource(*ePrev))
return 0;
edgeIterator eSucc = el.begin();
eSucc ++;
for (; eSucc != el.end(); ePrev++, eSucc++)
{
if ((getTarget(*ePrev) == getTarget (*eSucc)) ||
(getTarget(*eSucc) == getSource (*eSucc)))
return 0;
}
el.clear();
}
return 1;
}
unsigned int network::numberVertices (nodeBlueprint * n )
{
nodeList vl;
verticesMatching (vl,n);
return vl.size();
}
void statisticsNetwork::betweennessCentrality( string filename )
// uses the algorithm provided by U. Brandes in "A faster algorithm for betweenness Centrality",
// J. Math. Sociol., 25:163-177, 2001
{
network::nodeIterator ia;
nodeList vl;
verticesMatching(vl, _dynNode_);
unsigned int t;
nodeDescriptor v, w;
double d;
vector <double> CB (vl.size()); // array CB[v] für alle v in n
for ( t=0 ; t<vl.size() ; t++)
CB[t]=0.0;
list<int> S;
vector < list<int> > P (vl.size()); // listen P[w] für jedes w aus n
vector <double> sigma (vl.size()); // array sigma der Länge vl.size()
dijkstraCompare dC;
relaxed_heap < nodeDescriptor, dijkstraCompare > Q (vl.size()+3, dC); // queue Q
dC.weightMap.resize(vl.size());
vector <double> delta (vl.size());// array delta der Länge vl.size()
for ( ia=vl.begin() ; ia!=vl.end() ; ia++ )
{
while(!S.empty()) // S leeren
S.pop_back();
for ( t=0 ; t<vl.size() ; t++) // alle P[t] leeren
while( !P[t].empty() )
P[t].pop_back();
for ( t=0 ; t<vl.size() ; t++ )
sigma[t]=0;
sigma[*ia -*vl.begin()]=1;
for ( t=0 ; t<vl.size() ; t++ )
dC.weightMap[t]=numeric_limits<baseType>::infinity();
dC.weightMap[*ia -*vl.begin()]=0;
while(!Q.empty()) // Q leeren
Q.pop();
Q.push( *ia+1 -*vl.begin() ); // +1 um nicht 0 zu pushen, daher sind die Knotennrn in Q um 1 verschoben
while(!Q.empty())
{
v = Q.top()-1 +*vl.begin();
Q.pop();
S.push_back( v+1 -*vl.begin() );
for ( node::edgeDescriptor l=0 ; l<node::theNodes[v]->degree() ; l++ ) //weightMap aktualisieren
{
w = node::theNodes[v]->getTarget(l)->getNumber(); // alle Nachbarn w von v
d = 1/( node::theNodes[v]->getWeight(l) ); // d misst die Entfernung zwischen w und v
if ( dC.weightMap[w -*vl.begin()] == numeric_limits<baseType>::infinity() ) // zum ersten Mal entdeckt?
{
dC.weightMap[w -*vl.begin()] = dC.weightMap[v -*vl.begin()] + d;
Q.push(w+1 -*vl.begin());
}
else if ( dC.weightMap[w -*vl.begin()] > (dC.weightMap[v -*vl.begin()] + d) && dC.weightMap[w -*vl.begin()] < numeric_limits<baseType>::infinity() )
{
dC.weightMap[w -*vl.begin()] = dC.weightMap[v -*vl.begin()] + d;
Q.update(w+1 -*vl.begin());
}
}
for ( node::edgeDescriptor l=0 ; l<node::theNodes[v]->degree() ; l++ ) // Prezedessoren checken
{
w = node::theNodes[v]->getTarget(l)->getNumber(); // alle Nachbarn w von v
d = 1/( node::theNodes[v]->getWeight(l) ); // d misst die Entfernung zw w und v
// hier soll auf gleichheit kontrolliert werden...
if ( dC.weightMap[v -*vl.begin()] == dC.weightMap[w -*vl.begin()] + d ) // kürzester Weg nach v via w?
{
sigma[v -*vl.begin()] = sigma[v -*vl.begin()] + sigma[w -*vl.begin()];
P[v -*vl.begin()].push_back(w+1 -*vl.begin()); // ggf w Prezedessor von v
}
// Ähnlichkeitsvergleich für d!= integer: relative Abweicheichung
else if ( dC.weightMap[v -*vl.begin()] > dC.weightMap[w -*vl.begin()] )
{
double relativeError = 0.001;
if( fabs(dC.weightMap[v -*vl.begin()] - dC.weightMap[w -*vl.begin()] - d) / dC.weightMap[v -*vl.begin()] < relativeError )
{
sigma[v -*vl.begin()] = sigma[v -*vl.begin()] + sigma[w -*vl.begin()];
P[v -*vl.begin()].push_back(w+1 -*vl.begin()); // ggf w Prezedessor von v
}
}
}
}
for ( t=0 ; t<vl.size() ; t++ )
delta[t]=0;
while(!S.empty())
{
w = S.back() -1;
S.pop_back();
while ( !P[w].empty() )
{
v = P[w].back() -1;
P[w].pop_back();
delta[v] = delta[v] + (1+delta[w])*sigma[v]/sigma[w];
}
if ( w != *ia -*vl.begin())
CB[w] = CB[w] + delta[w];
}
}
for( t=0 ; t<vl.size() ; t++ ) // Normierung auf [0;1]
CB[t] = CB[t] / vl.size() / (vl.size()-1);
ofstream out(filename.c_str());
for( t=0 ; t<vl.size() ; t++ ){
out << CB[t] << endl ; }
out.close();
}
