示例#1
0
        // Shamelessly copy pasted from the XDAWaveFormDataParser
        // Thanks other Stephen
        private void ParsePQDIF()
        {
            try
            {
                List <ObservationRecord> observationRecords;

                using (OpenFileDialog dialog = new OpenFileDialog())
                {
                    // Parse PQDif File Data
                    using (LogicalParser logicalParser = new LogicalParser(m_currentFilePath))
                    {
                        observationRecords = new List <ObservationRecord>();
                        logicalParser.Open();

                        while (logicalParser.HasNextObservationRecord())
                        {
                            observationRecords.Add(logicalParser.NextObservationRecord());
                        }
                    }

                    // Convert to common channel format
                    m_channels = observationRecords
                                 .SelectMany(observation => observation.ChannelInstances)
                                 .Where(channel => channel.Definition.QuantityTypeID == QuantityType.WaveForm)
                                 .Select(MakeParsedChannel)
                                 .ToList();
                }
            }
            catch (Exception e)
            {
                e.Source = m_currentFileRootName;
                ExceptionList.Add(e);
            }
        }
示例#2
0
        private void PQDIFButton_Click(object sender, EventArgs e)
        {
            List <ObservationRecord> observationRecords;

            using (OpenFileDialog dialog = new OpenFileDialog())
            {
                dialog.Filter = "PQDIF Files|*.pqd|All Files|*.*";
                dialog.Title  = "Browse PQDIF Files";

                if (dialog.ShowDialog() == DialogResult.Cancel)
                {
                    return;
                }

                if (!File.Exists(dialog.FileName))
                {
                    return;
                }

                // Parse PQDif File Data
                using (LogicalParser logicalParser = new LogicalParser(dialog.FileName))
                {
                    observationRecords = new List <ObservationRecord>();
                    logicalParser.Open();

                    while (logicalParser.HasNextObservationRecord())
                    {
                        observationRecords.Add(logicalParser.NextObservationRecord());
                    }
                }

                // Convert to common channel format
                m_channels = observationRecords
                             .SelectMany(observation => observation.ChannelInstances)
                             .Where(channel => channel.Definition.QuantityTypeID == QuantityType.WaveForm)
                             .Select(MakeParsedChannel)
                             .ToList();

                // Clear the list box and data chart
                ChannelListBox.Items.Clear();
                DataChart.Series.Clear();

                // Populate the list box with channel names
                ChannelListBox.Items.AddRange(m_channels
                                              .Select((channel, index) => string.Format("[{0}] {1}", index, channel.Name))
                                              .Cast <object>()
                                              .ToArray());

                // Select the first channel in the list
                ChannelListBox.SelectedIndex = 0;

                // Change the title text of the window to show what file the user has open
                m_fileName = dialog.SafeFileName;
                Text       = string.Format("PQDIF - [{0}]", dialog.SafeFileName);
            }
        }
示例#3
0
 /// <summary>
 /// Determines whether the file can be parsed at this time.
 /// </summary>
 /// <param name="filePath">The path to the file to be parsed.</param>
 /// <param name="fileCreationTime">The time the file was created.</param>
 /// <returns>True if the file can be parsed; false otherwise.</returns>
 public bool CanParse(string filePath, DateTime fileCreationTime)
 {
     try
     {
         m_parser = new LogicalParser(filePath);
         m_parser.Open();
         return(true);
     }
     catch (IOException)
     {
         return(false);
     }
 }
