GIDI::Functions::Regions1d Class Reference

#include <GIDI.hpp>

Inheritance diagram for GIDI::Functions::Regions1d:

Public Member Functions
	Regions1d (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, Suite *a_parent)
	~Regions1d ()
std::size_t	size () const
Function1dForm const *	operator[] (std::size_t a_index) const
double	domainMin () const
double	domainMax () const
void	append (Function1dForm *a_function)
double	evaluate (double a_x1) const
void	mapToXsAndAdd (std::size_t a_offset, std::vector< double > const &a_Xs, std::vector< double > &a_results, double a_scaleFactor) const
XYs1d *	asXYs1d (bool a_asLinlin, double a_accuray, double a_lowerEps, double a_upperEps) const
std::vector< double > const &	Xs () const
std::vector< Function1dForm * > const &	function1ds () const
std::vector< Function1dForm * > &	function1ds ()
void	toXMLList_func (GUPI::WriteInfo &a_writeInfo, std::string const &a_indent, bool a_embedded, bool a_inRegions) const
void	write (FILE *a_file, std::string const &a_format) const
Public Member Functions inherited from GIDI::Functions::Function1dForm
	Function1dForm (std::string const &a_moniker, FormType a_type, ptwXY_interpolation a_interpolation, int a_index, double a_outerDomainValue)
	Function1dForm (std::string const &a_moniker, FormType a_type, Axes const &a_axes, ptwXY_interpolation a_interpolation, int a_index, double a_outerDomainValue)
	Function1dForm (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, FormType a_type, Suite *a_suite=nullptr)
	Function1dForm (Function1dForm const &a_form)
	~Function1dForm ()
Function1dForm &	operator= (Function1dForm const &a_rhs)
void	print (std::string const &a_format) const
Public Member Functions inherited from GIDI::Functions::FunctionForm
	FunctionForm (std::string const &a_moniker, FormType a_type, int a_dimension, ptwXY_interpolation a_interpolation, int a_index, double a_outerDomainValue)
	FunctionForm (std::string const &a_moniker, FormType a_type, int a_dimension, Axes const &a_axes, ptwXY_interpolation a_interpolation, int a_index, double a_outerDomainValue)
	FunctionForm (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, FormType a_type, int a_dimension, Suite *a_suite=nullptr)
	FunctionForm (FunctionForm const &a_form)
	~FunctionForm ()
FunctionForm &	operator= (FunctionForm const &a_rhs)
int	dimension () const
int	index () const
double	outerDomainValue () const
void	setOuterDomainValue (double a_outerDomainValue)
Axes const &	axes () const
Axes &	axes ()
ptwXY_interpolation	interpolation () const
void	setInterpolation (ptwXY_interpolation a_interpolation)
std::string	interpolationString () const
void	toXMLList (GUPI::WriteInfo &a_writeInfo, std::string const &a_indent) const
Public Member Functions inherited from GIDI::Form
	Form (FormType a_type)
	Form (std::string const &a_moniker, FormType a_type, std::string const &a_label)
	Form (HAPI::Node const &a_node, SetupInfo &a_setupInfo, FormType a_type, Suite *a_suite=nullptr)
	Form (Form const &a_form)
virtual	~Form ()
Form &	operator= (Form const &a_rhs)
Suite *	parent () const
std::string const &	label () const
void	setLabel (std::string const &a_label)
virtual std::string	actualMoniker () const
std::string const &	keyName () const
void	setKeyName (std::string const &a_keyName)
std::string const &	keyValue () const
virtual void	setKeyValue (std::string const &a_keyName) const
FormType	type () const
Form const *	sibling (std::string a_label) const
GUPI::Ancestry *	findInAncestry3 (LUPI_maybeUnused std::string const &a_item)
GUPI::Ancestry const *	findInAncestry3 (LUPI_maybeUnused std::string const &a_item) const
std::string	xlinkItemKey () const
Public Member Functions inherited from GUPI::Ancestry
	Ancestry (std::string const &a_moniker, std::string const &a_attribute="")
