CSpectrum

This constructor is used when construction time provides sufficient information to provide the axis definitions without computation.

rName and nId provide the name and Id of the new spectrum. Maps is a vector of axis definitions.

pGate is the gate to be applied to the spectrum. pDefault gate points to a gate container for the default gate which is a True gate.

Constructor to use when a set of axes easily be pre-built. The protected method addAxis can be used to add axis definitions one-by-one to the spectrum. The remaining parameters have the same meaning as for the previousl constructor.

Returns a pointer to the storage associated with the histogram. Note that this SpecTcl can maintain spectra which are purely local or it can locate spectra in a shared memory region so that local display programs can access bulk spectrum storage quickly.

Closely associated with this pointer, therefore, is the concept of storage ownership. The spectrum storage is said to be owned by the spectrum object if, on destruction it the storage can be released via the delete operator. If storage is not owned by the spectrum, it must not be deleted on destruction.

Spectrum storage may have been dynamically allocated by the spectrum object, or may belong to some other object. This method returns kfTRUE if the spectrum storage has been allocated by this object.

One case when this may return kfFALSE is a spectrum that has been bound into displayer shared memory when the storage is owned by the object that manages the shared memory region.

Storage that is owned by this object may be deleted if appropriate. Storage not owned is released to the custody/management of the owner (e.g. for Display shared memory the space is released for re-use by other spectra).

Returns the pointer to the CGateContainer object that holds the gate applied to this spectrum. Gate containers are named, pointer like objects that contain a SpecTcl gate. They provide another level of indirection that allows gates to be replaced without requiring that clients of those gates be notified.

The rule is that the gate dictionary contains gate containers that, once created, are never destroyed while gate clients will contain pointers to those gate containers which, in turn provide a fixed point of reference for the gate regardless of what might happen to change the gate later.

getAxisMaps returns the vector of CAxis objects associated with this spectrum. Each axis object defines how raw parameter values are mapped to bins on a channel.

In general, element 0 of this vector describes the X axis while, if the spectrum is 2-d element 1 describes the Y axis. An exception to this are summary spectra which only have an axis definition for the Y axis as the X axis is defined by the number of parameters summarized.

getAxisMapCount returns the number of elements in the axis map vector. it is equivalent to aspec.getAxisMaps().size()

