private void WriteOutFlatFile(OutPutMktMode mktMode, string filePath, int cutOffHour, string fileNameSuffix)
        {
            bool headerCreated = false;

            Dictionary <Security, MktOutput> MktsOutPut = new Dictionary <Security, MktOutput>();

            foreach (var dataFactory in _securitites)
            {
                MktsOutPut.Add(dataFactory.SecurityObj, new MktOutput()
                {
                    basePath      = filePath,
                    baseExtension = fileNameSuffix + ".csv",
                    security      = dataFactory.SecurityObj
                });
            }

            DateTime      date         = DateTime.MinValue;
            List <string> dataCacheAll = new List <string>();
            Dictionary <Security, string> dataCacheByMkt = new Dictionary <Security, string>();
            StringBuilder fileName      = new StringBuilder();
            StringBuilder allMktsHeader = new StringBuilder();

            foreach (var timeStamp in Markets)
            {
                // calculate the header using the tickdata's built-in funnction
                if (!headerCreated)
                {
                    foreach (var security in timeStamp.Value)
                    {
                        MarketState marketState        = security.Value[0];
                        string      allmktHeaderString = marketState.GetHeadersString(true) + marketState.GetTradesHeaderString(5, true);
                        allMktsHeader.Append(allmktHeaderString);

                        string mktHeaderString = marketState.GetHeadersString() + marketState.GetCodesHeadersString();
                        MktsOutPut[security.Key].header = mktHeaderString;
                    }

                    //Console.WriteLine(allMktsHeader.ToString());
                    dataCacheAll.Add(allMktsHeader.ToString());
                    headerCreated = true;
                }

                StringBuilder data      = new StringBuilder();
                bool          resetDate = false;
                foreach (var security in timeStamp.Value)
                {
                    MktOutput mktOutPut = MktsOutPut[security.Key];

                    // Output a new file for each day. The end of each day is defined by a cutOffHour
                    DateTime current = timeStamp.Key;
                    if (date == DateTime.MinValue || ((current.Day != date.Day) && (current.Hour >= cutOffHour)))
                    {
                        if (resetDate == false)
                        {
                            resetDate = true;
                            if (mktMode == OutPutMktMode.AggregatedMkts)
                            {
                                if (dataCacheAll.Count > 0)
                                {
                                    writeCacheToFile(fileName.ToString(), dataCacheAll);
                                    dataCacheAll.Add(allMktsHeader.ToString());
                                }
                            }
                        }

                        if ((mktMode == OutPutMktMode.SeperateMkts) || (mktMode == OutPutMktMode.SeperateAndAggregated))
                        {
                            // output each of the individual markets data
                            if (mktOutPut.dataCache.Count > 0)
                            {
                                writeCacheToFile(mktOutPut.filePath.ToString(), mktOutPut.dataCache);
                            }
                            mktOutPut.dataCache.Add(mktOutPut.header);
                        }


                        // construct the new file name
                        fileName.Clear();
                        fileName.Append(filePath);
                        DateTime currentAdj = current.AddHours(9).AddMinutes(1);

                        string dateStr = currentAdj.Year.ToString() +
                                         currentAdj.Month.ToString("00") +
                                         currentAdj.Day.ToString("00");

                        switch (mktMode)
                        {
                        case OutPutMktMode.SeperateMkts:
                            mktOutPut.SetFilePath(dateStr);
                            break;

                        case OutPutMktMode.SeperateAndAggregated:
                            mktOutPut.SetFilePath(dateStr);
                            fileName.Append("All_Mkts_");
                            break;

                        case OutPutMktMode.AggregatedMkts:
                        default:
                            fileName.Append("All_Mkts_");
                            break;
                        }

                        fileName.Append(dateStr);
                        fileName.Append(fileNameSuffix + ".csv");
                    }

                    if ((mktMode == OutPutMktMode.AggregatedMkts) || (mktMode == OutPutMktMode.SeperateAndAggregated))
                    {
                        MarketState lastTick = security.Value[(uint)(security.Value.Count - 1)];
                        data.Append(MarketStateToString(lastTick, 5) + ",");
                    }

                    if ((mktMode == OutPutMktMode.SeperateMkts) || (mktMode == OutPutMktMode.SeperateAndAggregated))
                    {
                        foreach (var mktStates in security.Value)
                        {
                            mktOutPut.dataCache.Add(MarketStateToString(mktStates.Value));
                        }
                    }
                }

                if (resetDate)
                {
                    date = timeStamp.Key;            // reset the date if we moved passed the cut off for a new day
                }
                if ((mktMode == OutPutMktMode.AggregatedMkts) || (mktMode == OutPutMktMode.SeperateAndAggregated))
                {
                    dataCacheAll.Add(data.ToString());
                }
            }


            if ((mktMode == OutPutMktMode.AggregatedMkts) || (mktMode == OutPutMktMode.SeperateAndAggregated))
            {
                if (dataCacheAll.Count > 0)
                {
                    writeCacheToFile(fileName.ToString(), dataCacheAll);
                }
            }


            if ((mktMode == OutPutMktMode.SeperateMkts) || (mktMode == OutPutMktMode.SeperateAndAggregated))
            {
                // output each of the individual markets final data set
                foreach (var mktOutPut in MktsOutPut.Values)
                {
                    if (mktOutPut.dataCache.Count > 0)
                    {
                        writeCacheToFile(mktOutPut.filePath.ToString(), mktOutPut.dataCache);
                    }
                }
            }
        }