RepAggregationPeriod Class Reference

creates a signal of time ranges in which the input signal (usually medication) was active ranges are combined based on the period parameter the signal value is not transfered to the output signal More...

#include <RepProcess.h>

Inheritance diagram for RepAggregationPeriod:

Public Member Functions
void	init_tables (MedDictionarySections &dict, MedSignals &sigs)
	initialize signal ids
int	init (map< string, string > &mapper)
int	_apply (PidDynamicRec &rec, vector< int > &time_points, vector< vector< float > > &attributes_mat)
	apply processing on a single PidDynamicRec at a set of time-points : Should be implemented for all inheriting classes
void	print ()
	optional printing of processor
void	get_required_signal_categories (unordered_map< string, vector< string > > &signal_categories_in_use) const
	returns for each used signal it's used categories
Public Member Functions inherited from RepProcessor
virtual void	clear ()
virtual int	init (void *params)
	initialize from a params object : Should be implemented for inheriting classes that have parameters
virtual void	init_defaults ()
	initialize to default values : Should be implemented for inheriting classes that have parameters
virtual void	set_signal (const string &_signalName)
	set signal-name : Should be implemented for inheriting classes that have signalName
virtual void	set_signal_ids (MedSignals &sigs)
	set signal-ids : Should be implemented for inheriting classes that have signalId
virtual void	get_required_signal_names (unordered_set< string > &signalNames)
	Append required signal names to set : parent function just uses req_signals.
virtual void	get_required_signal_names (unordered_set< string > &signalNames, unordered_set< string > preReqSignals)
	Append required signal names to set only if processor is actually required to produce any of preReqSignals : parent function just uses req_signals.
virtual void	set_required_signal_ids (MedDictionarySections &dict)
	Fill req_signal_ids : parent function just fills from req_signals.
virtual void	add_virtual_signals (map< string, int > &_virtual_signals, map< string, string > &_virtual_signals_generic) const
	rep processors CREATING virtual signals need to implement this: adding their signals to the pile
virtual void	get_required_signal_ids (unordered_set< int > &signalIds)
	Append required signal names to set : parent function just uses req_signals.
virtual void	get_required_signal_ids (unordered_set< int > &signalIds, unordered_set< int > preReqSignals)
	Append required signal names to set only if processor is actually required to produce any of preReqSignals : parent function just uses req_signals.
virtual void	set_affected_signal_ids (MedDictionarySections &dict)
	Fill aff_signal_ids : parent function just fills from aff_signals.
bool	is_signal_affected (int signalId)
	Check if a signal is affected by processor </summray> Returns true if affected, false if not
bool	is_signal_affected (string &signalName)
virtual void	fit_for_repository (MedPidRepository &rep)
	make changes to RepProcessor according to available signals in Repository
virtual void	register_virtual_section_name_id (MedDictionarySections &dict)
	Register section id to section name of new virtual signals.
virtual bool	filter (unordered_set< string > &reqSignals)
	Check if processor (and 'sub'-processors within) should be applied according to set of required signals </summray> Returns true if processor is not required and can be filtered, false otherwise
virtual void	init_attributes ()
	Init attributes information : Should be implemented for inheriting classes that have attributes.
virtual int	_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors)
	learn processing model on a subset of samples. Apply set of preceeding processors on DynamicPidRec before learning :
virtual int	_conditional_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of samples only if required. Apply set of preceeding processors on DynamicPidRec before learning :
int	learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors)
	learn processing model on a subset of ids. Apply set of preceeding processors on DynamicPidRec before learning
int	learn (MedPidRepository &rep)
	learn on all pids in repository, using fake samples - works only for repProcessors that ignore sample dates
int	learn (MedPidRepository &rep, MedSamples &samples)
	learn on subset of samples without preceesing processors
