Records activation and repolarisation times. More...

#include <FilterBenchmark.h>

Inheritance diagram for Nektar::FilterBenchmark:

Public Member Functions
	FilterBenchmark (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< SolverUtils::EquationSystem > &pEquation, const ParamMap &pParams)
	Construct the benchmark filter. More...

	~FilterBenchmark () override
	Destructor for the benchmark filter. More...

Public Member Functions inherited from Nektar::SolverUtils::Filter
SOLVER_UTILS_EXPORT	Filter (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)

virtual SOLVER_UTILS_EXPORT	~Filter ()

SOLVER_UTILS_EXPORT void	Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT bool	IsTimeDependent ()

Static Public Member Functions
static SolverUtils::FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< SolverUtils::EquationSystem > &pEquation, const ParamMap &pParams)
	Creates an instance of this class. More...

Static Public Attributes
static std::string	className
	Name of the class. More...

Protected Member Functions
void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override
	Initialises the benchmark filter and allocates storage. More...

void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override
	Update recorded times. More...

void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override
	Finalises the benchmark filter and write out recorded data. More...

bool	v_IsTimeDependent () override
	Identifies that the benchmark filter is time dependent. More...

virtual void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual bool	v_IsTimeDependent ()=0

Private Attributes
std::vector< Array< OneD, NekDouble > >	m_threshold
	Storage for activation and repolarisation times. More...

Array< OneD, int >	m_idx
	Number of activations and repolarisations detected for each point. More...

Array< OneD, int >	m_polarity
	Indicates if the previous event was an activation or repolarisation. More...

NekDouble	m_startTime
	Time at which to start detecting activations and repolarisations. More...

NekDouble	m_thresholdValue
	Value at which tissue is considered active. More...

NekDouble	m_initialValue
	Initial time to use in storage array. More...

std::string	m_outputFile
	Filename of output files. More...

LibUtilities::FieldIOSharedPtr	m_fld
	FieldIO object used for writing output files. More...

Friends
class	MemoryManager< FilterBenchmark >

Additional Inherited Members
Public Types inherited from Nektar::SolverUtils::Filter
typedef std::map< std::string, std::string >	ParamMap

Protected Attributes inherited from Nektar::SolverUtils::Filter
LibUtilities::SessionReaderSharedPtr	m_session

const std::weak_ptr< EquationSystem >	m_equ

Detailed Description

Records activation and repolarisation times.

This class records the sequence of activation and repolarisation times across the entire domain into a two-dimensional storage structure. At each timestep, the voltage at each point in the domain is examined to identify if it has crossed the threshold value. If so, the time of crossing is recorded. Auxiliary arrays hold the current index of each point (i.e. the number of crossings of the threshold) and the type of the last crossing (activation or repolarisation).

Definition at line 44 of file FilterBenchmark.h.

Constructor & Destructor Documentation

◆ FilterBenchmark()

Nektar::FilterBenchmark::FilterBenchmark	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< SolverUtils::EquationSystem > &	pEquation,
		const ParamMap &	pParams
	)

Construct the benchmark filter.

Parameters

pSession	Session reader for IO
pParams	Parameters of filter

Definition at line 59 of file FilterBenchmark.cpp.

    : Filter(pSession, pEquation)
{
    // ThresholdValue
    auto it = pParams.find("ThresholdValue");
    ASSERTL0(it != pParams.end(), "Missing parameter 'ThresholdValue'.");
    LibUtilities::Equation equ1(m_session->GetInterpreter(), it->second);
    m_thresholdValue = floor(equ1.Evaluate());
 
    // InitialValue
    it = pParams.find("InitialValue");
    ASSERTL0(it != pParams.end(), "Missing parameter 'InitialValue'.");
    LibUtilities::Equation equ2(m_session->GetInterpreter(), it->second);
    m_initialValue = floor(equ2.Evaluate());
 
    // OutputFile
    it = pParams.find("OutputFile");
    ASSERTL0(it->second.length() > 0, "Missing parameter 'OutputFile'.");
    m_outputFile = it->second;
 
    // StartTime
    m_startTime = 0.0;
    it          = pParams.find("StartTime");
    if (it != pParams.end())
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        m_startTime = floor(equ.Evaluate());
    }
 
    m_fld = LibUtilities::FieldIO::CreateDefault(pSession);
}

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::LibUtilities::Equation::Evaluate(), m_fld, m_initialValue, m_outputFile, Nektar::SolverUtils::Filter::m_session, m_startTime, and m_thresholdValue.

