Dynamic position calibration. More...

#include <JDynamics.hh>

Inheritance diagram for JDYNAMICS::JDynamics::JPosition:

Public Types
enum	{ NUMBER_OF_POINTS = 7, NUMBER_OF_DEGREES = 2 }

typedef JACOUSTICS::JGeometry	JGeometry

typedef JTOOLS::JElement2D < double, JACOUSTICS::JMODEL::JString >	element_type

typedef JTOOLS::JPolfitFunction1D < NUMBER_OF_POINTS, NUMBER_OF_DEGREES, element_type, JTOOLS::JCollection >	function_type

typedef JTOOLS::JHashMap< int, function_type >	data_type

typedef data_type::const_iterator	const_iterator

typedef data_type::const_reverse_iterator	const_reverse_iterator

typedef std::pair< T, T >	pair_type

typedef JRange< T, JComparator_t >	range_type

typedef JLANG::JClass< T > ::argument_type	argument_type

typedef T	key_type

typedef T	mapped_type

Public Member Functions
	JPosition (const JDetector &detector, const double Tmax_s)
	Constructor. More...

void	load (JObjectIterator< JACOUSTICS::JEvt > &input)
	Load calibration data. More...

bool	empty () const
	empty More...

size_t	size () const
	size More...

const_iterator	begin () const
	begin of calibration data More...

const_iterator	end () const
	end of calibration data More...

const_reverse_iterator	rbegin () const
	begin of reverse of calibration data More...

const_reverse_iterator	rend () const
	begin of reverse of calibration data More...

double	getCoverage (const JDetector &detector, const double t1_s) const
	Get coverage. More...

const JGeometry &	getGeometry () const
	Get detector geometry. More...

void	update (JDetector &detector, const double t1_s)
	Calibrate given detector at given UTC time. More...

void	reset ()
	Reset. More...

void	set (const double t0_s)
	Set. More...

const JUTCTimeRange &	getUTCTimeRange () const
	Get UTC time range. More...

void	setUTCTimeRange (const JRange< double > &timerange)
	Set UTC time range. More...

	operator pair_type () const
	Type conversion operator. More...

const range_type &	getRange () const
	Get range. More...

void	setRange (const range_type &range)
	Set range. More...

void	setRange (argument_type x, argument_type y)
	Set lower and upper limit. More...

template<class R >
void	setRange (R first, R second)
	Set range. More...

template<class JElement_t , class JAllocator_t >
void	setRange (const array_type< JElement_t, JAllocator_t > &buffer)
	Set lower and upper limit according to input data. More...

T	getLowerLimit () const
	Get lower limit. More...

T	getUpperLimit () const
	Get upper limit. More...

void	setLowerLimit (argument_type x)
	Set lower limit. More...

void	setUpperLimit (argument_type y)
	Set upper limit. More...

void	fixLowerLimit (argument_type x)
	Fix lower limit. More...

void	fixUpperLimit (argument_type y)
	Fix upper limit. More...

bool	equals (const range_type &range) const
	Equal method. More...

T	getLength () const
	Get length (difference between upper and lower limit). More...

void	setLength (argument_type length)
	Set length (difference between upper and lower limit). More...

bool	is_valid () const
	Check validity of range. More...

bool	in_range (argument_type x) const
	Test whether value is inside range. More...

bool	operator() (argument_type x) const
	Test whether value is inside range. More...

T	constrain (argument_type x) const
	Constrain value to range. More...

T	mod (argument_type x) const
	Modulo value with respect to range. More...

bool	overlap (const range_type &range) const
	Test overlap with given range. More...

range_type	include (argument_type x)
	Include given value to range. More...

range_type &	join (const range_type &range)
	Join ranges. More...

range_type &	combine (const range_type &range)
	Combine ranges. More...

range_type &	add (argument_type x)
	Add offset. More...

range_type &	add (const range_type &range)
	Add offsets. More...

range_type &	sub (argument_type x)
	Subtract offset. More...

