CGate

Constructs the base class. The gate is set with the cache invalid. The state of the cached value is therefore meaningless.

If the gate has a valid cached value returns kfTRUE. Otherwise returns kfFALSE

If the gate has a cached value (getChecked returns kfTRUE) returns the cached value for that gate. kfTRUE means the gate was satisifed by its last check. kfFALSE means the gate was not satisfied. If getChecked returns kfFalse, the return value from this method has no meaning.

Sets the new value for the gate. If called after this method call, getChecked will return kfTRUE until the cache is reset via a call to Reset is called on this gate or RecursiveReste is called on this gate or a gate that contains this gate either directly or indirectly.

Resets the cache on this gate. Any constituent gates will not be reset. Therefore, it is preferable to call RecursiveReset.

Resets the cached status of this break. For every constituent gate this method also does a recursive reset on it. Thus this method is expected to Reset all the gates that contribute to this gate as well as this gate itself.

If the gate has a valid cached value, that value is returned. If not, the gate is checked (normally using inGate). The result is then cached and returned.

This might be implemented as:

if (!wasChecked()) {
    Set(inGate(rEvent));   // Sets the gate status and cachce.
}
return getCachedValue();
                    

Compound gates are gates that depend on other gates. You can think of them as a container for other gates (some may be compound as wel) and a logical relationship required among those gates. For example, an And gate requires all constituent gates to be satisfied if it is to be satisifed for an event. The gates a compound gate depends on are called constituents.

If the gate has constituents, this method should return an iterator to the first item of the container of constituents If the gate has no constitutents, the value returned by End is returned.

This method is pure virtual to allow each gate type to use the container of constituents appropriate to it.

Returns the end of iteration iterator for the consitutents of this gate.

Returns a stringified version of the gate 'pointed to' by the constituent iterator. The form of this string may vary from gate type to gate type. Therefore, this method will be documented completely for each concrete gate class so you know what to expect.

Returns a dynamically created gate that is identical in state to this gate. Note that dynamically created means that when the client is done with this gate they must delete it.

Returns a text string that identifies the gate type. This method will be documented for each concrete gate type.

This method is used mostly by non gamma gates. That is gates with only one set of possible parameters. It returns kfTrue if the event satisfies the gate and kfFalse if not.

This is normally used by gamma gates. If the parameter ids in Params select a set of parameters in rEvent that make this gate true, the method returns kfTrue otherwise kfFalse.

Gamma gates can be used as cuts by trying all legal combinations of parmeter ids in the Params vector.

Returns kfTrue if the gate caches. This can be used to restrict the set of gates that are reset to only those that have a cache.

Constructs a gate that is satisfied when the parameter with id am_nId is in the interval [am_nLow, am_nHigh)

Returns the value of the low end of the interval that defines the cut.

Returns the value of the high end of the interval that defines the cut.

Returns the id of the parameter this gate will test.

Returns a vector of spectrum names involved with the gate. For a cut, no spectra are involved so an empty vector is returned. This is used mainly by gamma gates.

A cut is a gate with a single constituent - itself. This method returns an iterator that, once incremented is at the end of iteration.

Returns an iterator that points to nothing, and is off the end of constiuents.

Returns 1 indicating there is only one constituent, the gate itself.

If the iterator is not at end returns a string consisting of three space separated values. The first value is the parameter id. The second and third are the low and high limits of the cut's interval.

Returns the string s for slice. This is the type of gate. Note that c is used for the type of contour gates.

Returns kfTRUE if x is in the cut's interval.

If the event does not have the parameter whose id was used to construct the cut, returns kfFalse. If it does, the value of that parameter is passed to the previous method and the result of that method is returned.

Same as the previous method, howver instead of using the id of the parameter used to construct this object, the parameter id Params[0] is used.

As the gate name implies, regardless of the content of rEvent, this always returns kfFALSE.

Returns an iterator at end (same value as End). False gates have no components.

Returns 0

Regardless of the value of rIterator; returns an empty string.

Returns the string F which represents a False gate.

Both of these return kfFalse regardless of the parameters passed in.

Returns kfFalse as there's no need for a hard coded gate like CFalseGate to cache its answers.

As the gate name implies, regardless of the content of rEvent, this always returns kfTRUE.

Returns an iterator at end (same value as End). False gates have no components.

Returns 0

Regardless of the value of rIterator; returns an empty string.

Returns the string T which represents a True gate.

Both of these return kfTrue regardless of the parameters passed in.

Returns kfFalse as there's no need for a hard coded gate like CFalseGate to cache its answers.

This base class constructor stores the mask as an object attribute. Derived classes can use getCompare to retrieve this value. Gates derived from this method normally perform some bitwise operation between the parameter and the mask and then a comparison.

Returns the mask that used to instantiate this base class.

This just determine is the actual class's inGate method has to be invoked. If not the cached value for the gate is returned. Psuedo code for this is:

if cache is not valid
   Set cached value from Actual Class's inGate(rEvent)
endif
return cached value

                    

All constrcutors provide nXId, the id of the X parameter for the gate and nYId, the id of the Y parameter for the gate. Constructors only differ in how the points that define the gate shape are passed.

