Nektar::MetricLInf Class Reference

#include <MetricLInf.h>

Inheritance diagram for Nektar::MetricLInf:

Static Public Member Functions
static MetricSharedPtr	create (TiXmlElement *metric, bool generate)
Static Public Member Functions inherited from Nektar::MetricRegex
static MetricSharedPtr	create (TiXmlElement *metric, bool generate)

Static Public Attributes
static std::string	type
static std::string	defaultTolerance = "1e-12"
Static Public Attributes inherited from Nektar::MetricRegex
static std::string	type

Protected Member Functions
	MetricLInf (TiXmlElement *metric, bool generate)
void	v_Generate (std::istream &pStdout, std::istream &pStderr) override
	Virtual function to generate the metric. Should be redefined in derived classes. More...
Protected Member Functions inherited from Nektar::MetricRegex
	MetricRegex (TiXmlElement *metric, bool generate)
	Constructor. More...
bool	v_Test (std::istream &pStdout, std::istream &pStderr) override
	Test output against a regex expression and set of matches. More...
void	v_Generate (std::istream &pStdout, std::istream &pStderr) override
	Test output against a regex expression and set of matches. More...
virtual bool	v_Test (std::istream &pStdout, std::istream &pStderr)=0
	Virtual function to test the metric. Should be redefined in derived classes. More...
virtual void	v_Generate (std::istream &pStdout, std::istream &pSrderr)=0
	Virtual function to generate the metric. Should be redefined in derived classes. More...

Protected Attributes
std::map< std::string, std::string >	m_varTolerance
Protected Attributes inherited from Nektar::MetricRegex
std::regex	m_regex
	Storage for the boost regex. More...
std::vector< std::vector< MetricRegexFieldValue > >	m_matches
	Stores the multiple matches defined in each <MATCH> tag. More...
bool	m_unordered = false
	If true, regex matches may be in any order in output. More...
bool	m_useStderr = false
	If true, use stderr for testing/generation instead of stdout. More...
Protected Attributes inherited from Nektar::Metric
int	m_id
	Stores the ID of this metric. More...
std::string	m_type
	Stores the type of this metric (uppercase). More...
bool	m_generate
	Determines whether to generate this metric or not. More...
bool	m_average = false
	Indicates whether a metric supports averaging results from multiple runs. More...
TiXmlElement *	m_metric
	Pointer to XML structure containing metric definition. More...

Additional Inherited Members
Public Member Functions inherited from Nektar::MetricRegex
	~MetricRegex () override
Public Member Functions inherited from Nektar::Metric
	Metric (TiXmlElement *metric, bool generate)
	Constructor. More...
virtual	~Metric ()=default
bool	Test (std::istream &pStdout, std::istream &pStderr)
	Calls a metric's v_Test function (or v_Generate if m_generate). More...
void	Generate (std::istream &pStdout, std::istream &pStderr)
std::string	GetType ()
	Return metric type. More...
int	GetID ()
	Return metric ID. More...
bool	SupportsAverage () const
	Return whether this metric supports averaging results from multiple runs. More...

Detailed Description

Definition at line 42 of file MetricLInf.h.

Constructor & Destructor Documentation

MetricLInf()

Nektar::MetricLInf::MetricLInf ( TiXmlElement *  metric, bool  generate  )

protected

Definition at line 45 of file MetricLInf.cpp.

    : MetricRegex(metric, generate)
{
    // Set up the regular expression. This (optionally) matches a variable
    // name if it exists: first field is variable name, second field is L2
    // error.
    m_regex = "^L inf\\w* error\\s*(?:\\(variable "
              "(\\w+)\\))?\\s*:\\s*([+-]?\\d.+\\d|-?\\d|[+-]?nan|[+-]?inf).*";
 
    // Find the L2 error to match against.
    TiXmlElement *value = metric->FirstChildElement("value");
    ASSERTL0(value || m_generate, "Missing value tag for LInf metric!");
 
    while (value)
    {
        // Set up a match with two fields which correspond with the
        // subexpression above. The first is the variable name, second is
        // the L2 error.
        ASSERTL0(value->Attribute("tolerance"),
                 "Missing tolerance in L2 metric");
        ASSERTL0(!EmptyString(value->GetText()), "Missing value in L2 metric.");
 
        MetricRegexFieldValue var;
        if (value->Attribute("variable"))
        {
            var.m_value = value->Attribute("variable");
        }
 
        MetricRegexFieldValue val;
        val.m_value        = value->GetText();
        val.m_useTolerance = true;
        val.m_tolerance    = atof(value->Attribute("tolerance"));
 
        if (!m_generate)
        {
            std::vector<MetricRegexFieldValue> tmp(2);
            tmp[0] = var;
            tmp[1] = val;
            m_matches.push_back(tmp);
        }
        else
        {
            m_varTolerance[var.m_value] = value->Attribute("tolerance");
        }
 
        value = value->NextSiblingElement("value");
    }
}

