A BinNormalisation class that gets the normalisation factors from an ECAT8 3D normalisation file. Note that you have to point it to the "Interfile" header. More...

#include "stir/recon_buildblock/BinNormalisationFromECAT8.h"

Inheritance diagram for stir::ecat::BinNormalisationFromECAT8:

[legend]

Public Member Functions
	BinNormalisationFromECAT8 ()
	Default constructor.

	BinNormalisationFromECAT8 (const string &filename)
	Constructor that reads the projdata from a file.

Succeeded	set_up (const shared_ptr< const ExamInfo > &exam_info_sptr, const shared_ptr< const ProjDataInfo > &) override
	initialises the object and checks if it can handle such projection data

float	get_uncalibrated_bin_efficiency (const Bin &bin) const override

bool	use_detector_efficiencies () const

bool	use_dead_time () const

bool	use_geometric_factors () const

bool	use_crystal_interference_factors () const

bool	use_axial_effects_factors () const

Public Member Functions inherited from stir::RegisteredParsingObject< BinNormalisationFromECAT8, BinNormalisation, BinNormalisationWithCalibration >
std::string	get_registered_name () const override
	Returns Derived::registered_name.

std::string	parameter_info () override
	Returns a string with all parameters and their values, in a form suitable for parsing again.

Public Member Functions inherited from stir::BinNormalisationWithCalibration
Succeeded	set_up (const shared_ptr< const ExamInfo > &exam_info_sptr, const shared_ptr< const ProjDataInfo > &) override
	initialises the object and checks if it can handle such projection data

float	get_calib_decay_branching_ratio_factor (const Bin &) const
	product of calibration factor etc

float	get_calibration_factor () const override

float	get_branching_ratio () const

void	set_calibration_factor (const float)

void	set_radionuclide (const Radionuclide &)

float	get_bin_efficiency (const Bin &bin) const final
	return efficiency for 1 bin

Public Member Functions inherited from stir::BinNormalisation
virtual bool	is_trivial () const
	check if we would be multiplying with 1 (i.e. do nothing)

virtual bool	is_TOF_only_norm () const
	returns if the object can only handle TOF data

virtual void	apply (RelatedViewgrams< float > &) const
	normalise some data

virtual void	undo (RelatedViewgrams< float > &) const
	undo the normalisation of some data

void	apply (ProjData &, shared_ptr< DataSymmetriesForViewSegmentNumbers >=shared_ptr< DataSymmetriesForViewSegmentNumbers >()) const
	normalise some data

void	undo (ProjData &, shared_ptr< DataSymmetriesForViewSegmentNumbers >=shared_ptr< DataSymmetriesForViewSegmentNumbers >()) const
	undo the normalisation of some data

void	set_exam_info_sptr (const shared_ptr< const ExamInfo > _exam_info_sptr)

shared_ptr< const ExamInfo >	get_exam_info_sptr () const

Public Member Functions inherited from stir::ParsingObject
	ParsingObject (const ParsingObject &)

ParsingObject &	operator= (const ParsingObject &)

bool	parse (std::istream &f)

bool	parse (const char *const filename)

void	ask_parameters ()

Static Public Attributes
static const char *const	registered_name = "From ECAT8"
	Name which will be used when parsing a BinNormalisation object.

Additional Inherited Members
Static Public Member Functions inherited from stir::RegisteredParsingObject< BinNormalisationFromECAT8, BinNormalisation, BinNormalisationWithCalibration >
static BinNormalisation *	read_from_stream (std::istream *)
	Construct a new object (of type Derived) by parsing the istream.

Static Public Member Functions inherited from stir::RegisteredObject< BinNormalisation >
static BinNormalisation *	read_registered_object (std::istream *in, const std::string &registered_name)
	Construct a new object (of a type derived from Root, its actual type determined by the registered_name parameter) by parsing the istream.

static BinNormalisation *	ask_type_and_parameters ()
	ask the user for the type, and then calls read_registered_object(0, type)

static void	list_registered_names (std::ostream &stream)
	List all possible registered names to the stream.

Protected Types inherited from stir::RegisteredObject< BinNormalisation >
typedef BinNormalisation (	RootFactory) (std::istream *)
	The type of a root factory is a function, taking an istream* as argument, and returning a Root*.

