G4AttributeFilterT< T > Class Template Reference

#include <G4AttributeFilterT.hh>

Inheritance diagram for G4AttributeFilterT< T >:

Public Types
typedef T	Type

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

Private Types
enum	Config { Interval , SingleValue }
typedef std::vector< Pair >	ConfigVect
typedef std::pair< G4String, Config >	Pair

Private Attributes
G4bool	fActive
G4String	fAttName
ConfigVect	fConfigVect
G4bool	fFirst
G4VAttValueFilter *	filter
G4bool	fInvert
G4String	fName
size_t	fNPassed
size_t	fNProcessed
G4bool	fVerbose

Detailed Description

template<typename T>
class G4AttributeFilterT< T >

Definition at line 43 of file G4AttributeFilterT.hh.

Member Typedef Documentation

ConfigVect

template<typename T >

typedef std::vector<Pair> G4AttributeFilterT< T >::ConfigVect

private

Definition at line 72 of file G4AttributeFilterT.hh.

Pair

template<typename T >

typedef std::pair<G4String, Config> G4AttributeFilterT< T >::Pair

private

Definition at line 71 of file G4AttributeFilterT.hh.

Type

template<typename T >

typedef T G4VFilter< T >::Type

inherited

Definition at line 43 of file G4VFilter.hh.

Member Enumeration Documentation

Config

template<typename T >

enum G4AttributeFilterT::Config

private

Enumerator
Interval
SingleValue

Definition at line 69 of file G4AttributeFilterT.hh.

{Interval, SingleValue};

Constructor & Destructor Documentation

G4AttributeFilterT()

template<typename T >

G4AttributeFilterT< T >::G4AttributeFilterT

(

const G4String &

name = "Unspecified"

)

Definition at line 85 of file G4AttributeFilterT.hh.

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

~G4AttributeFilterT()

template<typename T >

G4AttributeFilterT< T >::~G4AttributeFilterT

virtual

Definition at line 93 of file G4AttributeFilterT.hh.

{
  delete filter;
}

Member Function Documentation

Accept()

template<typename T >

G4bool G4SmartFilter< T >::Accept ( const T &  object ) const

virtualinherited

Implements G4VFilter< T >.

Definition at line 104 of file G4SmartFilter.hh.

{
  if (fVerbose) {
    G4cout<<"Begin verbose printout for filter "<<G4VFilter<T>::Name()<<G4endl;
    G4cout<<"Active ? :   "<<fActive<<G4endl;
  }
  
  fNProcessed++;
  
  // Pass everything if filter is not active
  if (!fActive) {
    fNPassed++;
    return true;
  }
  
  // Do filtering
  G4bool passed = Evaluate(object);
  
  // Apply inversion if applicable
  if (fInvert) passed = !passed;
  
  if (passed) fNPassed++;
  
  if (fVerbose) {
    G4cout<<"Inverted ? : "<<fInvert<<G4endl;
    G4cout<<"Passed ?   : "<<passed<<G4endl;
    G4cout<<"End verbose printout for filter "<<G4VFilter<T>::Name()<<G4endl;
  }
  
  return passed;
}

References G4cout, G4endl, and G4VFilter< T >::Name().

AddInterval()

template<typename T >

void G4AttributeFilterT< T >::AddInterval

(

const G4String &

interval

)

Definition at line 197 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);
}

References G4Exception(), and JustWarning.

AddValue()

template<typename T >

void G4AttributeFilterT< T >::AddValue

(

const G4String &

value

)

Definition at line 216 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);
}

References G4Exception(), and JustWarning.

Clear()

template<typename T >

void G4AttributeFilterT< T >::Clear

virtual

Implements G4SmartFilter< T >.

Definition at line 172 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 100 of file G4AttributeFilterT.hh.

{
  // Return true (i.e., do not filter out) if attribute name has not yet been set.
  if (fAttName.empty()) return true;
  
  // ...or required attribute value has not yet been set
  if (fConfigVect.size() == 0) return true;
 
  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");
    G4cerr << "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");
      G4cerr << "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));
}

References G4AttUtils::ExtractAttDef(), G4AttUtils::ExtractAttValue(), G4cerr, G4cout, G4endl, G4Exception(), G4AttFilterUtils::GetNewFilter(), G4AttValue::GetValue(), and JustWarning.

GetActive()

template<typename T >

G4bool G4SmartFilter< T >::GetActive

inherited

Definition at line 172 of file G4SmartFilter.hh.

{
  return fActive;
}

GetInvert()

template<typename T >

G4bool G4SmartFilter< T >::GetInvert

inherited