range_type &	sub (const range_type &range)
	Subtract offsets. More...

range_type &	mul (const double factor)
	Multiply range. More...

JFirst_t &	mul (const JSecond_t &object)
	Multiply with object. More...

range_type &	div (const double factor)
	Divide range. More...

T	getN (const double R) const
	Get expected number of occurances of given rate within this interval. More...

const key_type &	getKey () const

const mapped_type &	getValue () const

mapped_type &	getValue ()

Static Public Member Functions
static T	getMinimum ()
	Get minimum possible value. More...

static T	getMaximum ()
	Get maximum possible value. More...

Public Attributes
JComparator_t	compare
	Function object. More...

T	first

T	second

Static Public Attributes
static const JRange< T, JComparator_t >	DEFAULT_RANGE
	Default range. More...

Protected Member Functions
template<class R >
void	setRange (R first, R second, const JLANG::JBool< false > &option)
	Set range. More...

template<class R >
void	setRange (R first, R second, const JLANG::JBool< true > &option)
	Set range. More...

Protected Attributes
JGeometry	geometry

data_type	calibration

Detailed Description

Dynamic position calibration.

Definition at line 278 of file JDynamics.hh.

Member Typedef Documentation

typedef JACOUSTICS::JGeometry JDYNAMICS::JDynamics::JPosition::JGeometry

Definition at line 286 of file JDynamics.hh.

typedef JTOOLS::JElement2D<double, JACOUSTICS::JMODEL::JString> JDYNAMICS::JDynamics::JPosition::element_type

Definition at line 288 of file JDynamics.hh.

typedef JTOOLS::JPolfitFunction1D<NUMBER_OF_POINTS, NUMBER_OF_DEGREES, element_type, JTOOLS::JCollection> JDYNAMICS::JDynamics::JPosition::function_type

Definition at line 291 of file JDynamics.hh.

typedef JTOOLS::JHashMap<int, function_type> JDYNAMICS::JDynamics::JPosition::data_type

Definition at line 293 of file JDynamics.hh.

typedef data_type::const_iterator JDYNAMICS::JDynamics::JPosition::const_iterator

Definition at line 295 of file JDynamics.hh.

typedef data_type::const_reverse_iterator JDYNAMICS::JDynamics::JPosition::const_reverse_iterator

Definition at line 296 of file JDynamics.hh.

template<class T, class JComparator_t = std::less<T>>

typedef std::pair<T,T> JTOOLS::JRange< T, JComparator_t >::pair_type

inherited

Definition at line 45 of file JRange.hh.

template<class T, class JComparator_t = std::less<T>>

typedef JRange<T, JComparator_t> JTOOLS::JRange< T, JComparator_t >::range_type

inherited

Definition at line 46 of file JRange.hh.

template<class T, class JComparator_t = std::less<T>>

typedef JLANG::JClass<T>::argument_type JTOOLS::JRange< T, JComparator_t >::argument_type

inherited

Definition at line 47 of file JRange.hh.

typedef T JTOOLS::JPair< T , T >::key_type

inherited

Definition at line 32 of file JPair.hh.

typedef T JTOOLS::JPair< T , T >::mapped_type

inherited

Definition at line 33 of file JPair.hh.

Member Enumeration Documentation

anonymous enum

Enumerator
NUMBER_OF_POINTS	number of points for interpolation
NUMBER_OF_DEGREES	number of degrees for interpolation

Definition at line 281 of file JDynamics.hh.

            {
         NUMBER_OF_POINTS  = 7,    //!< number of points  for interpolation
         NUMBER_OF_DEGREES = 2     //!< number of degrees for interpolation
       };

Constructor & Destructor Documentation

JDYNAMICS::JDynamics::JPosition::JPosition	(	const JDetector &	detector,
		const double	Tmax_s
	)

inline

Constructor.

Parameters

detector	detector
Tmax_s	applicability period of calibration [s]

