#include <G4MoleculeCounterTimeComparer.hh>

Public Types
enum	TimeComparerType { FixedPrecision , VariablePrecision }

Public Member Functions
	G4MoleculeCounterTimeComparer ()
virtual	~G4MoleculeCounterTimeComparer ()=default
	G4MoleculeCounterTimeComparer (const G4MoleculeCounterTimeComparer &)
G4MoleculeCounterTimeComparer &	operator= (const G4MoleculeCounterTimeComparer &)
void	SetFixedPrecision (G4double)
void	SetVariablePrecision (const std::vector< G4double > &, const std::vector< G4double > &)
void	SetVariablePrecision (const std::map< G4double, G4double > &)
G4double	GetPrecisionAtTime (G4double) const
bool	operator() (const G4double &, const G4double &) const

Static Public Member Functions
static G4MoleculeCounterTimeComparer	CreateWithFixedPrecision (G4double)
static G4MoleculeCounterTimeComparer	CreateWithVariablePrecision (const std::map< G4double, G4double > &)

Detailed Description

Definition at line 35 of file G4MoleculeCounterTimeComparer.hh.

Member Enumeration Documentation

◆ TimeComparerType

enum G4MoleculeCounterTimeComparer::TimeComparerType

Enumerator
FixedPrecision
VariablePrecision

Definition at line 38 of file G4MoleculeCounterTimeComparer.hh.

    {
      FixedPrecision,
      VariablePrecision
    };

Constructor & Destructor Documentation

◆ G4MoleculeCounterTimeComparer() [1/2]

G4MoleculeCounterTimeComparer::G4MoleculeCounterTimeComparer ( )

Definition at line 32 of file G4MoleculeCounterTimeComparer.cc.

33 : fType(TimeComparerType::FixedPrecision)

34{}

Referenced by CreateWithFixedPrecision(), CreateWithVariablePrecision(), G4MoleculeCounterTimeComparer(), operator=(), and ~G4MoleculeCounterTimeComparer().

◆ ~G4MoleculeCounterTimeComparer()

virtual G4MoleculeCounterTimeComparer::~G4MoleculeCounterTimeComparer ( )

virtualdefault

◆ G4MoleculeCounterTimeComparer() [2/2]

G4MoleculeCounterTimeComparer::G4MoleculeCounterTimeComparer ( const G4MoleculeCounterTimeComparer & other )

Definition at line 36 of file G4MoleculeCounterTimeComparer.cc.

{
  *this = other;
}

Member Function Documentation

◆ CreateWithFixedPrecision()

G4MoleculeCounterTimeComparer G4MoleculeCounterTimeComparer::CreateWithFixedPrecision ( G4double precision )

static

Definition at line 127 of file G4MoleculeCounterTimeComparer.cc.

{
  auto obj = G4MoleculeCounterTimeComparer();
  obj.SetFixedPrecision(precision);
  return obj;
}

◆ CreateWithVariablePrecision()

G4MoleculeCounterTimeComparer G4MoleculeCounterTimeComparer::CreateWithVariablePrecision ( const std::map< G4double, G4double > & map )

static

Definition at line 135 of file G4MoleculeCounterTimeComparer.cc.

{
  auto obj = G4MoleculeCounterTimeComparer();
  obj.SetVariablePrecision(map);
  return obj;
}

◆ GetPrecisionAtTime()

G4double G4MoleculeCounterTimeComparer::GetPrecisionAtTime ( G4double time ) const

Definition at line 92 of file G4MoleculeCounterTimeComparer.cc.

{
  if (fType == G4MoleculeCounterTimeComparer::FixedPrecision)
    return fPrecision;
  else
    return fVariablePrecision.upper_bound(time)->second;
}

◆ operator()()

G4bool G4MoleculeCounterTimeComparer::operator()	(	const G4double &	a,
		const G4double &	b ) const

Definition at line 100 of file G4MoleculeCounterTimeComparer.cc.

{
  if (fType == G4MoleculeCounterTimeComparer::FixedPrecision) {
    if (std::fabs(a - b) < fPrecision) {
      return false;
    }
  }
  else if (fType == G4MoleculeCounterTimeComparer::VariablePrecision) {
    const auto it_a = fVariablePrecision.upper_bound(a);
    const auto it_b = fVariablePrecision.upper_bound(b);
    auto precision = fVariablePrecision.crbegin()->second;
    if (it_a != fVariablePrecision.cend() && it_b != fVariablePrecision.cend())
      precision = std::min(it_a->second, it_b->second);
    if (std::fabs(a - b) < precision) {
      return false;
    }
  }
  else {
    G4Exception("G4MoleculeCounterTimeComparer::operator()", "G4MoleculeCounterTimeComparer",
                FatalException, "Unknown comparison type");
  }
  return a < b;
}

◆ operator=()

G4MoleculeCounterTimeComparer & G4MoleculeCounterTimeComparer::operator= ( const G4MoleculeCounterTimeComparer & other )

Definition at line 43 of file G4MoleculeCounterTimeComparer.cc.

{
  switch (other.fType) {
    case TimeComparerType::VariablePrecision:
      SetVariablePrecision(other.fVariablePrecision);
      break;
    case TimeComparerType::FixedPrecision:
    default:
      SetFixedPrecision(other.fPrecision);
      break;
  }
  return *this;
}

◆ SetFixedPrecision()

void G4MoleculeCounterTimeComparer::SetFixedPrecision ( G4double precision )

Definition at line 57 of file G4MoleculeCounterTimeComparer.cc.

{
  fType = TimeComparerType::FixedPrecision;
  fPrecision = precision;
}

Referenced by operator=().

◆ SetVariablePrecision() [1/2]

void G4MoleculeCounterTimeComparer::SetVariablePrecision ( const std::map< G4double, G4double > & resolutionMap )

Definition at line 80 of file G4MoleculeCounterTimeComparer.cc.

{
  fType = TimeComparerType::VariablePrecision;
  fVariablePrecision = resolutionMap;
 
  if (fVariablePrecision.empty()) {
    G4Exception("G4MoleculeCounterTimeComparer::SetVariablePrecision()",
                "G4MoleculeCounterTimeComparer", FatalException, "Precision map cannot be empty!");
  }
}

◆ SetVariablePrecision() [2/2]

void G4MoleculeCounterTimeComparer::SetVariablePrecision	(	const std::vector< G4double > &	globalTimeHighEdges,
		const std::vector< G4double > &	resolutions )

Definition at line 63 of file G4MoleculeCounterTimeComparer.cc.

{
  fType = TimeComparerType::VariablePrecision;
  fVariablePrecision.clear();
  for (auto key = globalTimeHighEdges.cbegin(), val = resolutions.cbegin();
       key != globalTimeHighEdges.cend() && val != resolutions.cend(); ++key, ++val)
  {
    fVariablePrecision.emplace(*key, *val);
  }
 
  if (fVariablePrecision.empty()) {
    G4Exception("G4MoleculeCounterTimeComparer::SetVariablePrecision()",
                "G4MoleculeCounterTimeComparer", FatalException, "Precision map cannot be empty!");
  }
}