Class default constructor.

 Class Constructor, setting up PartSieve properly with a TClasTool

 The runnum argument may be used later when we couple to a database 
 to get constants for cuts for a specific run. It is not used now.

 Class default destructor.

Calling this function turns on a flag that causes SieveEvent() to
count and store the number of each particle and store each particle's
index into the EVNT bank.

This is useful for getting how many of a certain particle are in 
an event. It is also useful because it is easy to tell it to get,
for example, the second kaon+, using GetEVNT. This should also be used 
in combination with the other two modes, in order for one to look at the
particles he has just analyzed.

Calling this function turns on a flag that causes SieveEvent() to
calculate and store a confidence level in each particle's id.

Use this to measure the confidence level in each particle's RECSIS 
id. For example if a particle's RECSIS id is proton and this function
assigns a confidence of .65, there is a 65% chance that it is actually
a proton.

Calling this function turns on a flag that causes SieveEvent() to
recalculate the id of each particle in the event.

This mode will actually change the particle id's that were assigned 
in RECSIS. Make sure you understand what the refinements are actually
doing before you use this mode!

Turns of particle sorting capability

Turn off confidence setting capability

Turn off Id refining capability

Set verbosity of code
Debug Mode = -1 : Absolutely no output
Debug Mode =  0 : Warning Messages only.
Debug Mode =  1 : Helpful non-warning messages and warning for too many particles in event.

 This function looks over each particle in the event. It can do the 
 following in any combination:
 1. Count and save the number of each type of particle in the event,
 as well as the EVNT index of each particle. These particles can then be
 accessed by telling the Sieve to get the 0th, 1st, 2nd etc. of such 
 and such a particle.
 2. Calculate the confidence that the RECSIS particle id is correct, 
 however this is only useful if you then save this info using option 1.
 3. Recalculate the particle id and save this new id.

THIS FUNCTION HAS BEEN WRITTEN FOR INTERNAL USE ONLY AND IS NOT ACCESSIBLE TO THE USER.

This will properly save a particle's index into the EVNT bank. It will
also incremement its counter. This routine saves the particle confidence 
if in the SetConfidence mode.

 This function returns the confidence level that the particle with EVNT 
 index Ind's RECSIS id is correct. For example if a particle's RECSIS id 
 is proton and this function /returns a confidence of .65, there is a 65%
 chance that it is actually a proton.

 The confidence level is set using a two-tiered system. The first tier consists
 of the Conf### functions, where ### is the particle name.
 In these functions the cuts that are to be used on the specific particle
 are selected. These functions also may contain code for a cut that
 is specific to a certain particle, however this should be very limited.

 The second tier of the system is the Cut functions themselves. The 
 general idea for these functions is that there is an ideal value of
 quantity that a particle may have. The experimental value will differ
 from this ideal value. The user inputs the maximum difference between
 ideal and experimental and the weight of this cut into the functions 
 as arguements. These functions are meant to be general and may require
 additional arguements such as the mass of the particle in question.

 THIS IS CURRENTLY TOTALLY NON FUNCTIONAL. 
 
 The thought behind it may even be flawed....

Get the number of particles with PartId in last sorted event.
Returns negative on error.

See GetNIdx(Int_t idx) (inlined function) for doing the same from an index.

Get the index into the EVNT bank for the numth PartId. Indexes start at 0.
Returns negative on error.

Get the index into the EVNT bank for the numth Idx. Indexes start at 0.
Returns negative on error.

Returns a pointer to the TEVNTClass for the numth INDEX, starting at index 0.
Returns NULL on error.

Returns a pointer to the TEVNTClass for the numth PartID, starting at index 0.
Returns NULL on error.

If you wish to save a particle confidence you have got independently of SieveEvent,
this will save it in the numth slot of PartId

Prints the number of each type of particle in the event and the SortFlag value.
You must call SieveEvent() first to see anything meaningful.

Returns the confidence from from the table. This table is constructed if the 
routine is run with ConfidenceOn(). Returns negative on error.

This transforms a particle index to the particle id#.
This is a passthrough call to TClasTool::GetPidFromType.

The Conf functions select the cuts that are relevent to their particle.
There is a seperate function for each particle because it keeps the 
code easy to read and straightforward. It is also the job of these 
functions to select the weight of each cut and how much range the cut 
should have.

Calculate the confidence that particle with EVNT index Ind is an electron.

 Calculate the confidence that particle with EVNT index Ind is a Pi+.
 Currently this is a hard cut on DeltaT, between 
 fConf_Pim_DT_min and fConf_Pim_DT_max

 Calculate the confidence that particle with EVNT index Ind is a Pi-.
 Currently this is a hard cut on DeltaT, between 
 fConf_Pip_DT_min and fConf_Pip_DT_max

Calculate the confidence that particle with EVNT index Ind is a proton.
 Currently this is a hard cut on DeltaT, between 
 fConf_Prot_DT_min and fConf_Prot_DT_max

Calculate the confidence that particle with EVNT index Ind is an electron

Calculate the confidence that particle with EVNT index Ind is a positron.
This calls the routine for the electron: ConfEl(Ind,0.)

Calculate the confidence that particle with EVNT index Ind is a photon.

Calculate the confidence that particle with EVNT index Ind is a neutron.

 Calculate the confidence that particle with EVNT index Ind is a K+.
 Currently this is a hard cut on DeltaT, between 
 fConf_Pip_DT_min and fConf_Pip_DT_max

 Calculate the confidence that particle with EVNT index Ind is a K-.
 Currently this is a hard cut on DeltaT, between 
 fConf_Pip_DT_min and fConf_Pip_DT_max

