rec_settings.cpp

PQDIF软件包(SDK,Software Development Kit),它能转换、生成并且显示PQDIF文件.对于开发电力系统的数据输出非常有用。

    }

    //  Find calApplied (required)
    if( status )
    {
        status = false;

        pvect = FindVectorInCollection( pcollMain, tagCalApplied );
        if( pvect )
        {
            //  Check size of vector
            pvect->GetCount( count );
            if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Copy them over (pvect --> triggerShapeParam)
                calApplied.SetCount( count );
                for( idx = 0; idx < count; idx++ )
                {
                    pvect->GetValueREAL8( idx, valueREAL8 );
                    calApplied.SetValueREAL8( idx, valueREAL8 );
                }
                status = true;

            }   //  Got the right physical type and array size
        }   //  Found vector
    }

    //  Find calRecorded (required)
    if( status )
    {
        status = false;

        pvect = FindVectorInCollection( pcollMain, tagCalRecorded );
        if( pvect )
        {
            //  Check size of vector
            pvect->GetCount( count );
            if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Copy them over (pvect --> triggerShapeParam)
                calRecorded.SetCount( count );
                for( idx = 0; idx < count; idx++ )
                {
                    pvect->GetValueREAL8( idx, valueREAL8 );
                    calRecorded.SetValueREAL8( idx, valueREAL8 );
                }
                status = true;

            }   //  Got the right physical type and array size
        }   //  Found vector
    }

    return status;
}


//  Set functions
//  -------------

bool CPQDIF_R_Settings::SetInfo
        (
        const   TIMESTAMPPQDIF&     timeEffective,
        const   TIMESTAMPPQDIF&     timeInstalled,
        const   TIMESTAMPPQDIF&     timeRemoved,  
                bool                useCal,       
                bool                useTrans      
        )
{
    bool        status = false;

    CPQDIF_E_Scalar *       psc;
    PQDIFValue              value;
    CPQDIF_E_Collection *   pcolInstances;

    //  Set times ... effective
    if( status )
    {
        status = false;
        psc = FindOrCreateScalarInCollection( m_pcollMain,
            tagEffective, ID_PHYS_TYPE_TIMESTAMPPQDIF );
        //  Set value
        if( psc )
        {
            value.ts = timeEffective;
            status = psc->SetValue( ID_PHYS_TYPE_TIMESTAMPPQDIF, value );
        }
    }
    //  ... installed
    if( status )
    {
        status = false;
        psc = FindOrCreateScalarInCollection( m_pcollMain,
            tagTimeInstalled, ID_PHYS_TYPE_TIMESTAMPPQDIF );
        //  Set value
        if( psc )
        {
            value.ts = timeInstalled;
            status = psc->SetValue( ID_PHYS_TYPE_TIMESTAMPPQDIF, value );
        }
    }
    //  ... removed
    if( status )
    {
        status = false;
        psc = FindOrCreateScalarInCollection( m_pcollMain,
            tagTimeRemoved, ID_PHYS_TYPE_TIMESTAMPPQDIF );
        //  Set value
        if( psc )
        {
            value.ts = timeRemoved;
            status = psc->SetValue( ID_PHYS_TYPE_TIMESTAMPPQDIF, value );
        }
    }

    //  Flags ... useCal
    if( status )
    {
        status = false;
        psc = FindOrCreateScalarInCollection( m_pcollMain,
            tagUseCalibration, ID_PHYS_TYPE_BOOLEAN4 );
        //  Set value
        if( psc )
        {
            value.bool4 = useCal;
            status = psc->SetValue( ID_PHYS_TYPE_BOOLEAN4, value );
        }
    }
    //  ... useTrans
    if( status )
    {
        status = false;
        psc = FindOrCreateScalarInCollection( m_pcollMain,
            tagUseTransducer, ID_PHYS_TYPE_BOOLEAN4 );
        //  Set value
        if( psc )
        {
            value.bool4 = useTrans;
            status = psc->SetValue( ID_PHYS_TYPE_BOOLEAN4, value );
        }
    }

    //  Is there a collection?
    pcolInstances = GetChannelSettings(); 
    if( !pcolInstances )
    {
        //  Nope, insert an empty collection ...
        pcolInstances = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
        pcolInstances->SetTag( tagChannelSettingsArray );
        m_pcollMain->Add( pcolInstances );
    }

    return status;
}


