class TreeSearch::PatternGenerator


TreeSearch::PatternGenerator

Function Members (Methods)

public:

virtual	~PatternGenerator()
static TClass*	Class()
TreeSearch::PatternTree*	Generate(TreeSearch::TreeParam_t parameters)
TreeSearch::PatternTree*	Generate(UInt_t maxdepth, Double_t detector_width, const char* zpos, Double_t maxslope)
TreeSearch::Pattern*	GetRoot() const
const TreeSearch::PatternGenerator::Statistics_t&	GetStatistics() const
virtual TClass*	IsA() const
TreeSearch::PatternGenerator&	operator=(const TreeSearch::PatternGenerator&)
TreeSearch::PatternGenerator	PatternGenerator()
TreeSearch::PatternGenerator	PatternGenerator(const TreeSearch::PatternGenerator&)
void	Print(Option_t* opt = "", ostream& os = std::cout) const
virtual void	ShowMembers(TMemberInspector& insp, char* parent)
virtual void	Streamer(TBuffer& b)
void	StreamerNVirtual(TBuffer& b)

private:

TreeSearch::PatternGenerator::HashNode*	AddHash(TreeSearch::Pattern* pat)
void	CalcStatistics()
void	ClearStatistics()
void	DeleteTree()
TreeSearch::PatternGenerator::HashNode*	Find(const TreeSearch::Pattern& pat)
UInt_t	Hash(const TreeSearch::Pattern& pat) const
bool	LineTest(const TreeSearch::Pattern& pat) const
void	MakeChildNodes(TreeSearch::PatternGenerator::HashNode* parent, UInt_t depth)
bool	SlopeTest(const TreeSearch::Pattern& pat, UInt_t depth) const

Data Members

private:

vector<HashNode>	fHashTable	Hashtab for indexing patterns during build
Double_t	fMaxSlope	Max allowed slope, normalized units (0-1)
UInt_t	fNlevels	Number of levels of the tree (0-nlevels-1)
UInt_t	fNplanes	Number of hitpattern planes
TreeSearch::PatternGenerator::Statistics_t	fStats	Tree statistics
vector<double>	fZ	z positions of planes, normalized (0-1)

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

PatternGenerator()

 Constructor

~PatternGenerator()

 Destructor

void DeleteTree()

 Delete the build tree along with its hash table.
 Internal utility function.

void CalcStatistics()

 Collect statistics on the build tree. This is best done separately here
 because some things (averages, memory requirements) can only be
 calculated once the tree is complete.

void ClearStatistics()

void Print(Option_t* opt = "", ostream& os = std::cout) const

 Print information about the tree, depending on option

PatternTree* Generate(TreeSearch::TreeParam_t parameters)

 Generate a new pattern tree for the given parameters. Returns a pointer
 to the generated tree, or zero if error

PatternTree* Generate(UInt_t maxdepth, Double_t detector_width, const char* zpos, Double_t maxslope)

 Convenience function for use at the command line and in scripts

UInt_t Hash(const TreeSearch::Pattern& pat) const

 Calculate unique a hash value for the given pattern. The maximum value is
 2^(fNlevels-1 + fNplanes-2) - 1. With the hash computed here, collisions
 never occur for patterns that pass LineTest().

bool SlopeTest(const TreeSearch::Pattern& pat, UInt_t depth) const

bool LineTest(const TreeSearch::Pattern& pat) const

 Check if the given bit pattern is consistent with a straight line.
 The intersection plane positions are given by fZ[]. Assumes fZ[0]=0.
 The other z values must increase strictly monotonically, fZ{i] > fZ[i-1].
 In the parent class, the z-values are normalized so that
 fZ[fNplanes-1] = 1.0, but that is not required.
 Assumes a normalized pattern, for which pat[0] is always zero.
 Assumes identical bin sizes and bin boundaries in each plane.
 If any of these assumption are relaxed, the algorithm requires additional
 tests and might need to save some data in temporary variables.

 The algorithm works by computing left and right boundary lines within
 which a bin must lie. The boundaries are the connections between the
 top and bottom reference points, (SL, SR) and (BL, BR), respectively.
 Starting from the plane one below the top (fZ[fNplanes-2]), bins in
 successively lower planes are tested to lie in the allowed region. If they
 do, the boundaries are narrowed if necessary to ensure that subsequent
 bins are consistent with all bins above. If the test succeeds in all
 planes, the pattern is consistent with a line.

 Algorithm originally developed by Brandon Belew, SULI summer intern,
 Jefferson Lab, 2007.

void MakeChildNodes(TreeSearch::PatternGenerator::HashNode* parent, UInt_t depth)

 Generate child nodes for the given parent pattern

PatternGenerator()

    friend class Test_PatternGenerator;

Pattern* GetRoot() const

{ return fHashTable[0].fPattern; }

const Statistics_t& GetStatistics() const

{ return fStats; }

HashNode* AddHash(TreeSearch::Pattern* pat)

HashNode* Find(const TreeSearch::Pattern& pat)