Calculate the confidence that particle with EVNT index Ind is a deuteron.

Calculate the confidence that particle with EVNT index Ind is a Helium 3.

Calculate the confidence that particle with EVNT index Ind is a Helium 4.

 right now.

Refine the Id of a Pi+.

Refine the Id of a proton.

Refine the Id of an electron.

Refine the Id of a photon.

Refine the Id of a Pi-.

Refine the Id of a neutron.

Refine the Id of a kaon+.

Refine the Id of a deuteron.

Refine the Id of a kaon-.

Refine the Id of a helium 3.

Refine the Id of a helium 4.

Refine the Id of a positron.

This function changes the id of the particle in the ClasTool bank with
index Ind to the ID in the arguement.

Set the minimum confidence a particle may have and be saved in the Sieve

Set the minimum confidence a particle may have if it is not to be refined

 In these Cut functions the difference between an ideal value and the 
 experimental value is calculated. The difference is scaled so that a
 difference of MaxDiff is scaled to 1, values less are less than 1 and
 values greater than MaxDiff are greater than 1. The scaled difference is
 then multiplied by Weight and returned. The returned value is meant to 
 be subtracted from the confidence.

 Compares the Beta from EVNT class with betta found using the formula
 B= p/sqrt(p^2 + m^2).m is the input parameter mass. Use the accepted value.
 Weight is a measure of how severe the cut is. Returns the 
 reduction in confidence.

 Helper function.
 This function return 1 if x is below cut-width/2.
 It will return       0 if x is above cut+width/2.
 Between cut-width/2 and cut+width/2 it returns a value between 1 and 0
 decreasing linearly.

 Helper function.
 This function return 0 if x is below cut-width/2.
 It will return       1 if x is above cut+width/2.
 Between cut-width/2 and cut+width/2 it returns a value between 0 and 1
 increasing linearly.

 See Float_t TPartSieve::ECUVWCut(TEVNTClass *evnt, Float_t WidthMultiply)

 This function cuts on the U,V and W coordinate on the EC plane. 
 These cuts make sure we do not use the events that are too close to the edge
 where some of the shower could have leaked out of the calorimeter.

 Instead of a hard cut, where the function would return 1 if you are inside
 and 0 if you are outside, each cut specifies a "width". The function returns
 a value of 0 or 1 outside this widht, and inside the width it returns a 
 value bewteen 0 and 1. The "WidthMultiply" parameter allows you to stretch
 or shrink these widths. So WidthMultiply=0 will give you the standard
 1 or 0 behavior.

 Cuts are specified by fEC_U_Cut, fEC_V_Cut and fEC_W_Cut, where the U cut
 is a cut on minumum U, and the V and W cuts are maxima. The widths for
 these cuts are set in fEC_?_Cut_width.

 Reasonable defaults are choosen for these cuts, but you probably want to 
 fine tune them for your analysis.

 See TPartSieve::EC_Eio_Cut((TEVNTClass *evnt,Float_t WidthMultiply)

 This performs a cut on the EC Inner energy versus the EC Outer energy
 to identify good electrons.
 The cut is a line: Eout/p >= Off - Slope* Ein/p
 Where Off=0.156 , Slope=1 is standard.

 Right now this is a hard cut, returning 0 or 1.

 See TPartSieve::GetDeltaT(TSCPBClass *sc,Float_t p,Int_t ipart)

 Get the DeltaT (difference between flight time calculated from
 sc hit and from momentum, see below) for event *evnt.

 First checks whether there was an SC hit, if not returns -1000.
 Next, checks whether the SC paddle is on the bad paddle list,
 if so, returns -999.
 If neither of the above, it returns the DeltaT by calling the routine below.

 Returns the difference between flight time calculated from
 the scintellator hit time dt_sc=(sc->Time - head->STT) and the flight time
 calculated from the momentum: dt_p=sc->Path/(29.9*betap), where 
 betap = p/(p*p+m*m) , with m the guessed at particle mass.
 This should thus be zero if the mass is guessed correctly and resolution
 is perfect.

 No checking is done for the validity of the *sc pointer!
 Returns the DeltaT.

 Same at GetDeltaT, but for the flight path to the EC.
 Returns the difference between flight time calculated from
 the EC hit time dt_ec=(ec->Time - head->STT) and the flight time
 calculated from the momentum: dt_p=ec->Path/(29.9*betap), where 
 betap = p/(p*p+m*m) , with m the guessed at particle mass.
 This should thus be zero if the mass is guessed correctly and resolution
 is perfect.

 Check the quality of the track. 
 If no DC at all or TEVNTClass::GetDCStat<=0 return 0.
 Also return 0. if the TEVNTClass:GetStat()<=0;
 This filters out the hit based only tracks.
 Else, compare the Chi2 requested with the Chi2 of the track.
 

 Cut on the number of CC photons, given an index.

 Cut on the number of CC photons.

Cut For particles missing a CC bank

Cut For particles missing an EC bank

Cut For particles missing a DC bank

Cut For particles missing an SC bank

 Check is sc is on the bad paddle list.

 Check is sccode is on the bad paddle list.

 Check if {sec,paddle} is on the bad baddle list.

 Set a paddle as bad in bad paddle list.
 Returns the new number of bad paddles;

 return beta from momentum and mass (index).

====================================================================================
This transforms particle id to particle index.
This is a passthrough call to TClasTool::GetTypeFromPid, but in addition
 stores the value in fIndexSave for later retrieval with IDtoIndQuick().
 (inline function);

==============================================================================
returns the last value found by IDtoInd. This avoids doing multiple searches.  

This function should be somewhere else (ie. the vertex class, but I 
need it for an analysis and this was the simplest place to put it.