示例#4
0
        /// <summary>
        /// Populate known voltage and current data from PQDIF file.
        /// </summary>
        /// <param name="faultDataSet">Fault data set to be populated.</param>
        /// <param name="settings">Source parameters.</param>
        public static void PopulateDataSet(FaultLocationDataSet faultDataSet, Dictionary <string, string> settings)
        {
            string fileName;

            List <ObservationRecord> observationRecords;
            ObservationRecord        faultObservation;

            ChannelInstance[] anChannels;
            ChannelInstance[] bnChannels;
            ChannelInstance[] cnChannels;

            if (!settings.TryGetValue("fileName", out fileName) || !File.Exists(fileName))
            {
                throw new ArgumentException("Parameters must define a valid \"fileName\" setting.");
            }

            // Parse PQDif File Data
            using (LogicalParser logicalParser = new LogicalParser(fileName))
            {
                observationRecords = new List <ObservationRecord>();
                logicalParser.Open();

                while (logicalParser.HasNextObservationRecord())
                {
                    observationRecords.Add(logicalParser.NextObservationRecord());
                }
            }

            // Get the first observation record that contains six wave forms.
            // Assume that this observation record will has both voltage and
            // current wave forms for each of the three phases
            faultObservation = observationRecords.FirstOrDefault(observation => observation.ChannelInstances.Count(channel => channel.Definition.QuantityTypeID == QuantityType.WaveForm) >= 6);

            if ((object)faultObservation != null)
            {
                // Get the voltage and current wave forms for each of the six phase types
                IEnumerable <ChannelInstance> waveForms = faultObservation.ChannelInstances.Where(channel => channel.Definition.QuantityTypeID == QuantityType.WaveForm).ToList();

                anChannels = waveForms.Where(channel => channel.Definition.Phase == Phase.AN).ToArray();
                bnChannels = waveForms.Where(channel => channel.Definition.Phase == Phase.BN).ToArray();
                cnChannels = waveForms.Where(channel => channel.Definition.Phase == Phase.CN).ToArray();

                // Attempt to fill in fault data for each of the three phase types
                FillFaultData(faultDataSet.Voltages.AN, faultDataSet.Currents.AN, anChannels);
                FillFaultData(faultDataSet.Voltages.BN, faultDataSet.Currents.BN, bnChannels);
                FillFaultData(faultDataSet.Voltages.CN, faultDataSet.Currents.CN, cnChannels);

                // Set the frequency in the data set to the nominal frequency of the system
                faultDataSet.Frequency = faultObservation.Settings.NominalFrequency;
            }
        }
