PulseCandidateFinder Class Reference
[Modules]

Utility class to find pulse candidates on a TPulseIsland. More...

#include <PulseCandidateFinder.h>

List of all members.

Classes
struct	Location
	Location is a struct containing the start and stop location (in terms of sample number) of a candidate pulse. More...
Public Member Functions
	PulseCandidateFinder (std::string detname, modules::options *opts)
	The constructor.
	PulseCandidateFinder ()
	Default constructor, make sure to set the channel name with SetChannel if you use this constructor.
	~PulseCandidateFinder ()
	Empty destructor.
void	SetChannel (const std::string &detname)
void	SetSigma (double sigma)
void	FindPulseCandidates (const TPulseIsland *pulse)
	Find the pulse candidates on the given TPulseIsland.
int	GetNPulseCandidates ()
	Returns the number of pulse candidates that were found.
void	GetPulseCandidates (std::vector< TPulseIsland * > &) const
	Returns the actual TPulseIsland of each candidate.
void	FillParameterHistogram (TH2D *histogram)
	Takes a histogram and fills it with the parameters (both sample height above pedestals and sample differences between consecutive samples).
Private Member Functions
void	FindCandidatePulses_Fast (int rise)
	The algorithm for finding fast pulses.
void	FindCandidatePulses_Slow (int threshold)
	The algorithm for finding slow pulses.
void	SetDefaultParameterValues ()
	Called in the constructor if fDefaultParameterValues is empty, so that it can be filled.
bool	CheckDigitiserOverflow ()
	Check if the pulse is overflowed.
Private Attributes
const TPulseIsland *	fPulseIsland
	The TPulseIsland that we are looking for candidates on.
std::vector< Location >	fPulseCandidateLocations
	The vector that we store the pulse candidate locations in.
IDs::channel	fChannel
	The channel that this PulseCandidateFinder works on.
double	fParameterValue
	The value of the parameter to start a candidate pulse.
double	fNoise
	The noise value for this channel.
double	fPedestal
	The pedestal value for this channel.
int	fNSigma
	The number of sigma (i.e. noise) that we want the threshold to be set to.
Static Private Attributes
static std::map< IDs::channel, int >	fDefaultParameterValues
	The map that stores the default parameter values in case there isn't one specified in the modules file.

---

Detailed Description

Utility class to find pulse candidates on a TPulseIsland.

Author:

Andrew Edmonds

This utility class stores the location of candidate pulses of a TPulseIsland. These candidate pulses can be retrieved later by the calling module.

Note that there are two algorithms used to find candidate pulses. For slow pulses, we simply look for when a sample has gone above a certain threshold and for fast pulses, we look to see if there's a sudden rise in sample value between consecutive pulses.

The final thing this class does is to fill a given histogram with the relevant parameters (either sample height or sample difference). This ability is used by the PulseCandidateFinder_InvestigateParameters module

Definition at line 29 of file PulseCandidateFinder.h.

---

Constructor & Destructor Documentation

PulseCandidateFinder::PulseCandidateFinder	(	std::string	detname,
		modules::options *	opts
	)

The constructor.

The constructor just sets all the parameter values.

The constructor looks in the opts for any changes to the defailt parameter, "n_sigma" and "debug"

Parameters:

[in]

opts

Describe the options this module takes.

Definition at line 37 of file PulseCandidateFinder.cpp.

References fChannel, fDefaultParameterValues, fParameterValue, modules::options::GetDouble(), modules::options::GetFlag(), modules::options::GetInt(), modules::options::HasOption(), SetChannel(), SetDefaultParameterValues(), and SetSigma().

                                                                                  {

  // make sure we have default values
  if (fDefaultParameterValues.empty()) {
    SetDefaultParameterValues();
  }

  SetChannel(detname);

  // Check options to set the values cut
  if(opts->HasOption("n_sigma")){
     SetSigma( opts->GetInt("n_sigma"));
  } else if(opts->HasOption(detname+"_param")){
    fParameterValue = opts->GetDouble(detname+"_param"); 
  }
  
  // print debugging statements
  if (opts->GetFlag("debug")){
    std::cout << "Parameter Value for " << fChannel 
              << " PulseCandidateFinder is " 
              << fParameterValue << std::endl; // would be nice to know which module this is for
  }
}