virtual int	conditional_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of samples only if required. Apply set of preceeding processors on DynamicPidRec before learning :
int	conditional_learn (MedPidRepository &rep, MedSamples &samples, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of ids only if required without preceesing processors
virtual int	_conditional_apply (PidDynamicRec &rec, vector< int > &time_points, unordered_set< int > &neededSignalIds, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points only if required : May be implemented for inheriting classes
virtual int	_apply_simple (PidDynamicRec &rec, vector< int > &time_points)
int	apply (PidDynamicRec &rec, vector< int > &time_points, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points
int	conditional_apply (PidDynamicRec &rec, vector< int > &time_points, unordered_set< int > &neededSignalIds, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points only if required : if any of the signals in neededSignalIds is actually affected by processor
int	apply (PidDynamicRec &rec, MedIdSamples &samples)
	apply processing on a single PidDynamicRec at a set of time-points given by samples
int	conditional_apply (PidDynamicRec &rec, MedIdSamples &samples, unordered_set< int > &neededSignalIds)
	apply processing on a single PidDynamicRec at a set of time-points given by samples only if required
int	conditional_apply_without_attributes (PidDynamicRec &rec, const MedIdSamples &samples, unordered_set< int > &neededSignalIds)
	apply processing on a single PidDynamicRec at a set of time-points given by samples only if required, not affecting attributes
virtual void	dprint (const string &pref, int rp_flag)
	used for debug prints, each inheriting class can overload this one to get a more precise debug print.
virtual void	make_summary ()
void *	new_polymorphic (string derived_class_name)
	for polymorphic classes that want to be able to serialize/deserialize a pointer * to the derived class given its type one needs to implement this function to return a new to the derived class given its type (as in my_type)
size_t	get_processor_size ()
	get size of processor + processor_type
size_t	processor_serialize (unsigned char *blob)
	seialize processor + processor_type
Public Member Functions inherited from SerializableObject
virtual int	version () const
	Relevant for serializations.
virtual string	my_class_name () const
	For better handling of serializations it is highly recommended that each SerializableObject inheriting class will implement the next method.
virtual void	serialized_fields_name (vector< string > &field_names) const
	The names of the serialized fields.
virtual void	pre_serialization ()
virtual void	post_deserialization ()
virtual size_t	get_size ()
	Gets bytes sizes for serializations.
virtual size_t	serialize (unsigned char *blob)
	Serialiazing object to blob memory. return number ob bytes wrote to memory.
virtual size_t	deserialize (unsigned char *blob)
	Deserialiazing blob to object. returns number of bytes read.
size_t	serialize_vec (vector< unsigned char > &blob)
size_t	deserialize_vec (vector< unsigned char > &blob)
virtual size_t	serialize (vector< unsigned char > &blob)
virtual size_t	deserialize (vector< unsigned char > &blob)
virtual int	read_from_file (const string &fname)
	read and deserialize model
virtual int	write_to_file (const string &fname)
	serialize model and write to file
virtual int	read_from_file_unsafe (const string &fname)
	read and deserialize model without checking version number - unsafe read
int	init_from_string (string init_string)
	Init from string.
int	init_params_from_file (string init_file)
int	init_param_from_file (string file_str, string &param)
int	update_from_string (const string &init_string)
virtual int	update (map< string, string > &map)
	Virtual to update object from parsed fields.
virtual string	object_json () const

Data Fields
string	input_name
	name of input signal used by the processor
string	output_name
	name of signal created by the processor
vector< string >	sets
	the sets to check if signal value is in set
int	period
	period to consider active after signal in win time units
int	time_unit_win = MedTime::Undefined
	the time unit in which the period is given. Default: Undefined
int	time_unit_sig = MedTime::Undefined
	the time init in which the signal is given. Default: Undefined
Data Fields inherited from RepProcessor
RepProcessorTypes	processor_type = REP_PROCESS_LAST
	type of repository processor
unordered_set< string >	req_signals
	names of signals required for processsing
unordered_set< int >	req_signal_ids
	ids of signals required for processing
unordered_set< string >	aff_signals
	names of signals affected by processing
unordered_set< int >	aff_signal_ids
	ids of signals affected by processing
bool	unconditional = false
	indicated that processor should ALWAYS be applied
vector< string >	attributes
	attributes generated by the processor (optional)
vector< pair< string, int > >	virtual_signals
	virtual signals are created only in rep processors but can be used by any rep processor that comes after or any feture generator as a regular signal.
vector< pair< string, string > >	virtual_signals_generic

Additional Inherited Members
Static Public Member Functions inherited from RepProcessor
static RepProcessor *	make_processor (string name)
	create a new repository processor from name
static RepProcessor *	make_processor (string type, string params)
	create a new repository processor from name and a parameters string
static RepProcessor *	make_processor (RepProcessorTypes type)
	create a new repository processor from type
static RepProcessor *	make_processor (RepProcessorTypes type, string params)
	create a new repository processor from type and a parameters string
static RepProcessor *	create_processor (string &params)
	create a new repository processor from parameters string which contains rp_type

Detailed Description

creates a signal of time ranges in which the input signal (usually medication) was active ranges are combined based on the period parameter the signal value is not transfered to the output signal

Member Function Documentation

_apply()

int RepAggregationPeriod::_apply ( PidDynamicRec &  rec, vector< int > &  time_points, vector< vector< float > > &  attributes_mat  )

virtual

apply processing on a single PidDynamicRec at a set of time-points : Should be implemented for all inheriting classes

Reimplemented from RepProcessor.

get_required_signal_categories()

void RepAggregationPeriod::get_required_signal_categories ( unordered_map< string, vector< string > > &  signal_categories_in_use ) const

virtual

returns for each used signal it's used categories

Reimplemented from RepProcessor.

init()

int RepAggregationPeriod::init ( map< string, string > &  mapper )

virtual

        if (field == "input_name")
            input_name = entry.second;
        else if (field == "output_name")
            output_name = entry.second;
        else if (field == "sets")
            boost::split(sets, entry.second, boost::is_any_of(","));
        else if (field == "rp_type")
        {
        }
        else if (field == "period")
            period = med_stoi(entry.second);
        else if (field == "time_unit_sig")
            time_unit_sig = med_time_converter.string_to_type(entry.second);
        else if (field == "time_unit_win")
            time_unit_win = med_time_converter.string_to_type(entry.second);
        else
            MTHROW_AND_ERR("Error in RepAggregationPeriod::init - Unsupported param \"%s\"\n", field.c_str());

[RepAggregationPeriod::init]

[RepAggregationPeriod::init]

Reimplemented from RepProcessor.

init_tables()

void RepAggregationPeriod::init_tables ( MedDictionarySections &  dict, MedSignals &  sigs  )

virtual

initialize signal ids

Reimplemented from RepProcessor.

print()

void RepAggregationPeriod::print ( )

virtual

optional printing of processor

Reimplemented from RepProcessor.

---

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

• Internal/MedProcessTools/MedProcessTools/RepProcess.h
• Internal/MedProcessTools/MedProcessTools/RepProcess.cpp