Definition at line 186 of file G4SmartFilter.hh.

{
  return fInvert;
}

GetName()

template<typename T >

G4String G4VFilter< T >::GetName

inherited

Definition at line 87 of file G4VFilter.hh.

{
  return Name();
}

GetVerbose()

template<typename T >

G4bool G4SmartFilter< T >::GetVerbose

inherited

Definition at line 200 of file G4SmartFilter.hh.

{
  return fVerbose;
}

Name()

template<typename T >

G4String G4VFilter< T >::Name

inherited

Definition at line 80 of file G4VFilter.hh.

{
  return fName;
}

Referenced by G4SmartFilter< T >::Accept(), G4AttributeFilterT< T >::Print(), and G4SmartFilter< T >::PrintAll().

Print()

template<typename T >

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

virtual

Implements G4SmartFilter< T >.

Definition at line 180 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);
}

References G4VFilter< T >::Name().

PrintAll()

template<typename T >

void G4SmartFilter< T >::PrintAll ( std::ostream &  ostr ) const

virtualinherited

Implements G4VFilter< T >.

Definition at line 138 of file G4SmartFilter.hh.

{
  ostr<<"Printing data for filter: "<<G4VFilter<T>::Name()<<G4endl;
 
  Print(ostr);
 
  ostr<<"Active ?   : " <<fActive<<G4endl;
  ostr<<"Inverted ? : " <<fInvert<<G4endl;
  ostr<<"#Processed : " <<fNProcessed<<G4endl;
  ostr<<"#Passed    : " <<fNPassed<<G4endl;
}

References G4endl, G4VFilter< T >::Name(), and pyG4Element::Print().

Reset()

template<typename T >

void G4SmartFilter< T >::Reset

virtualinherited

Implements G4VFilter< T >.

Definition at line 152 of file G4SmartFilter.hh.

{
  fActive = true;
  fInvert = false;
  fNProcessed = 0;
  fNPassed = 0;
  
  // Clear subclass data
  Clear();
}

Set()

template<typename T >

void G4AttributeFilterT< T >::Set

(

const G4String &

name

)

Definition at line 190 of file G4AttributeFilterT.hh.

{
  fAttName = name;
}

References G4InuclParticleNames::name().

SetActive()

template<typename T >

void G4SmartFilter< T >::SetActive ( const G4bool &  active )

inherited

Definition at line 165 of file G4SmartFilter.hh.

{
  fActive = active;
}

SetInvert()

template<typename T >

void G4SmartFilter< T >::SetInvert ( const G4bool &  invert )

inherited

Definition at line 179 of file G4SmartFilter.hh.

{
  fInvert = invert;
}

SetVerbose()

template<typename T >

void G4SmartFilter< T >::SetVerbose ( const G4bool &  verbose )

inherited

Definition at line 193 of file G4SmartFilter.hh.

{
  fVerbose = verbose;
}

Field Documentation

fActive

template<typename T >

G4bool G4SmartFilter< T >::fActive

privateinherited

Definition at line 81 of file G4SmartFilter.hh.

fAttName

template<typename T >

G4String G4AttributeFilterT< T >::fAttName

private

Definition at line 75 of file G4AttributeFilterT.hh.

fConfigVect

template<typename T >

ConfigVect G4AttributeFilterT< T >::fConfigVect

private

Definition at line 76 of file G4AttributeFilterT.hh.

fFirst

template<typename T >

G4bool G4AttributeFilterT< T >::fFirst

mutableprivate

Definition at line 79 of file G4AttributeFilterT.hh.

filter

template<typename T >

G4VAttValueFilter* G4AttributeFilterT< T >::filter

mutableprivate

Definition at line 80 of file G4AttributeFilterT.hh.

fInvert

template<typename T >

G4bool G4SmartFilter< T >::fInvert

privateinherited

Definition at line 82 of file G4SmartFilter.hh.

fName

template<typename T >

G4String G4VFilter< T >::fName

privateinherited

Definition at line 66 of file G4VFilter.hh.

fNPassed

template<typename T >

size_t G4SmartFilter< T >::fNPassed

mutableprivateinherited

Definition at line 84 of file G4SmartFilter.hh.

fNProcessed

template<typename T >

size_t G4SmartFilter< T >::fNProcessed

mutableprivateinherited

Definition at line 85 of file G4SmartFilter.hh.

fVerbose

template<typename T >

G4bool G4SmartFilter< T >::fVerbose

privateinherited

Definition at line 83 of file G4SmartFilter.hh.

---

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

• source/visualization/modeling/include/G4AttributeFilterT.hh