//Sets the inervals
private void setIntervalsAndRelations()
{
relations = new Dictionary <int, Dictionary <int, string> >();
TemporalDB db = CCMiner.mainDB;
sequences = new List <EventSequence>();
for (int k = 0; k < actual_ids.Count; k++)
{
string t_id = TransformedDB.getID(actual_ids[k]);
ids.Add(k, t_id);
string id = t_id;
EventSequence seq = new EventSequence();
List <string> seq_syms = CoincidenceManager.
getPatternSymbols(pDB.patterns[actual_ids[k]].Item1);
foreach (string sym in seq_syms)
{
seq.ints.Add(db.seqs[id].getInterval(sym));
}
sequences.Add(seq);
if (k == 0)
{
for (int i = 0; i < length; i++)
{
relations.Add(i, new Dictionary <int, string>());
for (int j = i + 1; j < length; j++)
{
EventInterval ei1 = seq.ints[i];
EventInterval ei2 = seq.ints[j];
string rel = getRelation(ei1, ei2);
relations[i].Add(j, rel);
}
}
}
}
}
//Adds a pattern to the patterns collection
public void addPattern(string pat, int sup, TransformedDB projDB)
{
using (FileStream fileStream = new FileStream(Constants.OUT_FILE, FileMode.Append, FileAccess.Write))
{
TextWriter tw = new StreamWriter(fileStream);
TemporalPattern tp = new TemporalPattern(CoincidenceManager.outToCoSeq(pat), sup, projDB);
tw.WriteLine(tp.ToString());
tw.Close();
}
}
public TemporalPattern(string cs, int sup, TransformedDB projDB)
{
pDB = projDB;
coSeqRep = cs;
support = sup;
setSyms();
setCoSeqLength();
actual_ids = pDB.patterns.Keys.ToList();
ids = new Dictionary <int, string>();
setIntervalsAndRelations();
setMeanHorSupport();
}
//The CCMiner main algorithm
public static CTP ccMiner(TemporalDB DB, bool closed)
{
CTP ctp = new CTP();
mainDB = DB;
//Transforms the db into cincidence representation
TransformedDB tdb = DB.transformDB();
//all frequent slices
Dictionary <string, int> tp1 = tdb.slicesFreq();
//backward extension slices
List <string> BS = null;
//int tasks = 0;
int count = 0;
foreach (KeyValuePair <string, int> entry in tp1)
{
count++;
Console.WriteLine(count + "/" + tp1.Count + "/" + entry.Key);
//For each frequent starting slice
if (entry.Value >= Constants.MINSUP && entry.Key.IndexOf(Constants.MEET_REP) < 0 &&
entry.Key.IndexOf(Constants.ST_REP) > 0)
{
BS = new List <string>();
TransformedDB projDB = tdb.projectDB(entry.Key, null, false);
if (!closed || !tdb.CBackScan(BS, entry.Key))
{
if (closed)
{
BS.AddRange(tdb.backwardExtensionCheck(entry.Key));
}
CBIDE(projDB, entry.Key, projDB.sup, projDB.trans_db.Count, BS, ref ctp, closed);
}
}
}
return(ctp);
}
//The CBIDE algorithm
private static void CBIDE(TransformedDB projDB, string alpha, int alpha_support,
double totalsup, List <string> BS, ref CTP ctp, bool closed)
{
long dt1 = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
Dictionary <string, int> LFs = projDB.slicesFreq();
long t = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond - dt1;
List <string> FS = new List <string>();
bool start = false;
if (closed)
{
foreach (KeyValuePair <string, int> entry in LFs)
{
//CCMiner wanted only finishing ones, but that's not enough for closed patterns recognition
if (/*entry.Key.IndexOf(Constants.FIN_REP) > 0 &&*/ totalsup == entry.Value)
{
if (entry.Key[entry.Key.Length - 1] == Constants.ST_REP)
{
start = true;
break;
}
string slice = entry.Key[0] == Constants.MEET_REP || entry.Key[0] == Constants.CO_REP ?
entry.Key.Substring(1) : entry.Key;
FS.Add(slice);
}
}
}
//Check if none appear in pairs in BS U FS
bool nip = closed && CoincidenceManager.noneInPairs(BS, FS);
//Check if all appear in pairs in the accumulated coincidence
bool aip = CoincidenceManager.allInPairs(alpha);
//If So, there are no backward & forward extensions and this is a temporal pattern
if ((!closed || (!start && nip)) && aip)
{
//Thus - alpha is a closed temporal pattern
ctp.addPattern(alpha, alpha_support, projDB);
}
//Now Continue Looking for possible extensions
List <string> P = new List <string>();
//For each frequent slice:
foreach (KeyValuePair <string, int> z in LFs)
{
if (z.Value < Constants.MINSUP)
{
continue;
}
//Finishing slices only
if (z.Key.IndexOf(Constants.FIN_REP) >= 0)
{
string tmp = z.Key[0] == Constants.CO_REP ? z.Key.Substring(1) : z.Key;
if (alpha.IndexOf(tmp.Replace(Constants.FIN_REP, Constants.ST_REP)) >= 0)
{//pre-pruning
P.Add(z.Key);
}
}
else
{
//Starting slices only
P.Add(z.Key);
}
}
//For each possible extension we found:
foreach (string z in P)
{
//post-pruning
//Notice that we project another time only by the recent added slice
TransformedDB alpha_projDB = projDB.projectDB(z, LFs, true);
//If the support of the extended pattern is above the minimum support requested
if (alpha_projDB.sup >= Constants.MINSUP)
{
//Copy Backward extension list
List <string> BStag = BS.Take(BS.Count).ToList();
//Check if extensible and update the backward extension slices
if (!closed || !projDB.CBackScan(BStag, z))
{
if (closed)
{
BStag.AddRange(projDB.backwardExtensionCheck(z));
}
CBIDE(alpha_projDB, alpha + z, alpha_projDB.sup, alpha_projDB.trans_db.Count, BStag, ref ctp, closed);
}
}
}
}