Definition at line 305 of file JDynamics.hh.

                                          :
         JUTCTracker(Tmax_s),
         geometry(detector)
       {
         using namespace JPP;
 
         if (getDetectorVersion(detector.getVersion()) < JDetectorVersion::V4) {
           THROW(JValueOutOfRange, "Detector version " << detector.getVersion() << " < " << JDetectorVersion::V4);
         }
       }

Member Function Documentation

void JDYNAMICS::JDynamics::JPosition::load ( JObjectIterator< JACOUSTICS::JEvt > & input )

inline

Load calibration data.

Parameters

input calibration data

Definition at line 323 of file JDynamics.hh.

       {
         using namespace JPP;
         
         this->reset();
 
         while (input.hasNext()) {
 
           const JACOUSTICS::JEvt* evt = input.next();
           const double t1_s = 0.5 * (evt->UNIXTimeStart + evt->UNIXTimeStop);
 
           for (JACOUSTICS::JEvt::const_iterator i = evt->begin(); i != evt->end(); ++i) {
             calibration[i->id][t1_s] = JMODEL::JString(i->tx, i->ty);
           }
         }
 
         for (data_type::iterator i = calibration.begin(); i != calibration.end(); ++i) {
           i->second.compile();
         }
       }

bool JDYNAMICS::JDynamics::JPosition::empty ( ) const

inline

empty

Definition at line 345 of file JDynamics.hh.

size_t JDYNAMICS::JDynamics::JPosition::size ( ) const

inline

size

Definition at line 346 of file JDynamics.hh.

const_iterator JDYNAMICS::JDynamics::JPosition::begin ( ) const

inline

begin of calibration data

Definition at line 347 of file JDynamics.hh.

const_iterator JDYNAMICS::JDynamics::JPosition::end ( ) const

inline

end of calibration data

Definition at line 348 of file JDynamics.hh.

const_reverse_iterator JDYNAMICS::JDynamics::JPosition::rbegin ( ) const

inline

begin of reverse of calibration data

Definition at line 349 of file JDynamics.hh.

const_reverse_iterator JDYNAMICS::JDynamics::JPosition::rend ( ) const

inline

begin of reverse of calibration data

Definition at line 350 of file JDynamics.hh.

double JDYNAMICS::JDynamics::JPosition::getCoverage	(	const JDetector &	detector,
		const double	t1_s
	)		const

inline

Get coverage.

Parameters

detector	detector
t1_s	UTC time [s]

Returns: coverage [0,1]

Definition at line 360 of file JDynamics.hh.

       {
         int n0 = 0;
         int n1 = 0;
 
         std::set<int> string;
         
         for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {
           if (module->getFloor() != 0) {
             string.insert(module->getString());
           }
         }
 
         for (std::set<int>::const_iterator i = string.begin(); i != string.end(); ++i) {
 
           ++n0;
 
           if (calibration.has(*i) && !calibration.get(*i).empty()) {
             if (calibration[*i].getXmin() <= t1_s && 
                 calibration[*i].getXmax() >= t1_s) {
               ++n1;
             }
           }
         }
 
         return (double) n1 / (double) n0;
       }

const JGeometry& JDYNAMICS::JDynamics::JPosition::getGeometry ( ) const

inline

Get detector geometry.

Returns: detector geometry

Definition at line 394 of file JDynamics.hh.

       {
         return geometry;
       }

void JDYNAMICS::JDynamics::JPosition::update	(	JDetector &	detector,
		const double	t1_s
	)

inline

Calibrate given detector at given UTC time.

Parameters

detector	detector (I/O)
t1_s	UTC time [s]