typedef FactoryRegistry< std::string, RootFactory, interfile_less >	RegistryType
	The type of the registry.

Protected Member Functions inherited from stir::BinNormalisationWithCalibration
void	set_defaults () override

void	initialise_keymap () override
	Initialise all keywords.

bool	post_processing () override
	This will be called at the end of the parsing.

Protected Member Functions inherited from stir::BinNormalisation
virtual void	check (const ProjDataInfo &proj_data_info) const
	check if the argument is the same as what was used for set_up()

virtual void	check (const ExamInfo &exam_info) const

virtual void	set_key_values ()
	This will be called before parsing or parameter_info is called.

Static Protected Member Functions inherited from stir::RegisteredObject< BinNormalisation >
static RegistryType &	registry ()
	Static function returning the registry.

Protected Attributes inherited from stir::BinNormalisation
bool	_already_set_up

shared_ptr< const ProjDataInfo >	proj_data_info_sptr

KeyParser	parser

Detailed Description

A BinNormalisation class that gets the normalisation factors from an ECAT8 3D normalisation file. Note that you have to point it to the "Interfile" header.

Parsing example

 Bin Normalisation type := from ecat8
 Bin Normalisation From ECAT8:=
 normalisation filename:= myfile.n.hdr

 ; next keywords can be used to switch off some of the normalisation components
 ; do not use unless you know why.
 ; Default values are indicated below (i.e. use all of them)
 ; use_gaps:=1
 ; use_detector_efficiencies:=1
 ; use_dead_time:=1
 ; use_geometric_factors:=1
 ; use_crystal_interference_factors:=1
 ; use_axial_effects_factors:=1

 ; keyword that can be used to write the components to a separate text files for debugging
 ; files are written in the current directory and are called geom_out.txt etc.
 ; write_components_to_file := 0
 End Bin Normalisation From ECAT8:=

More information

Siemens stores axial effects, i.e. one number per sinogram. This normally limits the use of the file to data that have been acquired with the same span, which is usually 11 for present Siemens scanners.

We work around this in 2 ways:

we assume that the axial_effects_factor is the same for every ring pair contributing to a particular Siemens sinogram
if there is no corresponding Siemens sinogram (i.e. the norm file has been acquired with a particular maximum ring difference, smaller than what is actually possible with the scanner), we use an axial_effects_factor of 1. This should be reasonable as the numbers are around 1 (on the mMR).

This strategy allows us to give normalisation factor for span=1 data, even if the norm file is for span=11.

Todo: dead-time is not yet implemented

Constructor & Destructor Documentation

◆ BinNormalisationFromECAT8()

stir::ecat::BinNormalisationFromECAT8::BinNormalisationFromECAT8 ( )

Default constructor.

Warning: You should not call any member functions for any object just constructed with this constructor. Initialise the object properly first by parsing.

References BinNormalisationFromECAT8().

Referenced by BinNormalisationFromECAT8(), and BinNormalisationFromECAT8().

Member Function Documentation

◆ set_up()

Succeeded stir::ecat::BinNormalisationFromECAT8::set_up	(	const shared_ptr< const ExamInfo > &	exam_info_sptr,
		const shared_ptr< const ProjDataInfo > &	proj_data_info_sptr_v )

overridevirtual

initialises the object and checks if it can handle such projection data

Default version sets _already_set_up and stores the shared pointers.

Reimplemented from stir::BinNormalisation.

References stir::ProjDataInfoCylindrical::get_max_ring_difference(), stir::ProjDataInfo::get_num_views(), stir::BinNormalisationWithCalibration::set_up(), set_up(), and stir::warning().

Referenced by set_up().

◆ get_uncalibrated_bin_efficiency()

float stir::ecat::BinNormalisationFromECAT8::get_uncalibrated_bin_efficiency ( const Bin & bin ) const

overridevirtual

Implements stir::BinNormalisationWithCalibration.

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

/home/kris/devel/STIRdistrib/STIR/src/include/stir/recon_buildblock/BinNormalisationFromECAT8.h
/home/kris/devel/STIRdistrib/STIR/src/recon_buildblock/BinNormalisationFromECAT8.cxx

Public Member Functions