// Pregnancy episode start marker types: LMP: Last menstrual period date, GEST: Gestational age record, FERT: Assisted
// conception procedure date, ULS: Nuchal ultrasound date, AFP: Alpha feto protein test date, AMEN: Amenorrhea record date,
// URINE: Urine pregnancy test date
private static IEnumerable <KeyValuePair <Event, Event> > FindPregnancEpisodes(
Dictionary <string, List <Event> > validOutcomes, RawEvents raw,
Dictionary <string, TermDurations> termDurations, Dictionary <string, GestEst> gestEst, string[] markers, bool hasDefault, bool desc)
{
var outcomes = new List <Event>();
foreach (var outcomeCategory in validOutcomes.Keys)
{
outcomes.AddRange(validOutcomes[outcomeCategory]);
}
foreach (var outcome in outcomes)
{
var duration = termDurations[outcome.Category];
var ge = gestEst[outcome.Category];
var priorOutcomeDate = DateTime.MinValue;
var priorOutcomes = outcomes.Where(o => o.Date < outcome.Date).ToArray();
TermDurations durationPrior = null;
if (priorOutcomes.Any())
{
var po = priorOutcomes.OrderByDescending(o => o.Date).First();
priorOutcomeDate = po.Date;
durationPrior = termDurations[po.Category];
}
foreach (var startEpisodeOutcome in FindPregnancyStartEvent(raw, duration, durationPrior, outcome, priorOutcomeDate,
ge, markers, hasDefault, desc))
{
yield return(new KeyValuePair <Event, Event>(outcome, startEpisodeOutcome));
}
}
}
private static Event FindStart(Event outcome, Event pe, TermDurations duration, DateTime priorOutcomeDate)
{
var episodeStartDate = pe.EpisodeStartDate;
var windowStart = outcome.Date.Date.AddDays(-1 * duration.MaxTerm);
var windowEnd = outcome.Date.AddDays(-1 * duration.MinTerm);
if (priorOutcomeDate.AddDays(duration.Retry) > windowStart)
{
windowStart = priorOutcomeDate.AddDays(duration.Retry);
}
return(episodeStartDate.Between(priorOutcomeDate > windowStart ? priorOutcomeDate : windowStart,
windowEnd) ? new Event {
EventId = pe.EventId, Category = pe.Category, Date = episodeStartDate
} : null);
}
private static IEnumerable <Event> FindPregnancyStartEvent(RawEvents raw, TermDurations duration,
TermDurations durationPrior, Event outcome, DateTime priorOutcomeDate, GestEst g, string[] markers,
bool hasDefault, bool desc)
{
List <Event> starts = new List <Event>();
foreach (var startMarker in markers)
{
if (!raw.PregnancyEvents.ContainsKey(startMarker))
{
continue;
}
foreach (var pe in raw.PregnancyEvents[startMarker]
.OrderBy(e => e.Date))
{
var e = FindStart(outcome, pe, duration, priorOutcomeDate);
if (e == null)
{
continue;
}
e.OriginalDate = pe.Date;
starts.Add(e);
}
}
if (starts.Any())
{
foreach (var group in starts.GroupBy(s => s.Category))
{
if (desc)
{
var maxDate = group.Max(e => e.OriginalDate);
yield return(group.Where(e => e.OriginalDate == maxDate).OrderBy(e => e.EventId).First());
}
else
{
var minDate = group.Min(e => e.OriginalDate);
yield return(group.Where(e => e.OriginalDate == minDate).OrderBy(e => e.EventId).First());
}
}
}
if (hasDefault)
{
var wStart = outcome.Date.Date.AddDays(-1 * duration.MaxTerm);
var wEnd = outcome.Date.AddDays(30);
if (outcome.Date.Between(priorOutcomeDate > wStart ? priorOutcomeDate : wStart,
wEnd))
{
var episodeStartDate = outcome.Date;
var category = "DEFAULT";
if (raw.PregnancyEvents.ContainsKey("PREM") && raw.PregnancyEvents["PREM"].Count(e =>
e.Date.Between(priorOutcomeDate > wStart ? priorOutcomeDate : wStart,
wEnd)) > 0)
{
episodeStartDate = episodeStartDate.Date.AddDays(-1 * g.PreTerm);
category = "PREM";
}
else if (raw.PregnancyEvents.ContainsKey("FT") && raw.PregnancyEvents["FT"].Count(e =>
e.Date.Between(priorOutcomeDate > wStart ? priorOutcomeDate : wStart,
wEnd)) > 0)
{
episodeStartDate = episodeStartDate.Date.AddDays(-1 * g.FullTerm);
}
else
{
episodeStartDate = episodeStartDate.Date.AddDays(-1 * g.NoData);
}
if (durationPrior != null && priorOutcomeDate.AddDays(durationPrior.Retry) > episodeStartDate)
{
episodeStartDate = priorOutcomeDate.AddDays(durationPrior.Retry);
}
yield return(new Event {
EventId = outcome.EventId, Category = category, Date = episodeStartDate
});
}
}
}