virtual	~Ancestry ()
Ancestry &	operator= (Ancestry const &a_ancestry)
std::string const &	moniker () const
void	setMoniker (std::string const &a_moniker)
Ancestry *	ancestor ()
Ancestry const *	ancestor () const
void	setAncestor (Ancestry *a_ancestor)
std::string	attribute () const
Ancestry *	root ()
Ancestry const *	root () const
bool	isChild (Ancestry *a_instance)
bool	isParent (Ancestry *a_parent)
bool	isRoot () const
Ancestry *	findInAncestry (std::string const &a_href)
Ancestry const *	findInAncestry (std::string const &a_href) const
virtual Ancestry *	findInAncestry3 (std::string const &a_item)=0
virtual Ancestry const *	findInAncestry3 (std::string const &a_item) const =0
virtual LUPI_HOST void	serialize (LUPI::DataBuffer &a_buffer, LUPI::DataBuffer::Mode a_mode)
std::string	toXLink () const
void	printXML () const

Additional Inherited Members
Static Public Member Functions inherited from GUPI::Ancestry
static std::string	buildXLinkItemKey (std::string const &a_name, std::string const &a_key)

Detailed Description

Class for the GNDS <regions1d> node.

Definition at line 1325 of file GIDI.hpp.

Constructor & Destructor Documentation

Regions1d()

GIDI::Functions::Regions1d::Regions1d	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		Suite *	a_parent )

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node to be parsed and used to construct the XYs2d.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_parent	[in] The parent GIDI::Suite.

Definition at line 52 of file GIDI_regions1d.cc.

                                                                                                                                  :
        Function1dForm( a_construction, a_node, a_setupInfo, FormType::regions1d, a_parent ) {
 
    if( a_setupInfo.m_formatVersion.format( ) != GNDS_formatVersion_1_10Chars ) {
        data1dListParse( a_construction, a_node.child( GIDI_function1dsChars ), a_setupInfo, m_function1ds );
        checkSequentialDomainLimits1d( m_function1ds, m_Xs );
        return;                                     // Need to add uncertainty parsing.
    }
 
    for( HAPI::Node child = a_node.first_child( ); !child.empty( ); child.to_next_sibling( ) ) {
        std::string name( child.name( ) );
 
        if( name == GIDI_axesChars ) continue;
        if( name == GIDI_uncertaintyChars ) continue;
 
        Function1dForm *_form = data1dParse( a_construction, child, a_setupInfo, nullptr );
        if( _form == nullptr ) throw Exception( "Regions1d::Regions1d: data1dParse returned nullptr." );
        append( _form );
    }
}

~Regions1d()

GIDI::Functions::Regions1d::~Regions1d

(

)

Definition at line 76 of file GIDI_regions1d.cc.

                       {
 
    for( std::vector<Function1dForm *>::iterator iter = m_function1ds.begin( ); iter < m_function1ds.end( ); ++iter ) delete *iter;
}

Member Function Documentation

append()

void GIDI::Functions::Regions1d::append

(

Function1dForm *

a_function

)

Appends the 1d function a_function to the region.

Parameters

a_function

[in] The 1d function (i.e., 1d region) to append to the Regions1d.

Definition at line 111 of file GIDI_regions1d.cc.

                                                   {
 
    if( dimension( ) != a_function->dimension( ) ) throw Exception( "Regions1d::append: dimensions differ." );
 
    double _domainMin = a_function->domainMin( ), _domainMax = a_function->domainMax( );
 
    if( m_Xs.size( ) == 0 ) {
        m_Xs.push_back( _domainMin ); }
    else {
        if( m_Xs.back( ) != _domainMin ) throw Exception( "Regions1d::append: regions do not abut." );
    }
 
    m_Xs.push_back( _domainMax );
    m_function1ds.push_back( a_function );
}

asXYs1d()

XYs1d * GIDI::Functions::Regions1d::asXYs1d ( bool a_asLinlin, double a_accuracy, double a_lowerEps, double a_upperEps ) const

virtual

This methods returns an XYs1d representation of this. The calling function owns the created instance and is responible for freeing it.

Parameters

a_asLinlin	[in] If true, the inpolatation of the returned XYs1d instance will always be lin-lin. Otherwise, the interpolation depends on the child 1d functions.
a_accuracy	[in] The accuracy use to convert the data to lin=lin interpolation if needed.
a_lowerEps	[in] The relative domain ammount to put a point below a boundary between two regions.
a_upperEps	[in] The relative domain ammount to put a point above a boundary between two regions.

Returns

A pointer to an XYs1d instance that must be freed by the calling function.

Reimplemented from GIDI::Functions::Function1dForm.

Definition at line 181 of file GIDI_regions1d.cc.

                                                                                                          {
 
    XYs1d *xys1d1 = nullptr, *xys1d2 = nullptr;
 
    if( a_lowerEps < 1e-14 ) a_lowerEps = 0.0;          // 1e-14 should be a global parameter.
    if( a_upperEps < 1e-14 ) a_upperEps = 0.0;
 
    if( !a_asLinlin ) {
        bool firstRegion = true;
        ptwXY_interpolation interpolation2 = ptwXY_interpolationLinLin;
        for( auto regionIter = m_function1ds.begin( ); regionIter != m_function1ds.end( ); ++regionIter ) {
            if( (*regionIter)->moniker( ) == GIDI_XYs1dChars ) {
                xys1d2 = static_cast<XYs1d *>( *regionIter );
                if( firstRegion ) interpolation2 = ptwXY_getInterpolation( xys1d2->ptwXY( ) );
                if( interpolation2 != ptwXY_getInterpolation( xys1d2->ptwXY( ) ) ) {
                    a_asLinlin = true;
                    break;
                } }
            else {
                a_asLinlin = true;
                break;
            }
        }
    }
 
    std::vector<double> xs;
    std::vector<double> ys;
 
    for( auto regionIter = m_function1ds.begin( ); regionIter != m_function1ds.end( ); ++regionIter ) {
        xys1d2 = (*regionIter)->asXYs1d( a_asLinlin, a_accuracy, a_lowerEps, a_upperEps );
        if( xys1d2 == nullptr ) {
            delete xys1d1;
            return( nullptr );
        }
 
        std::vector<double> xs2( xys1d2->xs( ) );
        if( xs2.size( ) < 2 ) continue;
 
        std::size_t xySize = xs.size( );
        std::vector<double> ys2( xys1d2->ys( ) );
        if( xySize > 0 ) {
            double y1u = ys.back( );
            double y2l = ys2[0];
 
            if( y1u == y2l ) {                              // Simple, just remove last point in xs and ys.
                xs.resize( xySize - 1 );
                ys.resize( xySize - 1 ); }
            else {
                bool addLower = false, addUpper = false;
                double x1l = xs[xySize-2];
                double x1u = xs.back( );
                double x2l = xs2[0];
                double x2u = xs2[1];
                double x1up = 0.0, x2lp= 0.0;
 
                if( a_lowerEps != 0.0 ) {
                    double x1lp = getAdjustedX( x1l, 0.8 *  a_lowerEps );
                    x1up        = getAdjustedX( x1u,       -a_lowerEps );       // Point to add in xs below xs.back() if room.
 
                    addLower = x1lp < x1up;                                     // Only add if relative spacing between existing point is greater than 1.8 * a_lowerEps.
                }
 
                if( a_upperEps > 0 ) {
                    x2lp        = getAdjustedX( x2l,        a_upperEps );       // Point to add in xs2 above xs2[0] if room.
                    double x2up = getAdjustedX( x2u, 0.8 * -a_upperEps );
 
                    addUpper = x2lp < x2up;                                     // Only add if relative spacing between existing point is greater than 1.8 * a_upperEps.
                }
 
                if( addLower ) {
                    if( addUpper ) {
                        xs.back( ) = x1up;
                        ys.back( ) = xys1d1->evaluate( x1up );
                        xs.push_back( x1u );
                        ys.push_back( 0.5 * ( y1u + y2l ) );
                        xs2[0] = x2lp;
                        ys2[0] = xys1d2->evaluate( x2lp ); }
                    else {
                        xs.back( ) = x1up;
                        ys.back( ) = xys1d1->evaluate( x1up );
                    } }
                else if( addUpper ) {
                    xs2[0] = x2lp;
                    ys2[0] = xys1d2->evaluate( x2lp ); }
                else {
                    ys2[0] = 0.5 * ( y1u + y2l );
                    xs.resize( xySize - 1 );
                    ys.resize( xySize - 1 );
                }
            }
        }
        xs.insert( xs.end( ),  xs2.begin( ), xs2.end( ) );
        ys.insert( ys.end( ),  ys2.begin( ), ys2.end( ) );
        xys1d1 = xys1d2;
    }
    delete xys1d1;
 
    return( new XYs1d( axes( ), ptwXY_interpolationLinLin, xs, ys ) );
}

domainMax()

double GIDI::Functions::Regions1d::domainMax ( ) const

virtual

Returns the domain maximum for the instance.

Returns

The domain maximum for the instance.

Implements GIDI::Functions::FunctionForm.

Definition at line 99 of file GIDI_regions1d.cc.

                                   {
 
    if( m_Xs.size( ) == 0 ) throw Exception( "Regions1d::domainMax: Regions1d has not regions" );
    return( m_Xs[m_Xs.size( )-1] );
}

domainMin()

double GIDI::Functions::Regions1d::domainMin ( ) const

virtual

Returns the domain minimum for the instance.

Returns

The domain minimum for the instance.

Implements GIDI::Functions::FunctionForm.

Definition at line 87 of file GIDI_regions1d.cc.

                                   {
 
    if( m_Xs.size( ) == 0 ) throw Exception( "Regions1d::domainMin: Regions1d has no regions" );
    return( m_Xs[0] );
}

evaluate()

double GIDI::Functions::Regions1d::evaluate ( double a_x1 ) const

virtual

The value of y(x1) at the point a_x1.

Parameters

a_x1	[in] Domain value to evaluate this at.

Returns

The value of this at the point a_x1.

Implements GIDI::Functions::Function1dForm.

Definition at line 135 of file GIDI_regions1d.cc.

                                              {
 
    if( m_Xs.size( ) == 0 ) throw Exception( "Regions1d::evaluate: Regions1d has not regions" );
 
    long iX1 = binarySearchVector( a_x1, m_Xs );
 
    if( iX1 < 0 ) {
        if( iX1 == -1 ) {       /* x1 > last value of Xs. */
            return( m_function1ds.back( )->evaluate( a_x1 ) );
        }
        iX1 = 0;                /* x1 < last value of Xs. */
    }
 
    return( m_function1ds[static_cast<std::size_t>(iX1)]->evaluate( a_x1 ) );
}

Referenced by evaluate().

function1ds() [1/2]

std::vector< Function1dForm * > & GIDI::Functions::Regions1d::function1ds ( )

inline

Returns the value of the m_function1ds member.

Definition at line 1348 of file GIDI.hpp.

function1ds() [2/2]

std::vector< Function1dForm * > const & GIDI::Functions::Regions1d::function1ds ( ) const

inline

Returns the value of the m_function1ds member.

Definition at line 1347 of file GIDI.hpp.

mapToXsAndAdd()

void GIDI::Functions::Regions1d::mapToXsAndAdd ( std::size_t a_offset, std::vector< double > const & a_Xs, std::vector< double > & a_results, double a_scaleFactor ) const

virtual

Evaluates this at the X-values in a_Xs[a_offset:] and adds the results to a_results[a_offset:]. a_Xs and a_results must be the same size otherwise a throw is executed.

Parameters