Definition at line 406 of file JDynamics.hh.

       {
         using namespace std;
         using namespace JPP;
 
         if (!calibration.empty()) {
 
           if (!in_range(t1_s)) {
 
             JHashMap<int, JMODEL::JString> buffer;
 
             for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
               if (module->getFloor() != 0) {
 
                 if (!buffer.has(module->getString())) {
 
                   if (calibration.has(module->getString())) {
 
                     const function_type& f1 = calibration.get(module->getString());
 
                     if (!f1.empty()) {
                       if (t1_s >= f1.getXmin() && t1_s <= f1.getXmax()) {
                         buffer[module->getString()] = f1(t1_s);
                       }
                     }
                   }
                 }
 
                 if (buffer.has(module->getString())) {
                   module->set(geometry[module->getString()].getPosition(buffer[module->getString()], module->getFloor())  -  getPiezoPosition());
                 }
               }
             }
 
             set(t1_s);
           }
         }
       }

void JDYNAMICS::JDynamics::JUTCTracker::reset ( )

inlineinherited

Reset.

Definition at line 83 of file JDynamics.hh.

       {
         set(0.0);
       }

void JDYNAMICS::JDynamics::JUTCTracker::set ( const double t0_s )

inlineinherited

Set.

Parameters

t0_s	UTC time [s]

Definition at line 94 of file JDynamics.hh.

       {
         const double Tmax_s = 0.5 * (getUpperLimit() - getLowerLimit());
 
         setRange(t0_s - Tmax_s, t0_s + Tmax_s);
       }

const JUTCTimeRange& JUTC::JUTCTimeRange::getUTCTimeRange ( ) const

inlineinherited

Get UTC time range.

Returns: UTC time range

Definition at line 63 of file JUTCTimeRange.hh.

     {
       return static_cast<const JUTCTimeRange&>(*this);
     }

void JUTC::JUTCTimeRange::setUTCTimeRange ( const JRange< double > & timerange )

inlineinherited

Set UTC time range.

Parameters

timerange UTC time range

Definition at line 74 of file JUTCTimeRange.hh.

     {
       static_cast<JUTCTimeRange&>(*this) = timerange;
     }

template<class T, class JComparator_t = std::less<T>>

JTOOLS::JRange< T, JComparator_t >::operator pair_type ( ) const

inlineinherited

Type conversion operator.

Returns: piar

Definition at line 124 of file JRange.hh.

     {
       return pair_type(getLowerLimit(), getUpperLimit());
     }

template<class T, class JComparator_t = std::less<T>>

const range_type& JTOOLS::JRange< T, JComparator_t >::getRange ( ) const

inlineinherited

Get range.

Returns: range

Definition at line 135 of file JRange.hh.

     {
       return static_cast<const range_type&>(*this);
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setRange ( const range_type & range )

inlineinherited

Set range.

Parameters

range range

Definition at line 146 of file JRange.hh.

     {
       static_cast<range_type&>(*this) = range;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setRange	(	argument_type	x,
		argument_type	y
	)

inlineinherited

Set lower and upper limit.

Parameters

x	lower limit
y	upper limit

Definition at line 158 of file JRange.hh.

     {
       this->first  = x;
       this->second = y;
     }

template<class T, class JComparator_t = std::less<T>>

template<class R >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	R	first,
		R	second
	)

inlineinherited

Set range.

The arguments could be values or iterators.

Parameters

first	first
second	second

Definition at line 173 of file JRange.hh.

     {
       using namespace JLANG;
       
       setRange(first, second, JBool<is_iterator<R>::value>());
     }

template<class T, class JComparator_t = std::less<T>>

template<class JElement_t , class JAllocator_t >

void JTOOLS::JRange< T, JComparator_t >::setRange ( const array_type< JElement_t, JAllocator_t > & buffer )

inlineinherited

Set lower and upper limit according to input data.

Parameters

buffer input data

Definition at line 187 of file JRange.hh.

     {
       setRange(getMaximum(), getMinimum());
 
       for (typename array_type<JElement_t, JAllocator_t>::const_iterator i = buffer.begin(); i != buffer.end(); ++i) {
         include(*i);
       }
     }

template<class T, class JComparator_t = std::less<T>>

template<class R >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	R	first,
		R	second,
		const JLANG::JBool< false > &	option
	)