示例#5
0
        private void Parse(string filename)
        {
            List <ObservationRecord> observationRecords;
            List <DataSourceRecord>  dataSourceRecords;

            using (LogicalParser logicalParser = new LogicalParser(filename))
            {
                observationRecords = new List <ObservationRecord>();
                logicalParser.Open();

                while (logicalParser.HasNextObservationRecord())
                {
                    observationRecords.Add(logicalParser.NextObservationRecord());
                }

                dataSourceRecords = logicalParser.DataSourceRecords;
            }

            this.m_previousProgress = this.m_previousProgress + 50;
            this.mProgress.Report(this.m_previousProgress);

            if (observationRecords.Count == 0)
            {
                return;
            }
            if (dataSourceRecords.Count != 1)
            {
                return;
            }

            //create Meter Definition
            //For now assume a single meter
            Meter meter = new Meter();

            meter.DeviceName     = dataSourceRecords[0].DataSourceName;
            meter.Owner          = dataSourceRecords[0].DataSourceOwner;
            meter.DeviceAlias    = GSF.PQDIF.Logical.Equipment.ToString(dataSourceRecords[0].EquipmentID);
            meter.DeviceLocation = dataSourceRecords[0].DataSourceLocation;
            if (dataSourceRecords[0].Latitude < uint.MaxValue)
            {
                meter.Latitude = dataSourceRecords[0].Latitude;
            }
            if (dataSourceRecords[0].Longitude < uint.MaxValue)
            {
                meter.Longitude = dataSourceRecords[0].Longitude;
            }

            meter.AccountName = GSF.PQDIF.Logical.Vendor.ToString(dataSourceRecords[0].VendorID);

            using (TransactionScope scope = new TransactionScope())
            {
                AdoDataConnection connection = new AdoDataConnection(connectionstring, dataprovider);

                GSF.Data.Model.TableOperations <Meter> meterTable = new GSF.Data.Model.TableOperations <Meter>(connection);

                meterTable.AddNewRecord(meter);
                meter.ID = ModelID.GetID <Meter>(connection);


                //create Channel Definitions
                List <PQio.Model.Channel> channels = dataSourceRecords[0].ChannelDefinitions.Select(channel => ParseChannel(meter, channel, connection)).ToList();
                List <PQio.Model.Event>   events   = new List <Event>();
                //create Event Definitions
                foreach (ObservationRecord record in observationRecords)
                {
                    //Create Event
                    Event evt = ParseObservationRecord(record, connection);

                    //create DataSeries objects
                    foreach (ChannelInstance channelInstance in record.ChannelInstances)
                    {
                        ParseSeries(channelInstance, channels[(int)channelInstance.ChannelDefinitionIndex], evt, connection);
                    }
                    events.Add(evt);
                }

                // Remove Channels whithout data
                channels = channels.FindAll(item => RemoveEmptyChannel(item, connection)).ToList();
                events   = events.FindAll(item => RemoveEmptyEvents(item, connection)).ToList();

                // Remove Channels whithout data
                channels = channels.FindAll(item => RemoveEmptyChannel(item, connection)).ToList();

                // If only one set of data it's easy to keep only single line
                int nVa = channels.Count(channel => channel.MeasurementType.ToLower() == MeasurementType.VoltageA);
                int nVb = channels.Count(channel => channel.MeasurementType.ToLower() == MeasurementType.VoltageB);
                int nVc = channels.Count(channel => channel.MeasurementType.ToLower() == MeasurementType.VoltageC);
                int nIa = channels.Count(channel => channel.MeasurementType.ToLower() == MeasurementType.CurrentA);
                int nIb = channels.Count(channel => channel.MeasurementType.ToLower() == MeasurementType.CurrentB);
                int nIc = channels.Count(channel => channel.MeasurementType.ToLower() == MeasurementType.CurrentC);

                if (nVa == 1 && nVb == 1 && nVc == 1)
                {
                    //Create new asset
                    Asset asset = new Asset()
                    {
                        AssetKey = String.Format("Asset 1 ({0})", meter.AccountName)
                    };


                    GSF.Data.Model.TableOperations <Asset> assetTable = new GSF.Data.Model.TableOperations <Asset>(connection);
                    assetTable.AddNewRecord(asset);
                    asset.ID = ModelID.GetID <Asset>(connection);

                    GSF.Data.Model.TableOperations <Channel> channelTable = new GSF.Data.Model.TableOperations <Channel>(connection);

                    Channel Va = channels.Find(item => item.MeasurementType.ToLower() == MeasurementType.VoltageA);
                    Channel Vb = channels.Find(item => item.MeasurementType.ToLower() == MeasurementType.VoltageB);
                    Channel Vc = channels.Find(item => item.MeasurementType.ToLower() == MeasurementType.VoltageC);

                    Va.AssetID = asset.ID;
                    Vb.AssetID = asset.ID;
                    Vc.AssetID = asset.ID;

                    channelTable.UpdateRecord(Va);
                    channelTable.UpdateRecord(Vb);
                    channelTable.UpdateRecord(Vc);

                    if (nIa == 1 && nIb == 1 && nIc == 1)
                    {
                        Channel Ia = channels.Find(item => item.MeasurementType.ToLower() == MeasurementType.CurrentA);
                        Channel Ib = channels.Find(item => item.MeasurementType.ToLower() == MeasurementType.CurrentB);
                        Channel Ic = channels.Find(item => item.MeasurementType.ToLower() == MeasurementType.CurrentC);

                        Ia.AssetID = asset.ID;
                        Ib.AssetID = asset.ID;
                        Ic.AssetID = asset.ID;

                        channelTable.UpdateRecord(Ia);
                        channelTable.UpdateRecord(Ib);
                        channelTable.UpdateRecord(Ic);
                    }
                }

                scope.Complete();
            }
            this.m_previousProgress = this.m_previousProgress + 50;
            this.mProgress.Report(this.m_previousProgress);
        }