a_offset	[in] The offset in a_Xs to start.
a_Xs	[in] The list of domain values to evaluate this at.
a_results	[in] The list whose values are added to by the Y-values of this.
a_scaleFactor	[in] A factor applied to each evaluation before it is added to a_results.

Reimplemented from GIDI::Functions::Function1dForm.

Definition at line 161 of file GIDI_regions1d.cc.

                                                                                                                                           {
 
    for( auto iter = m_function1ds.begin( ); iter < m_function1ds.end( ); ++iter ) {
        (*iter)->mapToXsAndAdd( a_offset, a_Xs, a_results, a_scaleFactor );
    }
}

operator[]()

Function1dForm const * GIDI::Functions::Regions1d::operator[] ( std::size_t a_index ) const

inline

Returns the region at index a_index - 1.

Definition at line 1336 of file GIDI.hpp.

size()

std::size_t GIDI::Functions::Regions1d::size ( ) const

inline

Returns number of regions.

Definition at line 1335 of file GIDI.hpp.

Referenced by MCGIDI::Functions::Regions1d::Regions1d().

toXMLList_func()

void GIDI::Functions::Regions1d::toXMLList_func ( GUPI::WriteInfo & a_writeInfo, std::string const & a_indent, bool a_embedded, bool a_inRegions ) const

virtual

Fills the argument a_writeInfo with the XML lines that represent this. Recursively enters each sub-node.

Parameters

a_writeInfo	[in/out] Instance containing incremental indentation and other information and stores the appended lines.
a_indent	[in] The amount to indent this node.
a_embedded	[in] If true, this function is embedded in a higher dimensional function.
a_inRegions	[in] If true, this is in a Regions1d container.

Reimplemented from GIDI::Functions::FunctionForm.

Definition at line 290 of file GIDI_regions1d.cc.

                                                                                                                               {
 
    std::string indent2 = a_writeInfo.incrementalIndent( a_indent );
    std::string indent3 = a_writeInfo.incrementalIndent( indent2 );
    std::string attributes;
 
    if( a_embedded ) {
        attributes += a_writeInfo.addAttribute( GIDI_outerDomainValueChars, LUPI::Misc::doubleToShortestString( outerDomainValue( ) ) ); }
    else {
        if( a_inRegions ) {
            attributes = a_writeInfo.addAttribute( GIDI_indexChars, intToString( index( ) ) ); }
        else {
            if( label( ) != "" ) attributes = a_writeInfo.addAttribute( GIDI_labelChars, label( ) );
        }
    }
 
    a_writeInfo.addNodeStarter( a_indent, moniker( ), attributes );
    axes( ).toXMLList( a_writeInfo, indent2 );
    a_writeInfo.push_back( indent2 + "<function1ds>" );
    for( std::vector<Function1dForm *>::const_iterator iter = m_function1ds.begin( ); iter != m_function1ds.end( ); ++iter ) (*iter)->toXMLList_func( a_writeInfo, indent3, false, true );
    a_writeInfo.push_back( "</function1ds>" );
    a_writeInfo.addNodeEnder( moniker( ) );
}

write()

void GIDI::Functions::Regions1d::write ( FILE * a_file, std::string const & a_format ) const

virtual

This method calls the write method for each region of this.

Parameters

a_file	[in] The C FILE instance to write the data to.
a_format	[in] The format string passed to each region's write method.

Reimplemented from GIDI::Functions::Function1dForm.

Definition at line 321 of file GIDI_regions1d.cc.

                                                                     {
 
    for( auto regionIter = m_function1ds.begin( ); regionIter != m_function1ds.end( ); ++regionIter ) {
        (*regionIter)->write( a_file, a_format );
    }
}

Xs()

std::vector< double > const & GIDI::Functions::Regions1d::Xs ( ) const

inline

Returns the value of the m_Xs member.

Definition at line 1346 of file GIDI.hpp.

---

The documentation for this class was generated from the following files:

• GIDI.hpp
• GIDI_regions1d.cc