inlineprotectedinherited

Set range.

Parameters

first	first
second	second
option	false

Definition at line 589 of file JRange.hh.

     {
       setRange((argument_type) first, (argument_type) second);
     }

template<class T, class JComparator_t = std::less<T>>

template<class R >

void JTOOLS::JRange< T, JComparator_t >::setRange	(	R	first,
		R	second,
		const JLANG::JBool< true > &	option
	)

inlineprotectedinherited

Set range.

Parameters

first	first
second	second
option	true

Definition at line 603 of file JRange.hh.

     {
       setRange(getMaximum(), getMinimum());
 
       for (R i = first; i != second; ++i) {
         include(*i);
       }
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getLowerLimit ( ) const

inlineinherited

Get lower limit.

Returns: lower limit

Definition at line 202 of file JRange.hh.

     {
       return this->first;
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getUpperLimit ( ) const

inlineinherited

Get upper limit.

Returns: upper limit

Definition at line 213 of file JRange.hh.

     {
       return this->second;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setLowerLimit ( argument_type x )

inlineinherited

Set lower limit.

Parameters

x	lower limit

Definition at line 224 of file JRange.hh.

     {
       this->first  = x;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setUpperLimit ( argument_type y )

inlineinherited

Set upper limit.

Parameters

y	upper limit

Definition at line 235 of file JRange.hh.

     {
       this->second = y;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::fixLowerLimit ( argument_type x )

inlineinherited

Fix lower limit.

The range is shifted to the given lower limit.

Parameters

x	lower limit

Definition at line 248 of file JRange.hh.

     {
       this->second += x - this->first;
       this->first   = x;
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::fixUpperLimit ( argument_type y )

inlineinherited

Fix upper limit.

The range is shifted to the given upper limit.

Parameters

y	upper limit

Definition at line 262 of file JRange.hh.

     {
       this->first  += y - this->second;
       this->second  = y;
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::equals ( const range_type & range ) const

inlineinherited

Equal method.

Parameters

range range

Returns: true if this module range equal to given module range; else false

Definition at line 275 of file JRange.hh.

     {
       return (!this->compare(this->getLowerLimit(), range.getLowerLimit()) &&
               !this->compare(range.getLowerLimit(), this->getLowerLimit()) &&
               !this->compare(this->getUpperLimit(), range.getUpperLimit()) &&
               !this->compare(range.getUpperLimit(), this->getUpperLimit()));
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getLength ( ) const

inlineinherited

Get length (difference between upper and lower limit).

Returns: length

Definition at line 289 of file JRange.hh.

     {
       return getUpperLimit() - getLowerLimit();
     }

template<class T, class JComparator_t = std::less<T>>

void JTOOLS::JRange< T, JComparator_t >::setLength ( argument_type length )

inlineinherited

Set length (difference between upper and lower limit).

Parameters

length length

Definition at line 300 of file JRange.hh.

     {
       setUpperLimit(getLowerLimit() + length);
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::is_valid ( ) const

inlineinherited

Check validity of range.

Returns: true if lower limit less than or equal to upper limit; else false

Definition at line 311 of file JRange.hh.

     {
       return !compare(getUpperLimit(), getLowerLimit());
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::in_range ( argument_type x ) const

inlineinherited

Test whether value is inside range.

Parameters

x value

Returns: true if lower limit <= value <= upper limit; else false

Definition at line 323 of file JRange.hh.

     {
       return (!compare(x, getLowerLimit()) && 
               !compare(getUpperLimit(), x));
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::operator() ( argument_type x ) const

inlineinherited

Test whether value is inside range.

Parameters

x value

Returns: true if lower limit <= value <= upper limit; else false

Definition at line 336 of file JRange.hh.

     {
       return in_range(x);
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::constrain ( argument_type x ) const

inlineinherited

Constrain value to range.

This method returns the original value if it is in this range, else lower limit if value < lower limit or upper limit if value > upper limit.

Parameters

x value

Returns: lower limit <= x <= upper limit

Definition at line 350 of file JRange.hh.

     {
       if (compare(x, getLowerLimit())) { return getLowerLimit(); }
       if (compare(getUpperLimit(), x)) { return getUpperLimit(); }
 
       return x;
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::mod ( argument_type x ) const

inlineinherited

Modulo value with respect to range.

Parameters

x value

Returns: lower limit <= x <= upper limit

Definition at line 365 of file JRange.hh.

     {
       if      (compare(x, getLowerLimit()))
         return x + getLength() * floor((getUpperLimit() - x) / getLength());
       else if (compare(getUpperLimit(), x))
         return x - getLength() * floor((x - getLowerLimit()) / getLength());
       else
         return x;
     }

template<class T, class JComparator_t = std::less<T>>

bool JTOOLS::JRange< T, JComparator_t >::overlap ( const range_type & range ) const

inlineinherited

Test overlap with given range.

The result is equivalent to join(range).is_valid().

Parameters

range range

Returns: true if there is a non-zero overlap; else false

Definition at line 383 of file JRange.hh.

     {  
       return (compare(getLowerLimit(), range.getUpperLimit()) &&
               compare(range.getLowerLimit(), getUpperLimit()));
     }

template<class T, class JComparator_t = std::less<T>>

range_type JTOOLS::JRange< T, JComparator_t >::include ( argument_type x )

inlineinherited

Include given value to range.

The new lower limit is the minimim of the original lower limit and given value and
the new upper limit is the maximum of the original upper limit and given value;

Parameters

x value

Returns: range

Definition at line 398 of file JRange.hh.

     {
       if (compare(x, getLowerLimit())) { setLowerLimit(x); }
       if (compare(getUpperLimit(), x)) { setUpperLimit(x); }
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::join ( const range_type & range )

inlineinherited

Join ranges.

The new lower limit is the maximim of the two lower limits and
the new upper limit is the minimum of the two upper limits.
This operation results in an equal or smaller range and may result in an unphysical range (i.e. lower limit > upper limit).

Parameters

range range

Definition at line 416 of file JRange.hh.

     {  
       if (compare(getLowerLimit(), range.getLowerLimit())) { setLowerLimit(range.getLowerLimit()); }
       if (compare(range.getUpperLimit(), getUpperLimit())) { setUpperLimit(range.getUpperLimit()); }
 
       return *this;      
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::combine ( const range_type & range )

inlineinherited

Combine ranges.

The new lower limit is the minimim of the two lower limits and
the new upper limit is the maximum of the two upper limits.
This operation results in an equal or larger range.

Parameters

range range

Definition at line 433 of file JRange.hh.

     {  
       if (compare(range.getLowerLimit(), getLowerLimit())) { setLowerLimit(range.getLowerLimit()); }
       if (compare(getUpperLimit(), range.getUpperLimit())) { setUpperLimit(range.getUpperLimit()); }
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::add ( argument_type x )

inlineinherited

Add offset.

Parameters

x offset

Definition at line 447 of file JRange.hh.

     { 
       this->first  += x;
       this->second += x;
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::add ( const range_type & range )

inlineinherited

Add offsets.

The new lower limit is the sum of the two lower limits and
the new upper limit is the sum of the two upper limits.

Parameters

range offset

Definition at line 477 of file JRange.hh.

     { 
       this->first  += range.getLowerLimit();
       this->second += range.getUpperLimit();
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::sub ( argument_type x )

inlineinherited

Subtract offset.

Parameters

x offset

Definition at line 461 of file JRange.hh.

     { 
       this->first  -= x;
       this->second -= x;
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::sub ( const range_type & range )

inlineinherited

Subtract offsets.

The new lower limit is the difference of the two lower limits and
the new upper limit is the difference of the two upper limits.

Parameters

range offset

Definition at line 493 of file JRange.hh.

     { 
       this->first  -= range.getLowerLimit();
       this->second -= range.getUpperLimit();
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::mul ( const double factor )

inlineinherited

Multiply range.

Parameters

factor factor

Definition at line 507 of file JRange.hh.

     { 
       this->first  *= factor;
       this->second *= factor;
 
       return *this;
     }

template<class JFirst_t, class JSecond_t = JNullType>

JFirst_t& JMATH::JMath< JFirst_t, JSecond_t >::mul ( const JSecond_t & object )

inlineinherited

Multiply with object.

Parameters

object object

Returns: result object

Definition at line 357 of file JMath.hh.

     {
       return static_cast<JFirst_t&>(*this) = JCalculator<JFirst_t>::calculator.mul(static_cast<const JFirst_t&>(*this), object);
     }

template<class T, class JComparator_t = std::less<T>>

range_type& JTOOLS::JRange< T, JComparator_t >::div ( const double factor )

inlineinherited

Divide range.

Parameters

factor factor

Definition at line 521 of file JRange.hh.

     { 
       this->first  /= factor;
       this->second /= factor;
 
       return *this;
     }

template<class T, class JComparator_t = std::less<T>>

T JTOOLS::JRange< T, JComparator_t >::getN ( const double R ) const

inlineinherited

Get expected number of occurances of given rate within this interval.

Parameters

R rate

Returns: expectation value

Definition at line 536 of file JRange.hh.

     {
       return R * (getUpperLimit() - getLowerLimit());
     }

template<class T, class JComparator_t = std::less<T>>

static T JTOOLS::JRange< T, JComparator_t >::getMinimum ( )

inlinestaticinherited

Get minimum possible value.

Returns: minimum possible value

Definition at line 547 of file JRange.hh.

     { 
       return JMATH::JLimits<T>::min();
     }

template<class T, class JComparator_t = std::less<T>>

static T JTOOLS::JRange< T, JComparator_t >::getMaximum ( )

inlinestaticinherited

Get maximum possible value.

Returns: maximum possible value

Definition at line 558 of file JRange.hh.

     { 
       return JMATH::JLimits<T>::max();
     }

const key_type& JTOOLS::JPair< T , T >::getKey ( ) const

inlineinherited

Definition at line 123 of file JPair.hh.

123 { return this->first; }

JTOOLS::JPair< T, T >::first

T first

Definition: JPair.hh:128

const mapped_type& JTOOLS::JPair< T , T >::getValue ( ) const

inlineinherited

Definition at line 124 of file JPair.hh.

124 { return this->second; }

JTOOLS::JPair< T, T >::second

T second

Definition: JPair.hh:129

mapped_type& JTOOLS::JPair< T , T >::getValue ( )

inlineinherited

Definition at line 126 of file JPair.hh.

126 { return this->second; }

JTOOLS::JPair< T, T >::second

T second

Definition: JPair.hh:129

Member Data Documentation

JGeometry JDYNAMICS::JDynamics::JPosition::geometry

protected

Definition at line 447 of file JDynamics.hh.

data_type JDYNAMICS::JDynamics::JPosition::calibration

protected

Definition at line 448 of file JDynamics.hh.

template<class T, class JComparator_t = std::less<T>>

const JRange< T, JComparator_t > JTOOLS::JRange< T, JComparator_t >::DEFAULT_RANGE

staticinherited

Default range.

This range corresponds to an unphysical range.

Definition at line 568 of file JRange.hh.

template<class T, class JComparator_t = std::less<T>>

JComparator_t JTOOLS::JRange< T, JComparator_t >::compare

inherited

Function object.

Parameters

first	first argument
second	second argument

Returns: true if first < second; else false

Definition at line 578 of file JRange.hh.

T JTOOLS::JPair< T , T >::first

inherited

Definition at line 128 of file JPair.hh.

T JTOOLS::JPair< T , T >::second

inherited

Definition at line 129 of file JPair.hh.

The documentation for this struct was generated from the following file:

JDynamics.hh

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation