G4BestUnit Class Reference

#include <G4UnitsTable.hh>

Public Member Functions
	G4BestUnit (G4double internalValue, const G4String &category)
	G4BestUnit (const G4ThreeVector &internalValue, const G4String &category)
	~G4BestUnit ()=default
G4double *	GetValue ()
const G4String &	GetCategory () const
std::size_t	GetIndexOfCategory () const
	operator G4String () const

Friends
std::ostream &	operator<< (std::ostream &flux, const G4BestUnit &VU)

Detailed Description

Definition at line 158 of file G4UnitsTable.hh.

Constructor & Destructor Documentation

G4BestUnit() [1/2]

G4BestUnit::G4BestUnit	(	G4double	internalValue,
		const G4String &	category )

Definition at line 523 of file G4UnitsTable.cc.

  : nbOfVals(1)
{
  // find the category
  G4UnitsTable& theUnitsTable = G4UnitDefinition::GetUnitsTable();
  std::size_t nbCat           = theUnitsTable.size();
  std::size_t i               = 0;
  while((i < nbCat) && (theUnitsTable[i]->GetName() != category))
  {
    ++i;
  }
  if(i == nbCat)
  {
    G4cout << " G4BestUnit: the category " << category << " does not exist !!"
           << G4endl;
    G4Exception("G4BestUnit::G4BestUnit()", "InvalidCall", FatalException,
                "Missing unit category !");
  }
 
  Value[0]        = value;
  Value[1]        = 0.;
  Value[2]        = 0.;
  Category        = category;
  IndexOfCategory = i;
}

Referenced by G4BestUnit(), and G4BestUnit().

G4BestUnit() [2/2]

G4BestUnit::G4BestUnit	(	const G4ThreeVector &	internalValue,
		const G4String &	category )

Definition at line 551 of file G4UnitsTable.cc.

  : nbOfVals(3)
{
  // find the category
  G4UnitsTable& theUnitsTable = G4UnitDefinition::GetUnitsTable();
  std::size_t nbCat           = theUnitsTable.size();
  std::size_t i               = 0;
  while((i < nbCat) && (theUnitsTable[i]->GetName() != category))
  {
    ++i;
  }
  if(i == nbCat)
  {
    G4cerr << " G4BestUnit: the category " << category << " does not exist."
           << G4endl;
    G4Exception("G4BestUnit::G4BestUnit()", "InvalidCall", FatalException,
                "Missing unit category !");
  }
 
  Value[0]        = value.x();
  Value[1]        = value.y();
  Value[2]        = value.z();
  Category        = category;
  IndexOfCategory = i;
}

~G4BestUnit()

G4BestUnit::~G4BestUnit ( )

default

Member Function Documentation

GetCategory()

const G4String & G4BestUnit::GetCategory ( ) const

inline

GetIndexOfCategory()

std::size_t G4BestUnit::GetIndexOfCategory ( ) const

inline

GetValue()

G4double * G4BestUnit::GetValue ( )

inline

operator G4String()

G4BestUnit::operator G4String

(

)

const

Definition at line 579 of file G4UnitsTable.cc.

{
  std::ostringstream oss;
  oss << *this;
  return oss.str();
}

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & flux, const G4BestUnit & VU )

friend

Definition at line 588 of file G4UnitsTable.cc.

{
  G4UnitsTable& theUnitsTable = G4UnitDefinition::GetUnitsTable();
  G4UnitsContainer& List = theUnitsTable[a.IndexOfCategory]->GetUnitsList();
  G4int len              = theUnitsTable[a.IndexOfCategory]->GetSymbMxLen();
 
  G4long ksup(-1), kinf(-1);
  G4double umax(0.), umin(DBL_MAX);
  G4double rsup(DBL_MAX), rinf(0.);
 
  // for a ThreeVector, choose the best unit for the biggest value
  G4double value =
    std::max(std::max(std::fabs(a.Value[0]), std::fabs(a.Value[1])),
             std::fabs(a.Value[2]));
 
  //special treatement for Energy.
  if ((a.Category == "Energy") && (value == 0.)) {
    for (G4int j = 0; j < a.nbOfVals; ++j) {
       flux << a.Value[j] << " ";
    }
    std::ios::fmtflags oldform = flux.flags();
    flux.setf(std::ios::left, std::ios::adjustfield);
    flux << std::setw(len) << "eV";
    flux.flags(oldform);
    return flux;
  }      
         
  //here, value != 0.
  for(std::size_t k = 0; k < List.size(); ++k)
  {
    G4double unit = List[k]->GetValue();
    if(!(value != DBL_MAX))
    {
      if(unit > umax)
      {
        umax = unit;
        ksup = k;
      }
    }
    else if(value <= DBL_MIN)
    {
      if(unit < umin)
      {
        umin = unit;
        kinf = k;
      }
    }
    else
    {
      G4double ratio = value / unit;
      if((ratio >= 1.) && (ratio < rsup))
      {
        rsup = ratio;
        ksup = k;
      }
      if((ratio < 1.) && (ratio > rinf))
      {
        rinf = ratio;
        kinf = k;
      }
    }
  }
 
  G4long index = ksup;
  if(index == -1)
  {
    index = kinf;
  }
  if(index == -1)
  {
    index = 0;
  }
 
  for(G4int j = 0; j < a.nbOfVals; ++j)
  {
    flux << a.Value[j] / (List[index]->GetValue()) << " ";
  }
 
  std::ios::fmtflags oldform = flux.flags();
 
  flux.setf(std::ios::left, std::ios::adjustfield);
  flux << std::setw(len) << List[index]->GetSymbol();
  flux.flags(oldform);
 
  return flux;
}

---

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

• G4UnitsTable.hh
• G4UnitsTable.cc