References ASSERTL0, Nektar::EmptyString(), Nektar::Metric::m_generate, Nektar::MetricRegex::m_matches, Nektar::MetricRegex::m_regex, Nektar::MetricRegexFieldValue::m_tolerance, Nektar::MetricRegexFieldValue::m_useTolerance, Nektar::MetricRegexFieldValue::m_value, and m_varTolerance.

Referenced by create().

Member Function Documentation

create()

static MetricSharedPtr Nektar::MetricLInf::create ( TiXmlElement *  metric, bool  generate  )

inlinestatic

Definition at line 45 of file MetricLInf.h.

    {
        return MetricSharedPtr(new MetricLInf(metric, generate));
    }

References MetricLInf().

v_Generate()

void Nektar::MetricLInf::v_Generate ( std::istream &  pStdout, std::istream &  pSrderr  )

overrideprotectedvirtual

Virtual function to generate the metric. Should be redefined in derived classes.

Parameters

pStdout	Reference to test output stream.
pSrderr	Reference to test error stream.

Implements Nektar::Metric.

Definition at line 94 of file MetricLInf.cpp.

{
    // Run MetricRegex to generate matches.
    MetricRegex::v_Generate(pStdout, pStderr);
 
    // First remove all existing values.
    m_metric->Clear();
 
    ASSERTL0(m_matches.size() > 0, "Unable to find L infinity norm in output!");
 
    // Now create new values.
    for (int i = 0; i < m_matches.size(); ++i)
    {
        ASSERTL0(m_matches[i].size() == 2,
                 "Wrong number of matches for regular expression.");
 
        bool tolSet         = false;
        std::string tol     = MetricLInf::defaultTolerance;
        TiXmlElement *value = new TiXmlElement("value");
 
        // See if there is a tolerance found already for this variable
        // (including empty variables).
        std::map<std::string, std::string>::iterator it =
            m_varTolerance.find(m_matches[i][0].m_value);
 
        if (it != m_varTolerance.end())
        {
            tol    = it->second;
            tolSet = true;
        }
 
        if (m_matches[i][0].m_value.size() > 0)
        {
            value->SetAttribute("variable", m_matches[i][0].m_value);
 
            if (m_matches[i][0].m_value == "p" && !tolSet)
            {
                // Set lower tolerance for pressure fields automatically if
                // we haven't already got a tolerance from the existing
                // file.
                tol = "1e-8";
            }
        }
 
        value->SetAttribute("tolerance", tol);
        value->LinkEndChild(new TiXmlText(m_matches[i][1].m_value));
        m_metric->LinkEndChild(value);
    }
}

References ASSERTL0, defaultTolerance, Nektar::MetricRegex::m_matches, Nektar::Metric::m_metric, m_varTolerance, and Nektar::MetricRegex::v_Generate().

Member Data Documentation

defaultTolerance

std::string Nektar::MetricLInf::defaultTolerance = "1e-12"

static

Definition at line 51 of file MetricLInf.h.

Referenced by v_Generate().

m_varTolerance

std::map<std::string, std::string> Nektar::MetricLInf::m_varTolerance

protected

Definition at line 56 of file MetricLInf.h.

Referenced by MetricLInf(), and v_Generate().

type

std::string Nektar::MetricLInf::type

static

Initial value:

=
    GetMetricFactory().RegisterCreatorFunction("LINF", MetricLInf::create)

Definition at line 50 of file MetricLInf.h.