PulseCandidateFinder::PulseCandidateFinder

(

)

Default constructor, make sure to set the channel name with SetChannel if you use this constructor.

The constructor just sets all the parameter values.

Definition at line 22 of file PulseCandidateFinder.cpp.

References fDefaultParameterValues, and SetDefaultParameterValues().

                                          :
    fChannel(IDs::kErrorDetector),
    fParameterValue(definitions::DefaultValue),
    fNoise(definitions::DefaultValue),
    fPedestal(definitions::DefaultValue),
    fNSigma(definitions::DefaultValue){

  // make sure we have default values
  if (fDefaultParameterValues.empty()) {
    SetDefaultParameterValues();
  }

}

PulseCandidateFinder::~PulseCandidateFinder

(

)

Empty destructor.

Definition at line 113 of file PulseCandidateFinder.cpp.

                                            {
}

---

Member Function Documentation

bool PulseCandidateFinder::CheckDigitiserOverflow

(

)

[private]

Check if the pulse is overflowed.

Checks each sample and if the value is equal to the maximum ADC value then we've overflowed the digitiser and can ignore this pulse

Definition at line 345 of file PulseCandidateFinder.cpp.

References fPulseIsland, TPulseIsland::GetBankName(), TSetupData::GetNBits(), TPulseIsland::GetSamples(), and TSetupData::Instance().

                                                  {
  const std::vector<int>& samples = fPulseIsland->GetSamples();
  unsigned int n_samples = samples.size();

  std::string bankname = fPulseIsland->GetBankName();
  int n_bits = TSetupData::Instance()->GetNBits(bankname);
  double max_adc_value = std::pow(2, n_bits);
  bool overflowed = false;

  // Loop through the samples
  for (unsigned int i = 0; i < n_samples; ++i) {
    if (samples[i] >= max_adc_value) {
      overflowed = true;
      break;
    }
  }

  return overflowed;
}

void PulseCandidateFinder::FillParameterHistogram

(

TH2D *

histogram

)

Takes a histogram and fills it with the parameters (both sample height above pedestals and sample differences between consecutive samples).

FillParameterHistogram Fills the given histogram with the relevant parameter based on the channel

Definition at line 269 of file PulseCandidateFinder.cpp.

References fPedestal, fPulseIsland, TPulseIsland::GetBankName(), TSetupData::GetDetectorName(), SetupNavigator::GetRunNumber(), TPulseIsland::GetSamples(), TPulseIsland::GetTriggerPolarity(), SetupNavigator::Instance(), and TSetupData::Instance().

Referenced by PulseCandidateFinder_InvestigateParameters::ProcessEntry().

                                                                 {

  std::string detname = TSetupData::Instance()->GetDetectorName(fPulseIsland->GetBankName());
  IDs::channel theChannel = detname;

  // Get some information from the TPI
  const std::vector<int>& samples = fPulseIsland->GetSamples();
  unsigned int n_samples = samples.size();
  int polarity = fPulseIsland->GetTriggerPolarity();

  int s1, s2, ds; // this sample value, the previous sample value and the change in the sample value

  // Loop through the samples and plot the 2D plot
  for (unsigned int i = 1; i < n_samples; ++i) {
    s1 = polarity * (samples[i-1] - fPedestal);
    s2 = polarity * (samples[i] - fPedestal);
    ds = s2 - s1;

    histogram->Fill(ds, s1);
  }

  std::stringstream histtitle;
  histtitle << "Plot of sample differences vs sample heights for " << detname << " for Run " << SetupNavigator::Instance()->GetRunNumber();
  histogram->SetTitle(histtitle.str().c_str());
  histogram->GetYaxis()->SetTitle("Sample Heights");
  histogram->GetXaxis()->SetTitle("Sample Differences");
}

void PulseCandidateFinder::FindCandidatePulses_Fast

(

int

rise

)

[private]

The algorithm for finding fast pulses.

Check the difference between consecutive samples and if it's above a certain value then it's that start of a candidate pulse. The end of the candidate pulse is when the samples go below pedestal

FindCandidatePulses_Fast Finds pulse candidates on fast pulse islands by looking for a sudden rise between consecutive samples

Definition at line 156 of file PulseCandidateFinder.cpp.

References fNoise, fPedestal, fPulseCandidateLocations, fPulseIsland, TPulseIsland::GetBankName(), TPulseIsland::GetSamples(), TPulseIsland::GetTriggerPolarity(), PulseCandidateFinder::Location::start, and PulseCandidateFinder::Location::stop.

Referenced by FindPulseCandidates().

                                                            {

  const std::vector<int>& samples = fPulseIsland->GetSamples();
  unsigned int n_samples = samples.size();

  std::string bankname = fPulseIsland->GetBankName();
  int polarity = fPulseIsland->GetTriggerPolarity();

  int s1, s2, ds; // this sample value, the previous sample value and the change in the sample value
  bool found = false;
  Location location;

  // Loop through the samples
  int n_before_start_samples = 2; // take a few samples from before the official start
  for (unsigned int i = 1; i < n_samples; ++i) {
    s1 = polarity * (samples[i-1] - fPedestal);
    s2 = polarity * (samples[i] - fPedestal);
    ds = s2 - s1;

    if (found) {

      if (s2 < fNoise) { // stop if the sample goes below pedestal
        location.stop = (int)i;
        if (location.stop >= (int)samples.size()) {
          location.stop = samples.size() - 1;
        }

        fPulseCandidateLocations.push_back(location);
        found = false;
      }
      else if (i == n_samples-1) { // Also stop if we are at the last sample (only do this check if we failed the above one)
        location.stop = (int) i;

        fPulseCandidateLocations.push_back(location);
        found = false;
      }
    } else {
      if (ds > rise) {
        found = true;
        location.start = (int)(i - 1) - n_before_start_samples;

        if (location.start < 0) {
          location.start = 0;
        }
      }
    }
  }
}

void PulseCandidateFinder::FindCandidatePulses_Slow

(

int

threshold

)

[private]

The algorithm for finding slow pulses.

Check the height above pedestal of each sample and if it's above a certain value then it's that start of a candidate pulse. The end of the candidate pulse is when the samples go below pedestal

FindCandidatePulses_Slow Finds pulse candidates on slow pulse islands by seeing if a sample goes above a threshold

Definition at line 207 of file PulseCandidateFinder.cpp.

References fNoise, fPedestal, fPulseCandidateLocations, fPulseIsland, TPulseIsland::GetBankName(), TPulseIsland::GetSamples(), TPulseIsland::GetTriggerPolarity(), PulseCandidateFinder::Location::start, and PulseCandidateFinder::Location::stop.

Referenced by FindPulseCandidates().

                                                                 {

  const std::vector<int>& samples = fPulseIsland->GetSamples();
  unsigned int n_samples = samples.size();

  std::string bankname = fPulseIsland->GetBankName();
  int polarity = fPulseIsland->GetTriggerPolarity();

  int sample_height; // the sample's height above pedestal
  int start, stop; // the start and stop location
  bool found = false;
  Location location;

  // Loop through the samples
  for (unsigned int i = 0; i < n_samples; ++i) {
    sample_height = polarity * (samples[i] - fPedestal);

    if (found) {
      if (sample_height < fNoise) { // stop if the sample goes below pedestal
        location.stop = (int)i;
        if (location.stop >=(int) samples.size()) {
          location.stop = samples.size() - 1;
        }

        start = stop = 0;
        fPulseCandidateLocations.push_back(location);
        found = false;
      }
      else if (i == n_samples-1) { // Also stop if we are at the last sample (only do this check if we failed the above one)
        location.stop = (int) i;

        fPulseCandidateLocations.push_back(location);
        found = false;
      }
    } else {
      if (sample_height > threshold) {
        found = true;

        // Track back until we get to the pedestal again so that we get the whole pulse (Ge-S pulses were being cut-off at the start)
        location.start = (int)(i);
        for (int j = i; j > 0; --j) {

          sample_height = polarity * (samples[j] - fPedestal);
          if (sample_height <= 0) {
            location.start = (int)(j);
            break;
          }
          else if (j == 1) { // if we are at the last iteration
            location.start = 0; // set the location to the start since we haven't gone below pedestal again
          }
        }
        if (location.start < 0) {
          location.start = 0;
        }
      }
    }
  }
}

void PulseCandidateFinder::FindPulseCandidates

(

const TPulseIsland *

pulse

)

Find the pulse candidates on the given TPulseIsland.

FindPulseCandidates() Finds the pulse candidates on the given TPulseIsland

Definition at line 75 of file PulseCandidateFinder.cpp.

References IDs::channel::Detector(), fChannel, FindCandidatePulses_Fast(), FindCandidatePulses_Slow(), fNSigma, fParameterValue, fPulseCandidateLocations, fPulseIsland, IDs::channel::isFast(), IDs::channel::isSlow(), IDs::channel::isValid(), and IDs::kGe.

Referenced by FirstCompleteAPGenerator::MakeTAPsWithPCF(), ExportPulse::PlotTPI(), and PulseCandidateFinder_InvestigateParameters::ProcessEntry().

                                                                        {
    if(!fChannel.isValid()){
        std::cout<<"Channel for PCF is not set, make sure to use "
                   "SetChannel() if you used the defualt constructor"<<std::endl;
        throw Except::UnspecifiedChannel();
    }

  // Clear the vector of pulse candidate locations first since it will still contain them from previous pulses
  fPulseCandidateLocations.clear();

  fPulseIsland = pulse;

  // Check if this pulse overflowed the digitiser
  //  if (!CheckDigitiserOverflow()) {
    // If we are using the "n_sigma" option, then all channels should use the slow pulse algorithm
    if (fNSigma != 0) {
      FindCandidatePulses_Slow(fParameterValue);
    }
    else { // We have a different algorithm for fast and slow pulses
      if (fChannel.isFast()) {
        if (fChannel.Detector() != IDs::kGe) {
          FindCandidatePulses_Slow(fParameterValue); // use the slow algorithm for the fast silicon pulses because of the noisy pedestal
        }
        else {
          FindCandidatePulses_Fast(fParameterValue);
        }
      }
      else if (fChannel.isSlow()) {
        FindCandidatePulses_Slow(fParameterValue);
      }
      else {
        // this is a scintillator so do the fast pulse analysis
        FindCandidatePulses_Fast(fParameterValue);
      }
    }
    //  }
}

int PulseCandidateFinder::GetNPulseCandidates

(

)

[inline]

Returns the number of pulse candidates that were found.

Definition at line 76 of file PulseCandidateFinder.h.

References fPulseCandidateLocations.

Referenced by PulseCandidateFinder_InvestigateParameters::ProcessEntry().

{ return fPulseCandidateLocations.size(); }

void PulseCandidateFinder::GetPulseCandidates

(

std::vector< TPulseIsland * > &

pulse_candidates

)

const

Returns the actual TPulseIsland of each candidate.

GetPulseCandidates() Fills a vector of the TPulseIslands of the pulse candidates that have been found

Definition at line 118 of file PulseCandidateFinder.cpp.

References fPulseCandidateLocations, fPulseIsland, TPulseIsland::GetBankName(), TPulseIsland::GetSamples(), TPulseIsland::GetTimeStamp(), TPulseIsland::SetBankName(), TPulseIsland::SetSamples(), and TPulseIsland::SetTimeStamp().

Referenced by FirstCompleteAPGenerator::MakeTAPsWithPCF(), and ExportPulse::PlotTPI().

                                                                                             {

  // Loop through the pulse candidate locations
  std::vector<int>::const_iterator start_new, stop_new;
  for (std::vector<Location>::const_iterator locationIter = fPulseCandidateLocations.begin();
          locationIter != fPulseCandidateLocations.end(); ++locationIter) {
    
    // Get iterator to the start locations
    start_new=fPulseIsland->GetSamples().begin();
    std::advance(start_new,locationIter->start);

    // Get iterator to the stop locations
    stop_new=fPulseIsland->GetSamples().begin();
    std::advance(stop_new,locationIter->stop);

    // Get the bank name and work out what the new timestamp will be
    std::string bankname = fPulseIsland->GetBankName();
    int new_timestamp = fPulseIsland->GetTimeStamp() + locationIter->start;

    // Make the new TPI
    int index=locationIter-fPulseCandidateLocations.begin();
    if((int)pulse_candidates.size() <= index || !pulse_candidates.at(index)){
        TPulseIsland* pulse_island = new TPulseIsland(new_timestamp, start_new, stop_new, bankname);
        pulse_candidates.push_back(pulse_island);
    }else{
        TPulseIsland* pulse_island=pulse_candidates.at(index);
        pulse_island->SetSamples(start_new,stop_new);
        pulse_island->SetTimeStamp(new_timestamp);
        pulse_island->SetBankName(bankname);
    }
  }
  for(unsigned int i=fPulseCandidateLocations.size();i< pulse_candidates.size();++i){
      pulse_candidates.at(i)->Reset();
  }
}

void PulseCandidateFinder::SetChannel

(

const std::string &

detname

)

Definition at line 66 of file PulseCandidateFinder.cpp.

References fChannel, fDefaultParameterValues, fNoise, fParameterValue, fPedestal, SetupNavigator::GetNoise(), SetupNavigator::GetPedestal(), and SetupNavigator::Instance().

Referenced by PulseCandidateFinder(), and ExportPulse::SetCurrentDetectorName().

                                                             {
  fChannel=detname;
  fNoise = SetupNavigator::Instance()->GetNoise(fChannel);
  fPedestal = SetupNavigator::Instance()->GetPedestal(fChannel);
  fParameterValue = fDefaultParameterValues[fChannel]; // set the parameter value for this channel
}

void PulseCandidateFinder::SetDefaultParameterValues

(

)

[private]

Called in the constructor if fDefaultParameterValues is empty, so that it can be filled.

SetDefaultParameterValues Sets the default parameter values

Definition at line 302 of file PulseCandidateFinder.cpp.

References fDefaultParameterValues.

Referenced by PulseCandidateFinder().

                                                     {

  // Set all the default values for the fast channels
  fDefaultParameterValues[IDs::channel("muSc")] = 230;
  fDefaultParameterValues[IDs::channel("muScA")] = 100;
  fDefaultParameterValues[IDs::channel("NDet")] = 100;
  fDefaultParameterValues[IDs::channel("NDet2")] = 100;

  fDefaultParameterValues[IDs::channel("Ge-F")] = 40;

  fDefaultParameterValues[IDs::channel("ScL")] = 100;
  fDefaultParameterValues[IDs::channel("ScR")] = 100;
  fDefaultParameterValues[IDs::channel("ScGe")] = 20;
  fDefaultParameterValues[IDs::channel("ScVe")] = 100;

  fDefaultParameterValues[IDs::channel("SiL2-F")] = 300;
  fDefaultParameterValues[IDs::channel("SiL1-1-F")] = 130;
  fDefaultParameterValues[IDs::channel("SiL1-2-F")] = 500;
  fDefaultParameterValues[IDs::channel("SiL1-3-F")] = 135;
  fDefaultParameterValues[IDs::channel("SiL1-4-F")] = 140;

  fDefaultParameterValues[IDs::channel("SiR2-F")] = 300;
  fDefaultParameterValues[IDs::channel("SiR1-1-F")] = 135;
  fDefaultParameterValues[IDs::channel("SiR1-2-F")] = 140;
  fDefaultParameterValues[IDs::channel("SiR1-3-F")] = 140;
  fDefaultParameterValues[IDs::channel("SiR1-4-F")] = 150;

  // Set all the default values for the slow parameters
  fDefaultParameterValues[IDs::channel("Ge-S")] = 500;

  fDefaultParameterValues[IDs::channel("SiL2-S")] = 100;
  fDefaultParameterValues[IDs::channel("SiL1-1-S")] = 50;
  fDefaultParameterValues[IDs::channel("SiL1-2-S")] = 80;
  fDefaultParameterValues[IDs::channel("SiL1-3-S")] = 120;
  fDefaultParameterValues[IDs::channel("SiL1-4-S")] = 80;

  fDefaultParameterValues[IDs::channel("SiR2-S")] = 100;
  fDefaultParameterValues[IDs::channel("SiR1-1-S")] = 50;
  fDefaultParameterValues[IDs::channel("SiR1-2-S")] = 65;
  fDefaultParameterValues[IDs::channel("SiR1-3-S")] = 65;
  fDefaultParameterValues[IDs::channel("SiR1-4-S")] = 62;
}

void PulseCandidateFinder::SetSigma

(

double

sigma

)

Definition at line 61 of file PulseCandidateFinder.cpp.

References fNoise, fNSigma, and fParameterValue.

Referenced by PulseCandidateFinder().

                                                {
    fNSigma=sigma;
    fParameterValue=fNSigma*fNoise;
}

---

Member Data Documentation

IDs::channel PulseCandidateFinder::fChannel [private]

The channel that this PulseCandidateFinder works on.

Definition at line 110 of file PulseCandidateFinder.h.

Referenced by FindPulseCandidates(), PulseCandidateFinder(), and SetChannel().

std::map< IDs::channel, int > PulseCandidateFinder::fDefaultParameterValues [static, private]

The map that stores the default parameter values in case there isn't one specified in the modules file.

Need to declare this outside of any method.

Definition at line 123 of file PulseCandidateFinder.h.

Referenced by PulseCandidateFinder(), SetChannel(), and SetDefaultParameterValues().

double PulseCandidateFinder::fNoise [private]

The noise value for this channel.

Definition at line 116 of file PulseCandidateFinder.h.

Referenced by FindCandidatePulses_Fast(), FindCandidatePulses_Slow(), SetChannel(), and SetSigma().

int PulseCandidateFinder::fNSigma [private]

The number of sigma (i.e. noise) that we want the threshold to be set to.

Definition at line 130 of file PulseCandidateFinder.h.

Referenced by FindPulseCandidates(), and SetSigma().

double PulseCandidateFinder::fParameterValue [private]

The value of the parameter to start a candidate pulse.

Definition at line 113 of file PulseCandidateFinder.h.

Referenced by FindPulseCandidates(), PulseCandidateFinder(), SetChannel(), and SetSigma().

double PulseCandidateFinder::fPedestal [private]

The pedestal value for this channel.

Definition at line 119 of file PulseCandidateFinder.h.

Referenced by FillParameterHistogram(), FindCandidatePulses_Fast(), FindCandidatePulses_Slow(), and SetChannel().

std::vector<Location> PulseCandidateFinder::fPulseCandidateLocations [private]

The vector that we store the pulse candidate locations in.

Definition at line 67 of file PulseCandidateFinder.h.

Referenced by FindCandidatePulses_Fast(), FindCandidatePulses_Slow(), FindPulseCandidates(), GetNPulseCandidates(), and GetPulseCandidates().

const TPulseIsland* PulseCandidateFinder::fPulseIsland [private]

The TPulseIsland that we are looking for candidates on.

Definition at line 64 of file PulseCandidateFinder.h.

Referenced by CheckDigitiserOverflow(), FillParameterHistogram(), FindCandidatePulses_Fast(), FindCandidatePulses_Slow(), FindPulseCandidates(), and GetPulseCandidates().

---

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

• rootana/src/TAP_generators/utils/PulseCandidateFinder.h
• rootana/src/TAP_generators/utils/PulseCandidateFinder.cpp