In the first constructor, points are passsed in as Points, a vector of type FPoint. This type is defined in the Point.h header. It is an object that encapsulates an X,Y coordinate pair that represents one point fo the gate shape.

The last two constructors require that the number of points in the gate shape, nPts, be passed to the constructor.

In the first of those two, the parameters xCoords and yCoords point to simple C arrays containing the X aqnd Y coordinates of each point respectively. Clearly xCoords and yCoords must both have nPts elements.

In the final constructor, the parameter pPoints points to a C array of FPoint objects.

These two methods get the ids of the parameters on the X and Y axes of the gate shape. An event that has both of these ids defines a point in parameter space where the parameter whose id is returned by getxId is on the X axis and that returned by getyId is on the Y axis. Gate points define a figure in this space whose meaning depends on the actual, concrete gate type.

Returns a copy of the points vector. This may result in copying a significatn number of FPoint objects and should not be userd to obtain gate points in order to check gates. Better to iterate or, if appropriate, use the Crosses utility method.

These methods provide support for iteration over the set of points that define the gate. The getBegin returns an iterator to the beginning of the container of FPoint objects defining the gate points while getEnd returns an end of iteration iterator.

If you are not sure what all this means; look up how iterators work in the C++ Standard Template library. These iterators work the same way.

The constituents of point list gates are the points of the gate. Begin and End provide for iteration over the constituents (see GetConstituent below). Size returns the number of constituents, in this case, the number of points in the gate figure.

Return the text string corresponsding to the constituent iterator rIterator. This will be a string consisting of two space separated floating point number strings (%f conversion). The first number is the X coordinate value of the point corresponding to the iterator while the second the Y coordinate of the same point.

Performs common code required to check if a gate is satisfied by an event. The geometry sensitive part of the check is done by the pure virtual method Inside defined below. Thwe psuedo code for this method is:

xid = getxId()
yid = getyid()
if (rEvent[xid].isValid() and rEvent[yid].isValid()) then
    return Inside(rEvent[xid], rEvent[yid])
endif

return kfFalse
                        

Thus this method only checks that both parameters are defined. If so Inside is invoked to see if the point defined by the event satisfies the gate and otherwise, kfFalse is returned.

Pure virtual method that has to be implemented by concrete sub-classes. x and y are a point in the parameter coordinate space in which the gate is drawn. The method should return kfTRUE if this point is 'inside' that gate or kfFALSE if not.

This utility method is useful for determining inside-edness. The parameters x and y define a point in the parameter space of a gate. f and s are two iterators that indicate two consecutive points in the figure that defines the gate.

Those two points define a line segment in the gate parameter space. The method 'draws' a horizontal ray that extends left from (x, y). The method returns 1 if this line would intersect (cross) the line segment defined by f and s. If not, 0 is returned.

Special cases that can speed up the determination are mercilessly exploited.

This constructor creates the base class without any contituent gates. Method such as AddGateBack must be used to add constituents to the gate.

These constructors create the object with an initial set of gates. Gates are stored as pointers to a gate container. This allows SpecTcl ot modify what the gate container "points to" without having to locate and fix up all references to an underlying gate.

The constructors only differ in the wa in which the constituent gates are passed to the constuctor. The first two use the std::vector and std::list container for the constituent gates while the last uses a counted C array of pointers to GateContainer pointers.

Returns the list of pointers to the gate containers that make up this gate.

Resets the cache of this gate and all constituent gates. The next time this, or any constituent gate is asked for its value vai operator() it must re-evaluate the gate with respect to the event.

Provides the usual constituent iterator interface for the compound gate. Begin produces an iterator at the start of the container and End one that is off the end of the container. Finally Size returns the number of times the iterator returned by Begin can be incremented before it becomes equal to the iterator returned by End.

Returns the name of a constituent gate. For compound gates, the ConstituentIterator can be thought of as an object that retrieves constituent gate names.

Adds a new constituent gate at the beginning of the constituents for the gate. Normally it's too hard to predicts the effect of constituent order on gates. If these can be predicted, however for And gates, the gates are most efficiently ordered in order of decreasing probability they'll fail, while for OR gates, gates are most efficiently ordered in decreasing probability they willl be satisfied.

Adds the gate container rGate at the end of all of the existing constituents. See above for notes on ordering gates.

Adds the gate container rGate in the constituent list just prior to rSpot. Thus AddGateFront(rGate) is identical to AddGate(Begin(), rGate). Similarly, AddGateBack(rGate) is identical to AddGate(End(), rGate).

The rGate is the single constituent gate. This gate will only be true for events that satisfy this constituent.

Returns a pointer to the gate container of the gate whose logical sense is inverted by this gate.

Supplies the constituent iteration interface for this gate type. Begin and End provide iterators for the start of iteration and the end respectively. Size returns the number of constituents (1).

Returns the constituent pointed at the iterator rp. For the iterator returned by Begin, this returns the name of the constituent gate. Otherwise an empty string is returned.

Returns the string - which is the type strig for a not gate. The string indicates negation of the constituent gate.

Rturns kfTRUE if rEvent satisfies the gate (does not satisfy the constituent gate). Otherwise returns kfFALSE. The gate is not a gamma gate so the first overload of this method just invokes the second.