G4AttributeFilterT< T > Class Template Reference

#include <G4AttributeFilterT.hh>

Inheritance diagram for G4AttributeFilterT< T >:

Public Member Functions
	G4AttributeFilterT (const G4String &name="Unspecified")
virtual	~G4AttributeFilterT ()
virtual bool	Evaluate (const T &) const
virtual void	Print (std::ostream &ostr) const
virtual void	Clear ()
void	Set (const G4String &name)
void	AddInterval (const G4String &)
void	AddValue (const G4String &)
Public Member Functions inherited from G4SmartFilter< T >
	G4SmartFilter (const G4String &name)
virtual	~G4SmartFilter ()
virtual G4bool	Evaluate (const T &) const =0
virtual void	Print (std::ostream &ostr) const =0
virtual void	Clear ()=0
G4bool	Accept (const T &) const
virtual void	PrintAll (std::ostream &ostr) const
virtual void	Reset ()
void	SetActive (const G4bool &)
G4bool	GetActive () const
void	SetInvert (const G4bool &)
G4bool	GetInvert () const
void	SetVerbose (const G4bool &)
G4bool	GetVerbose () const
Public Member Functions inherited from G4VFilter< T >
	G4VFilter (const G4String &name)
virtual	~G4VFilter ()
virtual G4bool	Accept (const T &) const =0
virtual void	PrintAll (std::ostream &ostr) const =0
virtual void	Reset ()=0
G4String	Name () const
G4String	GetName () const

Additional Inherited Members
Public Types inherited from G4VFilter< T >
typedef T	Type

Detailed Description

template<typename T>
class G4AttributeFilterT< T >

Definition at line 44 of file G4AttributeFilterT.hh.

Constructor & Destructor Documentation

G4AttributeFilterT()

template<typename T >

G4AttributeFilterT< T >::G4AttributeFilterT

(

const G4String &

name = "Unspecified"

)

Definition at line 87 of file G4AttributeFilterT.hh.

  :G4SmartFilter<T>(name)
  ,fAttName("")
  ,fFirst(true)
  ,fWarnedMissingAttribute(false)
  ,filter(0)
{}

~G4AttributeFilterT()

template<typename T >

G4AttributeFilterT< T >::~G4AttributeFilterT

virtual

Definition at line 96 of file G4AttributeFilterT.hh.

{
  delete filter;
}

Member Function Documentation

AddInterval()

template<typename T >

void G4AttributeFilterT< T >::AddInterval

(

const G4String &

interval

)

Definition at line 205 of file G4AttributeFilterT.hh.

{
  std::pair<G4String, Config> myPair(interval, G4AttributeFilterT<T>::Interval);
 
  typename ConfigVect::iterator iter = std::find(fConfigVect.begin(), fConfigVect.end(), myPair);
  
  if (iter != fConfigVect.end()) {
    G4ExceptionDescription ed;
    ed <<"Interval "<< interval <<" already exists";
    G4Exception
      ("G4AttributeFilterT::AddInterval", "modeling0104", JustWarning, ed);
    return;
  }
 
  fConfigVect.push_back(myPair);
}

AddValue()

template<typename T >

void G4AttributeFilterT< T >::AddValue

(

const G4String &

value

)

Definition at line 224 of file G4AttributeFilterT.hh.

{
  std::pair<G4String, Config> myPair(value, G4AttributeFilterT<T>::SingleValue);
 
  typename ConfigVect::iterator iter = std::find(fConfigVect.begin(), fConfigVect.end(), myPair);
  
  if (iter != fConfigVect.end()) {
    G4ExceptionDescription ed;
    ed <<"Single value "<< value <<" already exists";
    G4Exception
      ("G4AttributeFilterT::AddValue", "modeling0105", JustWarning, ed);
    return;
  }
  fConfigVect.push_back(myPair);
}

Clear()

template<typename T >

void G4AttributeFilterT< T >::Clear

virtual

Implements G4SmartFilter< T >.

Definition at line 180 of file G4AttributeFilterT.hh.

{
  fConfigVect.clear();
  if (0 != filter) filter->Reset();
}

Evaluate()

template<typename T >

G4bool G4AttributeFilterT< T >::Evaluate ( const T &  object ) const

virtual

Implements G4SmartFilter< T >.

Definition at line 103 of file G4AttributeFilterT.hh.

{
  // Return false if attribute name has not been set. Just print one warning.
  if (fAttName.isNull()) {
 
    if (!fWarnedMissingAttribute) {
      G4Exception("G4AttributeFilterT::Evaluate", "modeling0101", JustWarning, "Null attribute name");
      fWarnedMissingAttribute = true;
    }
    
    return false;
  }
  
  if (fFirst) {
 
    fFirst = false;
 
    // Get attribute definition
    G4AttDef attDef;
    
    // Expect definition to exist    
    if (!G4AttUtils::ExtractAttDef(object, fAttName, attDef)) {
      static G4bool warnedUnableToExtract = false;
      if (!warnedUnableToExtract) {
    G4ExceptionDescription ed;
    ed <<"Unable to extract attribute definition named "<<fAttName;
    G4Exception
      ("G4AttributeFilterT::Evaluate", "modeling0102", JustWarning, ed, "Invalid attribute definition");
    G4cout << "Available attributes:\n"
           << object.GetAttDefs();
    warnedUnableToExtract = true;
      }
      return false;
    }
    
    // Get new G4AttValue filter
    filter = G4AttFilterUtils::GetNewFilter(attDef);
 
    // Load both interval and single valued data.
    typename ConfigVect::const_iterator iter = fConfigVect.begin();
    
    while (iter != fConfigVect.end()) {
      if (iter->second == G4AttributeFilterT<T>::Interval) {filter->LoadIntervalElement(iter->first);}
      else if (iter->second == G4AttributeFilterT<T>::SingleValue) {filter->LoadSingleValueElement(iter->first);}
      iter++;
    }
  }
 
  // Get attribute value
  G4AttValue attVal;
 
  // Expect value to exist
  if (!G4AttUtils::ExtractAttValue(object, fAttName, attVal)) {
    static G4bool warnedUnableToExtract = false;
    if (!warnedUnableToExtract) {
      G4ExceptionDescription ed;
      ed <<"Unable to extract attribute value named "<<fAttName;
      G4Exception
    ("G4AttributeFilterT::Evaluate", "modeling0103", JustWarning, ed, "InvalidAttributeValue");
      G4cout << "Available attributes:\n"
         << object.GetAttDefs();
      warnedUnableToExtract = true;
    }
    return false;
  }
 
  if (G4SmartFilter<T>::GetVerbose()) {
    G4cout<<"G4AttributeFilterT processing attribute named "<<fAttName;
    G4cout<<" with value "<<attVal.GetValue()<<G4endl;
  }
 
  // Pass subfilter
  return (filter->Accept(attVal));
}

Print()

template<typename T >

void G4AttributeFilterT< T >::Print ( std::ostream &  ostr ) const

virtual

Implements G4SmartFilter< T >.

Definition at line 188 of file G4AttributeFilterT.hh.

{
  ostr<<"Printing data for G4Attribute filter named: "<<G4VFilter<T>::Name()<<std::endl;
  ostr<<"Filtered attribute name: "<<fAttName<<std::endl;
  ostr<<"Printing sub filter data:"<<std::endl;
  if (0 != filter) filter->PrintAll(ostr);
}

Set()

template<typename T >

void G4AttributeFilterT< T >::Set

(

const G4String &

name

)

Definition at line 198 of file G4AttributeFilterT.hh.

{
  fAttName = name;
}

---

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

• G4AttributeFilterT.hh