This method is an optimization that caters to large analysis cases. Perfomance analysis showed that the spectrum -list command required a significant amount of time to build spectrum descriptions for analysis cases with large (1000's) numbers of spectra.

The CSpectrum class therefore has an attribute in to which the spectrum description string can be written when the spectrum is created (e.g. by spectrum -new). This method returns the value stored in that attribute.

This method provides the capability for SpecTcl to cache the Tcl description of a spectrum normally produced by spectrum -list. This was added because when there are a large number of spectra, computing the spectrum definition string can be very time consuming. Therefore, SpecTcl's spectrum command now computes this string on spectrum creation.

The SpecTcl spectrum -list command uses this cached spectrum description string. If, however, the string is empty, it computes the description string ab intio, caches that string in the spectrum to satisfy future requests and uses the computed string when producing its returned value.

This pure virtual method must be implemented by concrete spectrum type classes. It is expected to return the actual spectrum type. Note that if new spectrum types are implemented histotypes.h must be updated to extend the SpectrumType_t enumerated data type.

Process the implications of an event; rEvent for this spectrum. While this method is virtual, the base class implementation is normally sufficient. The base class implemebntaton checks the gate applied to this spectrum and, if satisfied, invokes the Increment method for this spectrum.

Normally only the Increment method needs to be implemented for spectrum event processing to work properly.

Note that there is no gaurantee that this method will be invoked for all events. SpecTcl's histogramming subsystem and the dope arrays in CEvent collaborate to minimize the number of histograms that must be invoked for each event.

Applies a new gate specified by the gate container pNewGate to the spectrum. The previously applied gate container is returned. From now on pNewGate is checked by operator() and must be satisfied for that method to call Increment.

Ungates the spectrum and returs the pointer to the previously applied gate container. Note that spectra are never actually ungated. This method applies a predefined gate container that points to a true gate ensuring that operator() will always invoke increment when called.

If the spectrum uses rParameter, this method returns kFTRUE, otherwise it returns kfFALSE.

Note the difference between uses and required. For example, a summary spectrum has no required parameters but uses all of the parametersa in its definition.

Returns the type of channel the spectrum contains. See the definition of DataType_t in histottypes.h for the possible values this method can return.

Given a raw parameter value fParameterValue, converts it to a bin number on the spectrum axis indexed by nAxis. The resulting bin number is returned.

Inverse transformation from ParameterToAxis.

With Root integration, createStatArrays is obsolete, but provided for compatibility sake. Prior to version 5.0, SpecTcl maintained over/underflow statistics in separate arrays called statistics arrays, one element per axis. With Root integration, SpecTcl histograms encapsulate a TH1 or TH2 derived root class. Those types of spectra maintain over/underflow statistics in additional channels of the spectrum.

Clears overflow and underflow statistics for the spectrum. With Root integration, this method is somewhat misnamed. In 5.0 and later, SpecTcl spectra are wrappers around TH1 or TH2 subclasses. These maintain over/underflow counts in addtional spetrum channels.

These two methods are completely obsolete and are only present for compatibility sake. With 5.0's root integration, all SpecTcl histograms are wrappers around root TH1 and TH2 objects. The Fill method of these objects maintains over/underflow statistics in addional channels of the spectrum.

Returns the over/underlflow counters for the histogram.

The return value is a vector. The vector has one element for 1-d spectra and two elements for 2-d spectra.

5.0 integrates with Root. Underflows and overflows are stored in extra channels of the histogram.

For 1-d spectra, these methods are trivial. Underflows are stored in channel 0 and overflows are stored in channel n+1 (n the number of bins on the X axis).

For 2-d spectra, summing must be done. For example, X underflows are the sum of all channels with coordinates [0, i] where i is in the range [1, n], n the number of channels in the spectrum. Similarly, Y underflows are summed over all X with Y = 0.

Inverse transformation from ParameterToAxis.

With Root integration, createStatArrays is obsolete, but provided for compatibility sake. Prior to version 5.0, SpecTcl maintained over/underflow statistics in separate arrays called statistics arrays, one element per axis. With Root integration, SpecTcl histograms encapsulate a TH1 or TH2 derived root class. Those types of spectra maintain over/underflow statistics in additional channels of the spectrum.

Clears overflow and underflow statistics for the spectrum. With Root integration, this method is somewhat misnamed. In 5.0 and later, SpecTcl spectra are wrappers around TH1 or TH2 subclasses. These maintain over/underflow counts in addtional spetrum channels.

These two methods are completely obsolete and are only present for compatibility sake. With 5.0's root integration, all SpecTcl histograms are wrappers around root TH1 and TH2 objects. The Fill method of these objects maintains over/underflow statistics in addional channels of the spectrum.

Returns the over/underlflow counters for the histogram.

The return value is a vector. The vector has one element for 1-d spectra and two elements for 2-d spectra.

5.0 integrates with Root. Underflows and overflows are stored in extra channels of the histogram.

For 1-d spectra, these methods are trivial. Underflows are stored in channel 0 and overflows are stored in channel n+1 (n the number of bins on the X axis).

For 2-d spectra, summing must be done. For example, X underflows are the sum of all channels with coordinates [0, i] where i is in the range [1, n], n the number of channels in the spectrum. Similarly, Y underflows are summed over all X with Y = 0.

This pure virtual method must be implemented by concrete spectrum classes. nId is a parameter id. The method returns kfTRUE if the parameter specified by that id is used by the spectrum. Otherwise, it returns kfFALSE.

This pure virtual method must be implemented bvy any concrete. spectrum class. pIndices points to one (1-d spectra) or two (2-d spectra) axis bin numbers. The method returns the contents of the bin at that coordinate. An exception such as std::range_error is thrown if one or more of the indices is out of range.

Note that with Root integration, Spectra aer wrappers around TH1 or TH2 derived objects. These methods may be used to index the over/underflow channels of these objects as well as the regular channels.

This pure virtual member allows you to store a nValue at the axis bin indices selected by pIndices. As with operator[], pInidices points to a one or two element array containing the X axis bin number and, if the spectrum is 2d the Y axis bin number to modify.

rvIds will be given the set of parameter ids used by the spectrum. The concreate class should implement this method so that on return rvIds only contains the parameter ids.

On return from this method call, rvResolutions will be a vector containing the number of channels in each axis of the spectrum. Element 0 of rvResolutions will be the number of channels on the X axis and, if the spectrum is 2-d, element 1 will be the number of channels on the y axis.

Note that summary spectra are an exception in that they only have a settable Y axis. Calling this method on summary spectra will return a single element vector containing the number of channels on the Y axis.

Given an event which can be assumed to satisfy the spectrum's gate, this method should increment the channel(s) appropriate to the contents of the event.

Returns the spectrum dimensionality. This the number of axes that have controllable resolutions. Note that summary spectra, while they are 2-d spectra only have a Y axis with a controllable resolution. Summary spectra will therefore return 1

Returns the number of channels in dimension nDimension. As usual, with the exception of summary spectra, 0 specifies the X dimension while 1 specifies the y.

Returns the axis low limit for the axis number nDimension.

Returns the high limit of the axis selected by nDimension

Returns the units of measure of the axis selected by nDimension. This will will be an empty string if no axis units were specified.

Since SpecTcl can relocate spectra in an out of shared memory this method is provided to support that relocation. Copy copies the contents of this spectrum into storage pointed to by pStorage. It is the responsibility of the caller to ensure that this points to sufficient storage.

Note that StorageNeeded can be used not only to determine how much storage is required but to allow this method to be correctly implemented in the base class.

Clears the spectrum. This also clears the over/underflow counters. For most spectra, the base class implementation is sufficient.

Returns the number of bytes of storage required for this spectrum.

Replaces the storage associated with the spectrum with pNewLoc. If there's already storage associated with the spectrum, its contents are copied into pNewLoc using the Copy method. If the storage is owned by the spectrum, ReleaseStorage is called to free it. Finally, the value of the storage storage ownership flag is set to the value of fTransferOwnership.

Returns kfTRUE if the event rEvent satisfies the gate that is currently applied to thsi spectrum. If not, returns kfFALSE.

Returns a struct that describes the spectrum. See TYPES below for more information about the fields in the SpectrumDefinition data type.

This is used by SpecTcl's histogramming object to organize spectra. Some spectra require the existence of at least one specific parameter (e.g. 1-d or 2-d spectra). These spectra are placed in lists organized by the id of the first parameter needed.

Other spectra can't make the statement that some specific parameter is required for them to be incremented (e.g. Summary spectra and all types of gamma spectra). These are placed in a list and must have their operator() called for every event.

This method returns kfTRUE if this spectrum has a parameter that is required for the spectrum to be incremented. If not, kfFALSE is returned.

Computing spectrum definition strings can be costly and adds up rapidly for analysis cases with several hundreds or even thousands of spectra. This method allows a description string to be cached with the spectrum so that it can be fetched with getTextDescription. d will be the new cached spectrum description string.

SpecTcl makes use of this description caching to vastly improve the performance of spectrum -list.

This simply sets the private member data holding the pointer to the spectrum storage with am_pStorage. ReplaceStorage is preferred as it takes care of copying current spectrum data and, if appropriate, deleting prior storage. This method is provided if a concrete spectrum class has specific, special storage management requirements.

Sets the storage ownership flag to am_fOwnStorage.

Intended for use by specific, concrete constructors. This method sets the spectrum data type element to dt.

This method is intended for use by constructors that must incrementally add axis definitions to a spectrum. This method adds a single axis definition for an axis with nChannels bins, that represent parameter values in the range [fLow, fHigh).

If supplied, Units is saved as the units of measure for the axis.

This method is obsolete. It checks that a avlue channel is in the range [0, nChans). If so, the method returns true. If not either logUnderflow or logOverflow is called as appropriate and false is returned.

THe method is obsolete because with SpecTcl 5.0 root integration, the spectrum classes are wrappers around TH1 and TH2 derived objects. Those objects maintain overflows and underflows via calls to Fill

Frees storage associated with the spectrum. This should only be called if the spectrum owns its storage.

Spectra have a vector of CAxis objects. Each object defines an axis and, more importantly, the mapping function between raw parameters and bins on that axis.

See CAxis for more information about this class.

Defines an iterator into the collection of axes a spectrum maintains.

Spectra require a uniform description. The SpectrumDefinition struct provides that type. It has the following members:

In this constructor, rName is the name of the spectrum being created and nId its id. rParameter defines the parameter that is used to increment the spectrum. nChannels .

The spectrum will increment for hte bottom nChannels bits in rParameter. It, therefore has an X axis with a range [0, nChannels)

This constructor creates a bit mask spectra that increments for bit numbers in the range of [nLow, nHigh).

Returns the number of channels in the spectrum. This will also be the number of bits in the range of bits the spectrum displays.

Returns the id of the parameter the spectrum is defined on. This will be the id of the rParameter parameter passsed to the constructor.

Returns the value keBitMask indicating this is a bit mask spectrum.

If the parameter the spectrum was constructed on was assigned a value in rEvent, it is converted to a 32 bit integer. For every bit that is set in that spectrum within the range of bits the X axis covers, the appropriate channel is incremented.

Note that normally this is called from within CSpectrum::operator() if the gate applied on this spectrum is satisfied.

This constructor creates a new gamma spetrum base class given the spectrum name (rName) and id (id). Axis definitions are supplied by a vector of CAxis; Maps.

The gamma spectrum will be incremented from the parameters in Parameters. What this means depends on the specific type of gamma spectrum being created by the subclass.

Finally pGate points to the gate container of the gate initially applied to the spectrum. This defaults to pDefaultGate which points to a container for a true gate.

Note that this constructor is used when there's no distinction between X and Y parameters such as in gamma 1d or ordinary gamma 2d spectra.

This constructor should be used by subclasses that differentiate between parameters on the X and Y axis. For example, the Gamma Deluxe spectrum.

The only difference between this and the previous constructor is that parameters are specified by xParameters - the parameters on the X axis and yParameters - the parameters on the Y axis.

These constructors are used when the axis definitions will be computed and added via AddAxis as during the constructor body.

Gamma spectrum increments are mediated by the fold applied on them. Gamma spectra always have a fold although the fold may be a default one.

This method invokes the fold given the list of parameters and the event, for ordinary gamma spectra, or the x and y parameters and the event for gamma deluxe spectra. The fold, in turn will determine which of the Increment methods below and how to invoke it. Those methods will perform the final increment.

This pure virtual method must be implemented in concrete derived classes. It performs the appropriate increments of the spectrum given a vector of pairs. The first element of each pair is a parameter number and the second the value of that parameter. Note that The fold that calls this may have removed some of the parameter/values present in the event due to the impact of the fold.

This increment is used by ordinary gamma spectra that don't have a concept of X and Y parameters.

This pure virtual method must be implemented in concrete derived classes. It performs appropriate increments for gamma spectra that differentiate between X and Y parameters (Gamma Deluxe). It will be called by the spetrum's fold after it has reduced the parameters to the appropriate set after the application of the fold.

Returns true if the spectrum has a named fold. Note that the default fold, a fold wrapped around a True gate, has no name. Only folds wrapped around gamma gates have names, the name of the wrapped gate.

What this method actually tells you is whether or not the spectrum has a fold that can influence how spectra are incremented.

Wraps the gate container (and hence the gate it contains) pointed to by pGate into a CFold object and applies the resulting fold to the spectrum. The fold can, if it is a gamma gate, dictate how the spectrum is incremented by reducing the set of parameters used to increrment the spectrum.

Returns a pointer to the fold applied to the spectrum.

The set of parameter ids used by this spectrum are appended to rvIds. Note this vector is not cleared by the method.

For spectra that care about X/Y parameters, the X parameters are added first followed by the Y parameters.

Given the event rEvent, creates a vector of parameter number/value pairs for all parameters the spectrum is defined on that have been assigned values in rEvent. Note that if the spectrum cares about X/Y parameters, this will represent the X parameters only.

For spectra that care about which parameters are X and Y, produces what CreateParameterList does for the Y parameters. For those spectra, CreateParameterList only produces a list of X parameters.

Creates vectors of parameter definitions into Parameters. If the Spectrum does not care about X,Y parameters, CreateParameterVector creates a vector with all of the parameters. If the spectrum does care about X/Y parameters, the method produces only the X parameters and CreateYParameterVector produces the definitions of the Y parameters.

Constructs a 1d Gamma Spectrum. For the two constructors, rName and nId are the name and id of the spectrum respecdtively. rrParameters is a vector containing the descriptions of the parameters on which the spectrum is defined.

In the first form, nScales is the number of channels in the spectrum. The X axis of the spectrum, in this case is the range [0, nScale).

In the second form, the number of channels is given by nChannels and the axis range in parameter coordinates is [fLow,fHigh)

Returns the value keG1D.

Increments appropriate channels of the spectrum given the vector of parameter ids and pairs. For this simple 1D Gamma spectrum, this just means incrementing for all values that are in axis range.

This method is not appropriate for gamma 1d spectra as there's no differentiation between X and Y parameters in this type of spectrum. Invokingh this wil therefore throw a CException whose reason text explains that you're trying to increment a gamma 1d spectrum with the gamma 2d deluxe increment method.

These constructors differ only in how the X/Y axes are specified. Both of them require a spectrum name (rName), id (nId). Both require a vector of parameters that will be used to increment the spectrum and evaluate it's associated fold (rParameters).

The first constructor specifies the axes only with bin counts, nXScale and nYscale. The X axis runs the range [0, nXScale) and the Y axis has the range [0, nYScale)

The second constructor provides full mappings for both the X and Y axes. In addition to nXScale and nYScale, which specify the number of bins on the X and Y axi respectively, both axis ranges are specified. The X axis range is [xLow, xHigh). The axis range is [yLow, yHigh).

Retrns keG2D - Gamma 2d spectrum.

This method should be called to increment the spectrum. rParameters is a vector of parameter ids and their associated values. The spectrum's fold may have reduced the set of parameters from the set in the event for this spectrum.

The Gamma 2d spectrum does not know about separate X and Y parameters but increments for all ordered pairs of parameters in the spectrum following psuedo code like:

for i in 0 - rParameters.size() -1 
   for j in i +1 - rParameters.size()
      xparam  = RawToXaxis(rParameters[i].second)
      yparam  = RawToYaxis(rParameters[j].second)
      if xparam and yparam fall in X and Y axes respectively
        increment spectrum at xparam,yparam
      end if
    end for
end for
                    

This increment operation is not valid for this spectrum type as it does not distinguish between X and Y parameters. If it is called in error it will throw a CException with the reason text "Gamma 2d Deluxe increment called on CGamma2DL"

Constructors for G2DD spectra. Both constructors provide parameters to identify the spectrum. rName is the spectrum's name and nID its identifier. Both provide a pair of vector parameters; xParameters and yParameters which provide parameters for the X and Y axes respectively. Both also provide a pair of parameters; xChannels and yChannels to provide the number of bins on the X and Y axes respectively.

The first of the constructors does not provide for a mapping between raw parameters and axis values/bins. The X axis has the range [0, xChannels). The Y axis has the range [0, yChannels)

The second of the constructors provides for the ability to specify parameter coordinate ranges for each axis as well as the binning. The X axis in this case has the range [xLow, xHigh) with xChannels bins. Similarly, the Y axis has the range [yLow, yHigh) with yChannels bins.

Returns keG2DD.

This, axis blind method is not appropriate for incrementing the Gamma Deluxe family of spectra. If invoked, it will throw a CException with the reason text Attempted a 'non-deluxe' increment of a gamma deluxe spectrum

This is the appropriate increment method for G2DD spectra. rXParameters is a vector of parameter ids and their values for the X axis. Similarly rYParameters is a vector for the Y axis.

The evaluation of the spectrum's fold can reduce the set of parameters passed to the increment. Psuedo code below shows how these parameters increment the spectrum.

for i in [0, rXParameters.size())
   for j in [0, rYParameters.size()]
       x = RawToXaxis(rXParameters[i].second)
       y = RawToYaxis(rYParameters[j].second)
       if x and y are in the axis ranges
          increment spectrum at (x,y)
        endif
    end for
end for
       

                    

As usual there are a pair of constructors. The first of these provides for an one to one mapping between parameter values and Y axis channels. The second allows for arbitary mappings.

For the most part, parameterrs are the same as for other gamma spectra. The pParameters paramameter points, however to a vector of vectors. The outer vector indexes the X axis channels while the inner vector contains the parameters that contribute to the gamma spectrum that is on the Y axis for each of those channels. The Increment method documentation provides pseudo code for the increment logic.

returns the value keGSummary indicating this spectrum is a gamma summary spectrum.

Increments the appropriate channels in the spectrum given the event rEvent. The object has a member m_Parameters that is a vector of vectors of parameter ids. This is used to drive the increment. Here's pseudo code for the increment operation.

for i in [0, m_Parameters.size()]
    for all m_Parameters[i] py where rEvent[py].isValid()
        y = rawToYAxis(rEvent[py]);
        increment channel (i,y)
    end for
end for
                    

These two constructors differ only in how the X axis of the spectrum is described. For both of them, rName and nId are the name and id of the spectrum being created. rParameter references the description of the parameter that will be used to increment the spectrum. and nChannels is the number of bins on the X axis.

In the first form of the constructor, the mapping from raw parameter to bin is one-to-one. That is the X axis is assumed to cover the range [0, nChannels).

In the second form of the constructor, the additional parameters; fLow and fHigh specify the range of the X axis. The X axis range is considered to be [fLow, fHigh)

Returns the id of the parameter that will be used to increment the spectrum.

Returns ke1D.

Performs the appropriate increment for the event rE. At most only one increment can be performed. Pseudo code for the increment (assuming the gate has been satisfied) is

UInt_t id = getParameter();
if (rE[id].isValid())
   x = rawToXaxis(rE[id])
   increment channel x if in range
end if
                    

The two constructors, like the constructors for most spectrum types differ only in how the axes of the spectrum are specified.

The first constructor specifies the X axis as covering the range [0, nXChannels) with nXChannels bins. The Y axis is similarly specified as covering the range [0, nYChannels) with nYChannels bins.

The second constructor, provides for arbitrary limits and binning. nXChannels and nYChannels specify the number of bins on the X and Y axes respectively as before. The range of the X axis is, however specified a [fxLow, fxHigh). The range for the Y axis is similarly [fyLow, fyHigh).

The remainder of the constructor parameters are common to both forms of the constructor. rName and nId identify the spectrum. rXParameter and rYParameter are the definition objects for the X and Y axis parameters respectively.

Returns the parameter id of the X axis parameter.

Returns the parameter id of the Y axis parameter.

Returns ke2D.

Increments the spectrum as appropriate given the event rEvent. Increment does not check the gate. operator() is assumed to already have done that.

Pseudo code for the increment is:

xid  = getXParameter();
yid  = getYParameter();
if rEvent[xid].isValid() and rEvent[yid].isValid()
    x = rawToXaxis(rEvent[xid])
    y = rawToYAxis(rEvent[yid])
    increment spectrum at channel (x,y)
end if
                    

These tow constructors again differ only in the initial axis specification. In the first form, the spectrum has nChannels channels and the channel width corresponds to one unit of width in the raw parameter space.

In the second form of the constructor, the initial range of the spectrum is [fLow, fHigh). The width of a channel is (fHigh - fLow)/nChannels.

For both constructor forms, rName and nId identify the spectrum. rParameters is the spectrum's parameter value. This parameter is on the Y axis of the strip chart. nChannel is the spectrum's channel parameter.

This method is normally used by Increment for events where the channel parameter is to the left of the origin of the X axis. Data are shifted upwards (to the right) and zero filled on the left. nShift is the number of channels to shift the data.

Same as shiftDataUp but the channels are shifted to the left in the spectrum.

Returns keStrip

Increments the spectrum as per the contents of the event rE. The Psuedo code is:

nc = getChannelParameter()
np = getParameter()
if (rEvent[nc].isValid() and rEvent[np].isValid())
    channel = rawToX(rEvent[nc])
    if (channel > last channel)
        shift spectrum down
    else if (channel < 0)
        shift spectrum up
    endif
    channel = rawToX(rEvent[nc])
    increment spectrum at channel by rEvent[np]
end if
                    

The two forms of the constructor differ in how they create the range and binning of the Y axis. In the first form; there are nYScale bins on an axis that spans the interval [0, nYScale). In the second form; there are again nYScale channels, but the axis spans the interval [fYLow, fYHigh).

The remaining parameters are semantically the same for both constructors. rName and nId identify the spectrum. rrParameters provide the parameters that are histogrammed in the summary. The index of each element of the vector indicates which X channel that parameter's spectrum occupies.

Returns the number of parameters on the X axis. This is also the number of channels on the X axis.

Returns the parameter id for channel n.

Returns keSummary.

Given an event rEvent increments the appropriate channels of the spectrum. The psuedo code for this method looks a bit like this, assuming there's a vector m_parameters that has the parameter ids of the parameters used to construct the spectrum:

xchan = 0
for each parameter id in m_parameters as id
    if rEvent[id].isValid()
        value = rawToYAxis(rEvent[id])
        Increment channel (xchan, value)
    endif
    xchan = xchan + 1
end for