///////////////////////////////////////////////////////////////////////////////
// Triad counting methods
void TempMotifCounter::Count3TEdgeTriadsNaive(double delta, Counter3D& counts) {
TIntV Us, Vs, Ws;
GetAllStaticTriangles(Us, Vs, Ws);
counts = Counter3D(2, 2, 2);
#pragma omp parallel for schedule(dynamic)
for (int i = 0; i < Us.Len(); i++) {
int u = Us[i];
int v = Vs[i];
int w = Ws[i];
// Gather all edges in triangle (u, v, w)
int uv = 0, vu = 1, uw = 2, wu = 3, vw = 4, wv = 5;
TVec<TIntPair> combined;
AddStarEdges(combined, u, v, uv);
AddStarEdges(combined, v, u, vu);
AddStarEdges(combined, u, w, uw);
AddStarEdges(combined, w, u, wu);
AddStarEdges(combined, v, w, vw);
AddStarEdges(combined, w, v, wv);
// Get the counts for this triangle
combined.Sort();
ThreeTEdgeMotifCounter counter(6);
TIntV edge_id(combined.Len());
TIntV timestamps(combined.Len());
for (int k = 0; k < combined.Len(); k++) {
edge_id[k] = combined[k].Dat;
timestamps[k] = combined[k].Key;
}
Counter3D local;
counter.Count(edge_id, timestamps, delta, local);
// Update the global counter with the various symmetries
#pragma omp critical
{
// i --> j, k --> j, i --> k
counts(0, 0, 0) += local(uv, wv, uw) + local(vu, wu, vw) + local(uw, vw, uv)
+ local(wu, vu, wv) + local(vw, uw, vu) + local(wv, uv, wu);
// i --> j, k --> j, k --> i
counts(0, 0, 1) += local(uv, wv, wu) + local(vu, wu, wv) + local(uw, vw, vu)
+ local(wu, vu, vw) + local(vw, uw, uv) + local(wv, uv, uw);
// i --> j, j --> k, i --> k
counts(0, 1, 0) += local(uv, vw, uw) + local(vu, uw, vw) + local(uw, wv, uv)
+ local(wu, uv, wv) + local(vw, wu, vu) + local(wv, vu, wu);
// i --> j, j --> k, k --> i
counts(0, 1, 1) += local(uv, vw, wu) + local(vu, uw, wv) + local(uw, wv, vu)
+ local(wu, uv, vw) + local(vw, wu, uv) + local(wv, vu, uw);
// i --> j, k --> i, j --> k
counts(1, 0, 0) += local(uv, wu, vw) + local(vu, wv, uw) + local(uw, vu, wv)
+ local(wu, vw, uv) + local(vw, uv, wu) + local(wv, uw, vu);
// i --> j, k --> i, k --> j
counts(1, 0, 1) += local(uv, wu, wv) + local(vu, wv, wu) + local(uw, vu, vw)
+ local(wu, vw, vu) + local(vw, uv, uw) + local(wv, uw, uv);
// i --> j, i --> k, j --> k
counts(1, 1, 0) += local(uv, uw, vw) + local(vu, vw, uw) + local(uw, uv, wv)
+ local(wu, wv, uv) + local(vw, vu, wu) + local(wv, wu, vu);
// i --> j, i --> k, k --> j
counts(1, 1, 1) += local(uv, uw, wv) + local(vu, vw, wu) + local(uw, uv, vw)
+ local(wu, wv, vu) + local(vw, vu, uw) + local(wv, wu, uv);
}
}
}
void TempMotifCounter::Count3TEdge3NodeStarsNaive(
double delta, Counter3D& pre_counts, Counter3D& pos_counts,
Counter3D& mid_counts) {
TIntV centers;
GetAllNodes(centers);
pre_counts = Counter3D(2, 2, 2);
pos_counts = Counter3D(2, 2, 2);
mid_counts = Counter3D(2, 2, 2);
// Get counts for each node as the center
#pragma omp parallel for schedule(dynamic)
for (int c = 0; c < centers.Len(); c++) {
// Gather all adjacent events
int center = centers[c];
TIntV nbrs;
GetAllNeighbors(center, nbrs);
for (int i = 0; i < nbrs.Len(); i++) {
for (int j = i + 1; j < nbrs.Len(); j++) {
int nbr1 = nbrs[i];
int nbr2 = nbrs[j];
TVec<TIntPair> combined;
AddStarEdges(combined, center, nbr1, 0);
AddStarEdges(combined, nbr1, center, 1);
AddStarEdges(combined, center, nbr2, 2);
AddStarEdges(combined, nbr2, center, 3);
combined.Sort();
ThreeTEdgeMotifCounter counter(4);
TIntV edge_id(combined.Len());
TIntV timestamps(combined.Len());
for (int k = 0; k < combined.Len(); k++) {
edge_id[k] = combined[k].Dat;
timestamps[k] = combined[k].Key;
}
Counter3D local;
counter.Count(edge_id, timestamps, delta, local);
#pragma omp critical
{ // Update with local counts
for (int dir1 = 0; dir1 < 2; ++dir1) {
for (int dir2 = 0; dir2 < 2; ++dir2) {
for (int dir3 = 0; dir3 < 2; ++dir3) {
pre_counts(dir1, dir2, dir3) +=
local(dir1, dir2, dir3 + 2) + local(dir1 + 2, dir2 + 2, dir3);
pos_counts(dir1, dir2, dir3) +=
local(dir1, dir2 + 2, dir3 + 2) + local(dir1 + 2, dir2, dir3);
mid_counts(dir1, dir2, dir3) +=
local(dir1, dir2 + 2, dir3) + local(dir1 + 2, dir2, dir3 + 2);
}
}
}
}
}
}
}
}
bool getTimestamp(string dir_timestamp, unsigned int entry_number, ros::Time &stamp)
{
string str_support = (fs::path(dir_timestamp) / fs::path("timestamps.txt")).string();
ifstream timestamps(str_support.c_str());
if (!timestamps.is_open())
{
ROS_ERROR_STREAM("Fail to open " << timestamps);
return true;
}
timestamps.seekg(30*entry_number);
getline(timestamps,str_support);
stamp = parseTime(str_support);
return false;
}
void TempMotifCounter::Count3TEdge2Node(int u, int v, double delta,
Counter3D& counts) {
// Sort event list by time
TVec<TIntPair> combined;
AddStarEdges(combined, u, v, 0);
AddStarEdges(combined, v, u, 1);
combined.Sort();
// Get the counts
ThreeTEdgeMotifCounter counter(2);
TIntV in_out(combined.Len());
TIntV timestamps(combined.Len());
for (int k = 0; k < combined.Len(); k++) {
in_out[k] = combined[k].Dat;
timestamps[k] = combined[k].Key;
}
counter.Count(in_out, timestamps, delta, counts);
}
bool getTimestamp(string dir_timestamp,vector<ros::Time> ×)
{
string str_support;
str_support = (fs::path(dir_timestamp) / "times.txt").string();
ifstream timestamps(str_support.c_str());
double stamp;
if (!timestamps.is_open())
{
ROS_ERROR_STREAM("Fail to open times.txt :" << timestamps);
return false;
}
while(timestamps >> stamp) {
ros::Time t(stamp);
times.push_back(t);
}
timestamps.close();
return true;
}
size_t JsonWriteRichPresenceObj(char* dest,
size_t maxLen,
int nonce,
int pid,
const DiscordRichPresence* presence)
{
JsonWriter writer(dest, maxLen);
{
WriteObject top(writer);
JsonWriteNonce(writer, nonce);
WriteKey(writer, "cmd");
writer.String("SET_ACTIVITY");
{
WriteObject args(writer, "args");
WriteKey(writer, "pid");
writer.Int(pid);
if (presence != nullptr) {
WriteObject activity(writer, "activity");
WriteOptionalString(writer, "state", presence->state);
WriteOptionalString(writer, "details", presence->details);
if (presence->startTimestamp || presence->endTimestamp) {
WriteObject timestamps(writer, "timestamps");
if (presence->startTimestamp) {
WriteKey(writer, "start");
writer.Int64(presence->startTimestamp);
}
if (presence->endTimestamp) {
WriteKey(writer, "end");
writer.Int64(presence->endTimestamp);
}
}
if ((presence->largeImageKey && presence->largeImageKey[0]) ||
(presence->largeImageText && presence->largeImageText[0]) ||
(presence->smallImageKey && presence->smallImageKey[0]) ||
(presence->smallImageText && presence->smallImageText[0])) {
WriteObject assets(writer, "assets");
WriteOptionalString(writer, "large_image", presence->largeImageKey);
WriteOptionalString(writer, "large_text", presence->largeImageText);
WriteOptionalString(writer, "small_image", presence->smallImageKey);
WriteOptionalString(writer, "small_text", presence->smallImageText);
}
if ((presence->partyId && presence->partyId[0]) || presence->partySize ||
presence->partyMax) {
WriteObject party(writer, "party");
WriteOptionalString(writer, "id", presence->partyId);
if (presence->partySize && presence->partyMax) {
WriteArray size(writer, "size");
writer.Int(presence->partySize);
writer.Int(presence->partyMax);
}
}
if ((presence->matchSecret && presence->matchSecret[0]) ||
(presence->joinSecret && presence->joinSecret[0]) ||
(presence->spectateSecret && presence->spectateSecret[0])) {
WriteObject secrets(writer, "secrets");
WriteOptionalString(writer, "match", presence->matchSecret);
WriteOptionalString(writer, "join", presence->joinSecret);
WriteOptionalString(writer, "spectate", presence->spectateSecret);
}
writer.Key("instance");
writer.Bool(presence->instance != 0);
}
}
}
return writer.Size();
}
void TempMotifCounter::Count3TEdgeTriads(double delta, Counter3D& counts) {
counts = Counter3D(2, 2, 2);
// Get the counts on each undirected edge
TVec< THash<TInt, TInt> > edge_counts(static_graph_->GetMxNId());
TVec< THash<TInt, TIntV> > assignments(static_graph_->GetMxNId());
for (TNGraph::TEdgeI it = static_graph_->BegEI();
it < static_graph_->EndEI(); it++) {
int src = it.GetSrcNId();
int dst = it.GetDstNId();
int min_node = MIN(src, dst);
int max_node = MAX(src, dst);
edge_counts[min_node](max_node) += temporal_data_[src](dst).Len();
assignments[min_node](max_node) = TIntV();
}
// Assign triangles to the edge with the most events
TIntV Us, Vs, Ws;
GetAllStaticTriangles(Us, Vs, Ws);
#pragma omp parallel for schedule(dynamic)
for (int i = 0; i < Us.Len(); i++) {
int u = Us[i];
int v = Vs[i];
int w = Ws[i];
int counts_uv = edge_counts[MIN(u, v)].GetDat(MAX(u, v));
int counts_uw = edge_counts[MIN(u, w)].GetDat(MAX(u, w));
int counts_vw = edge_counts[MIN(v, w)].GetDat(MAX(v, w));
if (counts_uv >= MAX(counts_uw, counts_vw)) {
#pragma omp critical
{
TIntV& assignment = assignments[MIN(u, v)].GetDat(MAX(u, v));
assignment.Add(w);
}
} else if (counts_uw >= MAX(counts_uv, counts_vw)) {
#pragma omp critical
{
TIntV& assignment = assignments[MIN(u, w)].GetDat(MAX(u, w));
assignment.Add(v);
}
} else if (counts_vw >= MAX(counts_uv, counts_uw)) {
#pragma omp critical
{
TIntV& assignment = assignments[MIN(v, w)].GetDat(MAX(v, w));
assignment.Add(u);
}
}
}
TVec<TIntPair> all_edges;
TIntV all_nodes;
GetAllNodes(all_nodes);
for (int node_id = 0; node_id < all_nodes.Len(); node_id++) {
int u = all_nodes[node_id];
TIntV nbrs;
GetAllNeighbors(u, nbrs);
for (int nbr_id = 0; nbr_id < nbrs.Len(); nbr_id++) {
int v = nbrs[nbr_id];
if (assignments[u].IsKey(v) && assignments[u].GetDat(v).Len() > 0) {
all_edges.Add(TIntPair(u, v));
}
}
}
// Count triangles on edges with the assigned neighbors
#pragma omp parallel for schedule(dynamic)
for (int edge_id = 0; edge_id < all_edges.Len(); edge_id++) {
TIntPair edge = all_edges[edge_id];
int u = edge.Key;
int v = edge.Dat;
// Continue if no assignment
if (!assignments[u].IsKey(v)) { continue; }
TIntV& uv_assignment = assignments[u].GetDat(v);
// Continue if no data
if (uv_assignment.Len() == 0) { continue; }
// Get all events on (u, v)
TVec<TriadEdgeData> events;
TVec<TIntPair> ts_indices;
int index = 0;
int nbr_index = 0;
// Assign indices from 0, 1, ..., num_nbrs + 2
AddTriadEdgeData(events, ts_indices, index, u, v, nbr_index, 0, 1);
nbr_index++;
AddTriadEdgeData(events, ts_indices, index, v, u, nbr_index, 0, 0);
nbr_index++;
// Get all events on triangles assigned to (u, v)
for (int w_id = 0; w_id < uv_assignment.Len(); w_id++) {
int w = uv_assignment[w_id];
AddTriadEdgeData(events, ts_indices, index, w, u, nbr_index, 0, 0);
AddTriadEdgeData(events, ts_indices, index, w, v, nbr_index, 0, 1);
AddTriadEdgeData(events, ts_indices, index, u, w, nbr_index, 1, 0);
AddTriadEdgeData(events, ts_indices, index, v, w, nbr_index, 1, 1);
nbr_index++;
}
// Put events in sorted order
ts_indices.Sort();
TIntV timestamps(ts_indices.Len());
TVec<TriadEdgeData> sorted_events(ts_indices.Len());
for (int i = 0; i < ts_indices.Len(); i++) {
timestamps[i] = ts_indices[i].Key;
sorted_events[i] = events[ts_indices[i].Dat];
}
// Get the counts and update the counter
ThreeTEdgeTriadCounter tetc(nbr_index, 0, 1);
tetc.Count(sorted_events, timestamps, delta);
#pragma omp critical
{
for (int dir1 = 0; dir1 < 2; dir1++) {
for (int dir2 = 0; dir2 < 2; dir2++) {
for (int dir3 = 0; dir3 < 2; dir3++) {
counts(dir1, dir2, dir3) += tetc.Counts(dir1, dir2, dir3);
}
}
}
}
}
}