◆ ~FilterBenchmark()

Nektar::FilterBenchmark::~FilterBenchmark ( )

override

Destructor for the benchmark filter.

Definition at line 97 of file FilterBenchmark.cpp.

98{

99}

Member Function Documentation

◆ create()

static SolverUtils::FilterSharedPtr Nektar::FilterBenchmark::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< SolverUtils::EquationSystem > &	pEquation,
		const ParamMap &	pParams
	)

inlinestatic

Creates an instance of this class.

Definition at line 50 of file FilterBenchmark.h.

    {
        SolverUtils::FilterSharedPtr p =
            MemoryManager<FilterBenchmark>::AllocateSharedPtr(
                pSession, pEquation, pParams);
        return p;
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

◆ v_Finalise()

void Nektar::FilterBenchmark::v_Finalise	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

overrideprotectedvirtual

Finalises the benchmark filter and write out recorded data.

Writes out the crossings to file.

Parameters

pFields	Field storage expansion list.
time	Current time.

Implements Nektar::SolverUtils::Filter.

Definition at line 175 of file FilterBenchmark.cpp.

{
    for (size_t j = 0; j < m_threshold.size() - 1; ++j)
    {
        std::stringstream vOutputFilename;
        vOutputFilename << m_outputFile << "_" << j << ".fld";
 
        std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
            pFields[0]->GetFieldDefinitions();
        std::vector<std::vector<NekDouble>> FieldData(FieldDef.size());
 
        Array<OneD, NekDouble> vCoeffs(pFields[0]->GetNcoeffs());
        pFields[0]->FwdTransLocalElmt(m_threshold[j], vCoeffs);
 
        // copy Data into FieldData and set variable
        for (size_t i = 0; i < FieldDef.size(); ++i)
        {
            // Could do a search here to find correct variable
            FieldDef[i]->m_fields.push_back("m");
            pFields[0]->AppendFieldData(FieldDef[i], FieldData[i], vCoeffs);
        }
 
        m_fld->Write(vOutputFilename.str(), FieldDef, FieldData);
    }
}

References m_fld, m_outputFile, and m_threshold.

◆ v_Initialise()

void Nektar::FilterBenchmark::v_Initialise	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

overrideprotectedvirtual

Initialises the benchmark filter and allocates storage.

Implements Nektar::SolverUtils::Filter.

Definition at line 106 of file FilterBenchmark.cpp.

{
    m_threshold.push_back(
        Array<OneD, NekDouble>(pFields[0]->GetNpoints(), m_initialValue));
 
    m_idx      = Array<OneD, int>(pFields[0]->GetNpoints(), 0);
    m_polarity = Array<OneD, int>(pFields[0]->GetNpoints(), -1);
}

References m_idx, m_initialValue, m_polarity, and m_threshold.

◆ v_IsTimeDependent()

bool Nektar::FilterBenchmark::v_IsTimeDependent ( )

overrideprotectedvirtual

Identifies that the benchmark filter is time dependent.

Returns: This filter is time dependent.

Implements Nektar::SolverUtils::Filter.

Definition at line 206 of file FilterBenchmark.cpp.

{
    return true;
}

◆ v_Update()

void Nektar::FilterBenchmark::v_Update	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

overrideprotectedvirtual

Update recorded times.

Checks each point in the domain to determine if it has crossed the threshold. The direction of crossing is determined. Additional storage is allocated if needed.

Parameters

pFields	Field storage expansion lists
time	Current time

Implements Nektar::SolverUtils::Filter.

Definition at line 124 of file FilterBenchmark.cpp.

{
    // Only proceed if the start time has passed
    if (time < m_startTime)
    {
        return;
    }
 
    // Examine each point in turn
    size_t nPts = pFields[0]->GetNpoints();
    for (size_t i = 0; i < nPts; ++i)
    {
        if ((m_polarity[i] == -1 &&
             pFields[0]->GetPhys()[i] > m_thresholdValue) ||
            (m_polarity[i] == 1 && pFields[0]->GetPhys()[i] < m_thresholdValue))
        {
            // If APD less than 50ms, remove last activation
            if (m_polarity[i] == 1 && time - m_threshold[m_idx[i]][i] < 50)
            {
                m_idx[i]--;
                m_threshold[m_idx[i]][i] = m_initialValue;
            }
            else
            {
                m_threshold[m_idx[i]][i] = time;
                m_idx[i]++;
            }
            // Update polarity of last crossing
            m_polarity[i] *= -1;
        }
    }
 
    // Allocate additional storage if any point has as many crossings as
    // current storage permits.
    size_t max_idx = Vmath::Vmax(pFields[0]->GetNpoints(), m_idx, 1);
    pFields[0]->GetSession()->GetComm()->AllReduce(max_idx,
                                                   LibUtilities::ReduceMax);
    if (m_threshold.size() == max_idx)
    {
        m_threshold.push_back(
            Array<OneD, NekDouble>(pFields[0]->GetNpoints(), m_initialValue));
    }
}

References m_idx, m_initialValue, m_polarity, m_startTime, m_threshold, m_thresholdValue, Nektar::LibUtilities::ReduceMax, and Vmath::Vmax().

Friends And Related Function Documentation

◆ MemoryManager< FilterBenchmark >

friend class MemoryManager< FilterBenchmark >

friend

Definition at line 1 of file FilterBenchmark.h.

Member Data Documentation

◆ className

std::string Nektar::FilterBenchmark::className

static

Initial value:

=
    SolverUtils::GetFilterFactory().RegisterCreatorFunction(
        "Benchmark", FilterBenchmark::create)

Name of the class.

Definition at line 62 of file FilterBenchmark.h.

◆ m_fld

LibUtilities::FieldIOSharedPtr Nektar::FilterBenchmark::m_fld

private

FieldIO object used for writing output files.

Definition at line 104 of file FilterBenchmark.h.

Referenced by FilterBenchmark(), and v_Finalise().

◆ m_idx

Array<OneD, int> Nektar::FilterBenchmark::m_idx

private

Number of activations and repolarisations detected for each point.

Definition at line 92 of file FilterBenchmark.h.

Referenced by v_Initialise(), and v_Update().

◆ m_initialValue

NekDouble Nektar::FilterBenchmark::m_initialValue

private

Initial time to use in storage array.

Definition at line 100 of file FilterBenchmark.h.

Referenced by FilterBenchmark(), v_Initialise(), and v_Update().

◆ m_outputFile

std::string Nektar::FilterBenchmark::m_outputFile

private

Filename of output files.

Definition at line 102 of file FilterBenchmark.h.

Referenced by FilterBenchmark(), and v_Finalise().

◆ m_polarity

Array<OneD, int> Nektar::FilterBenchmark::m_polarity

private

Indicates if the previous event was an activation or repolarisation.

Definition at line 94 of file FilterBenchmark.h.

Referenced by v_Initialise(), and v_Update().

◆ m_startTime

NekDouble Nektar::FilterBenchmark::m_startTime

private

Time at which to start detecting activations and repolarisations.

Definition at line 96 of file FilterBenchmark.h.

Referenced by FilterBenchmark(), and v_Update().

◆ m_threshold

std::vector<Array<OneD, NekDouble> > Nektar::FilterBenchmark::m_threshold

private

Storage for activation and repolarisation times.

Definition at line 90 of file FilterBenchmark.h.

Referenced by v_Finalise(), v_Initialise(), and v_Update().

◆ m_thresholdValue

NekDouble Nektar::FilterBenchmark::m_thresholdValue

private

Value at which tissue is considered active.

Definition at line 98 of file FilterBenchmark.h.

Referenced by FilterBenchmark(), and v_Update().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FilterBenchmark()

◆ ~FilterBenchmark()

Member Function Documentation

◆ create()

◆ v_Finalise()

◆ v_Initialise()

◆ v_IsTimeDependent()

◆ v_Update()

Friends And Related Function Documentation

◆ MemoryManager< FilterBenchmark >

Member Data Documentation

◆ className

◆ m_fld

◆ m_idx

◆ m_initialValue

◆ m_outputFile

◆ m_polarity

◆ m_startTime

◆ m_threshold

◆ m_thresholdValue