long CPQDIF_R_Settings::AddChannel
        (
                UINT4               idxChannelDefn,
                UINT4               triggerTypeID,
                REAL8               fullScale,  
                REAL8               noiseFloor, 
                REAL8               triggerLow, 
                REAL8               triggerHigh,
                REAL8               triggerRate,
                //REAL8 *         triggerShapeParam   //  Array of [3] ... or NULL
        const   CPQDIF_E_Vector *   triggerShapeParam   //  Array of [3] ... or NULL
        ) 
{
            long        idxNew = -1;

            CPQDIF_E_Collection *   pcolInstances = GetChannelSettings();
            CPQDIF_E_Collection *   pcollOne;

            CPQDIF_E_Vector *       pvect;

            long    idx;
            long    count;
            double  valueParam;
    const   long    countParams = 3;

    if( pcolInstances )
    {
        //  Get the new index
        idxNew = GetCountChannels();

        //  Create the new channel instance
        pcollOne = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
        pcollOne->SetTag( tagOneChannelSetting );

        //  Stuff in the information...
        pcollOne->SetScalarUINT4( tagChannelDefnIdx, idxChannelDefn );
        pcollOne->SetScalarUINT4( tagTriggerTypeID, triggerTypeID );

        //  Thresholds
        pcollOne->SetScalarREAL8( tagFullScale, fullScale );
        pcollOne->SetScalarREAL8( tagNoiseFloor, noiseFloor );
        pcollOne->SetScalarREAL8( tagTriggerLow, triggerLow );
        pcollOne->SetScalarREAL8( tagTriggerHigh, triggerHigh );
        pcollOne->SetScalarREAL8( tagTriggerRate, triggerRate );

        //  Shape param
        pvect = FindOrCreateVectorInCollection( pcollOne, 
                    tagTriggerShapeParam, ID_PHYS_TYPE_REAL8 );
        //  Set its value(s)
        if( pvect && triggerShapeParam )
        {
            //  Validate physical type & size
            pvect->GetCount( count );
            if( pvect->GetPhysicalType() == ID_PHYS_TYPE_REAL8 
                && count == countParams )
            {
                pvect->SetCount( countParams );
                for( idx = 0; idx < countParams; idx++ )
                {
                    triggerShapeParam->GetValueREAL8( idx, valueParam );
                    pvect->SetValueREAL8( idx, valueParam );
                }
            }
        }

        //  We're done filling the collection ... add it!
        pcolInstances->Add( pcollOne );
    }

    return idxNew;
}


bool CPQDIF_R_Settings::SetChanTrans
        (
                UINT4               idxChannel,
                UINT4               xdTransformerTypeID,
                REAL8               xdSystemSideRatio,  
                REAL8               xdMonitorSideRatio,
        const   CPQDIF_E_Vector *   xdFrequencyResponse   //  Array [n]... or NULL
        )
{
    bool    status = false;

    CPQDIF_E_Collection *   pcollOne = GetOneChannelSetting( idxChannel );
    CPQDIF_E_Scalar *       psc;
    CPQDIF_E_Vector *       pvect;

    long        idx;
    long        count;
    double      value;

    if( pcollOne )
    {
        //  Scalars
        psc = FindOrCreateScalarInCollection( pcollOne,
            tagXDTransformerTypeID, ID_PHYS_TYPE_UNS_INTEGER4 );
        if( psc )
        {
            psc->SetValueUINT4( xdTransformerTypeID );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
            tagXDSystemSideRatio, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( xdSystemSideRatio );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
            tagXDMonitorSideRatio, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( xdMonitorSideRatio );
        }

        //  Vector
        if( xdFrequencyResponse )
        {
            pvect = FindOrCreateVectorInCollection( pcollOne, 
                    tagXDFrequencyResponse, ID_PHYS_TYPE_REAL8 );
            if( pvect && xdFrequencyResponse->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Transfer the data over
                xdFrequencyResponse->GetCount( count );
                pvect->SetCount( count );
                for( idx = 0; idx < count; idx++)
                {
                    xdFrequencyResponse->GetValueREAL8( idx, value );
                    pvect->SetValueREAL8( idx, value );
                }
            }
        }

        status = true;
    }

    return status;
}


bool CPQDIF_R_Settings::SetChanCal
        (
                UINT4               idxChannel,
                REAL8               calTimeSkew,  
                REAL8               calOffset,  
                REAL8               calRatio,  
                bool                calMustUseARCal,
        const   CPQDIF_E_Vector *   calApplied,     //  Array [n]... or NULL
        const   CPQDIF_E_Vector *   calRecorded     //  Array [n]... or NULL
        )
{
    bool    status = false;

    CPQDIF_E_Collection *   pcollOne = GetOneChannelSetting( idxChannel );
    CPQDIF_E_Scalar *       psc;
    CPQDIF_E_Vector *       pvect;

    long        idx;
    long        count;
    double      value;

    if( pcollOne )
    {
        //  Scalars
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalTimeSkew, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( calTimeSkew );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalOffset, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( calOffset );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalRatio, ID_PHYS_TYPE_REAL8 );
        if( psc )
        {
            psc->SetValueREAL8( calRatio );
        }
        psc = FindOrCreateScalarInCollection( pcollOne,
                tagCalMustUseARCal, ID_PHYS_TYPE_BOOLEAN4 );
        if( psc )
        {
            psc->SetValueBOOL4( (BOOL4) calMustUseARCal );
        }

        //  Vectors
        if( calApplied && calRecorded )
        {
            //  Applied
            pvect = FindOrCreateVectorInCollection( pcollOne, 
                        tagCalApplied, ID_PHYS_TYPE_REAL8 );
            if( pvect && calApplied->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Transfer the data over
                calApplied->GetCount( count );
                pvect->SetCount( count );
                for( idx = 0; idx < count; idx++)
                {
                    calApplied->GetValueREAL8( idx, value );
                    pvect->SetValueREAL8( idx, value );
                }
            }

            //  Recorded
            pvect = FindOrCreateVectorInCollection( pcollOne, 
                        tagCalRecorded, ID_PHYS_TYPE_REAL8 );
            if( pvect && calRecorded->GetPhysicalType() == ID_PHYS_TYPE_REAL8 )
            {
                //  Transfer the data over
                calRecorded->GetCount( count );
                pvect->SetCount( count );
                for( idx = 0; idx < count; idx++)
                {
                    calRecorded->GetValueREAL8( idx, value );
                    pvect->SetValueREAL8( idx, value );
                }
            }
        }

        status = true;
    }

    return status;
}

    
//  Protected stuff

CPQDIF_E_Collection * CPQDIF_R_Settings::GetChannelSettings( void )
{
    CPQDIF_E_Collection *   pcollSettings;

    //  Create the collection if it does not yet exist.
    pcollSettings = FindCollectionInCollection( m_pcollMain, tagChannelSettingsArray );
    if( !pcollSettings )
    {
        pcollSettings = (CPQDIF_E_Collection *) theFactory.NewElement( ID_ELEMENT_TYPE_COLLECTION );
        if( pcollSettings )
        {
            pcollSettings->SetTag( tagChannelSettingsArray );
            m_pcollMain->Add( pcollSettings );
        }
    }

    return pcollSettings;
}


CPQDIF_E_Collection * CPQDIF_R_Settings::GetOneChannelSetting
        ( 
        long idxChannel
        )
{
    CPQDIF_E_Collection *   pcolReturn = NULL;
    CPQDIF_E_Collection *   pcolInstances = GetChannelSettings();
    CPQDIF_Element *        pel;

    if( pcolInstances )
    {
        pel = pcolInstances->GetElement( idxChannel );
        if( pel )
        {
            if( pel->GetElementType() == ID_ELEMENT_TYPE_COLLECTION
                && PQDIF_IsEqualGUID( pel->GetTag(), tagOneChannelSetting ) )
            {
                pcolReturn = (CPQDIF_E_Collection *) pel;
            }
        }
    }

    return pcolReturn;
}