TemplateFitAPGenerator Class Reference

#include <TemplateFitAPGenerator.h>

Inheritance diagram for TemplateFitAPGenerator:
TVAnalysedPulseGenerator

List of all members.

Public Member Functions

 TemplateFitAPGenerator (TAPGeneratorOptions *opts)
virtual ~TemplateFitAPGenerator ()
virtual int ProcessPulses (const PulseIslandList &, AnalysedPulseList &)
 This method is called on each vector of pulses from a MIDAS event.
virtual bool MayDivideTPIs ()
void SetPulseList (PulseIslandList *list)
template<typename TypeOfTAP >
TypeOfTAP * MakeNewTAP (int parent_index) const
 The suggested method for constructing a new TAP.
TAnalysedPulse * MakeNewTAP (int parent_index) const
bool Debug () const
IDs::channel GetChannel () const
std::string GetBank () const
const IDs::source & GetSource () const
 Get the source id for this generator being used on the current channel.
virtual void CalibratePulses (AnalysedPulseList &theAnalysedPulses) const

Static Public Member Functions

static const char * TapType ()

Protected Member Functions

virtual void SetChannel (const std::string &det)
 Set the channel for this generator. Should NOT be called by user code.

Private Member Functions

bool PassesIntegralRatio (const TPulseIsland *pulse, double &integral, double &ratio) const
bool RefitWithTwo (TH1D *tpi, TTemplateFitAnalysedPulse *&tap_one, TTemplateFitAnalysedPulse *&tap_two) const
void InitializeSecondPulse (TH1D *tpi, const TTemplateFitAnalysedPulse *tap_one, int &second_time, double &second_scale) const

Private Attributes

double fIntegralMax
double fIntegralMin
double fIntegralRatioMax
double fIntegralRatioMin
double fTemplateAmp
double fTemplatePed
double fTemplateTime
double fTemplate2Amp
double fTemplate2Ped
double fTemplate2Time
double fInitPedestal
double fChi2MinToRefit
TTemplate * fTemplate
TTemplate * fTemplate2
TemplateMultiFitter * fFitter
TemplateMultiFitter * fDoubleFitter
Algorithm::IntegralRatio * fIntegralRatio
Algorithm::MaxBinAmplitude fMaxBin

Static Private Attributes

static TemplateArchive * fTemplateArchive = NULL
static TemplateArchive * fTemplateArchive2 = NULL

Friends

class MakeAnalysedPulses

Detailed Description

Definition at line 14 of file TemplateFitAPGenerator.h.

Constructor & Destructor Documentation

TemplateFitAPGenerator::TemplateFitAPGenerator ( TAPGeneratorOptions *  opts  ) 

Definition at line 16 of file TemplateFitAPGenerator.cpp.

References TemplateMultiFitter::AddTemplate(), fChi2MinToRefit, fDoubleFitter, fFitter, fIntegralMax, fIntegralMin, fIntegralRatio, fIntegralRatioMax, fIntegralRatioMin, fTemplate, fTemplate2, fTemplate2Amp, fTemplate2Ped, fTemplate2Time, fTemplateAmp, fTemplateArchive, fTemplateArchive2, fTemplatePed, fTemplateTime, TTemplate::GetAmplitude(), TVAnalysedPulseGenerator::GetChannel(), modules::options::GetDouble(), modules::options::GetFlag(), modules::options::GetInt(), TemplateArchive::GetName(), TTemplate::GetPedestal(), SetupRecord::GetPolarity(), EventNavigator::GetSetupRecord(), modules::options::GetString(), TemplateArchive::GetTemplate(), TTemplate::GetTime(), modules::options::HasOption(), TemplateMultiFitter::Init(), and EventNavigator::Instance().

00016                                                                        :
00017    TVAnalysedPulseGenerator("TemplateFitAPGenerator",opts),
00018     fInitPedestal(EventNavigator::Instance().GetSetupRecord().GetPedestal(GetChannel())),
00019     fTemplate2(NULL),
00020     fIntegralRatio(NULL),
00021     fMaxBin(fInitPedestal, EventNavigator::Instance().GetSetupRecord().GetPolarity(GetChannel()))
00022 {
00023    // get the templates from the archive
00024    if(!fTemplateArchive){
00025      fTemplateArchive=new TemplateArchive(opts->GetString("template_archive").c_str(),"READ");
00026    }
00027    if(opts->HasOption("template_archive_2")){
00028      std::string template_2_src=opts->GetString("template_archive_2");
00029      if (template_2_src!=fTemplateArchive->GetName() && !fTemplateArchive2)
00030         fTemplateArchive2=new TemplateArchive(opts->GetString("template_archive_2").c_str(),"READ");
00031      else if(!fTemplateArchive2){
00032         fTemplateArchive2=fTemplateArchive;
00033      }
00034    }
00035    fTemplate=fTemplateArchive->GetTemplate(GetChannel());
00036    if(fTemplateArchive2) fTemplate2=fTemplateArchive2->GetTemplate(GetChannel());
00037 
00038    // make the fitters
00039    fFitter = new TemplateMultiFitter(GetChannel().str());
00040    fFitter->AddTemplate(fTemplate);
00041    fFitter->Init();
00042    if(fTemplate2){
00043      fDoubleFitter = new TemplateMultiFitter(GetChannel().str());
00044      fDoubleFitter->AddTemplate(fTemplate);
00045      fDoubleFitter->AddTemplate(fTemplate2);
00046      fDoubleFitter->Init();
00047    }
00048 
00049    // prepare the integral ratio cuts
00050    if(opts->GetFlag("use_IR_cut")){
00051       fIntegralRatio=new Algorithm::IntegralRatio(
00052                       opts->GetInt("start_integral",10),
00053                       opts->GetInt("start_tail",60),
00054                       opts->GetInt("stop_integral",0),
00055                       EventNavigator::Instance().GetSetupRecord().GetPolarity(GetChannel()));
00056       fIntegralMax=opts->GetDouble("max_integral");
00057       fIntegralMin=opts->GetDouble("min_integral");
00058       fIntegralRatioMax=opts->GetDouble("max_ratio");
00059       fIntegralRatioMin=opts->GetDouble("min_ratio");
00060   }
00061 
00062   // cache the template parameters so we dont need to look them up
00063   fTemplateAmp=fTemplate->GetAmplitude();
00064   fTemplateTime=fTemplate->GetTime();
00065   fTemplatePed=fTemplate->GetPedestal();
00066 
00067   if(fTemplate2){
00068      fTemplate2Amp=fTemplate2->GetAmplitude();
00069      fTemplate2Time=fTemplate2->GetTime();
00070      fTemplate2Ped=fTemplate2->GetPedestal();
00071   }
00072 
00073   // chi2 to determine when we refit with 2 pulses
00074   fChi2MinToRefit=opts->GetDouble("min_chi2_to_refit",2e5);
00075 }

TemplateFitAPGenerator::~TemplateFitAPGenerator (  )  [virtual]

Definition at line 77 of file TemplateFitAPGenerator.cpp.

References fDoubleFitter, fFitter, fIntegralRatio, fTemplateArchive, and fTemplateArchive2.

00077                                                {
00078   delete fFitter;
00079     
00080   delete fDoubleFitter;
00081   if(fIntegralRatio) delete fIntegralRatio;
00082   if(fTemplateArchive) {
00083     delete fTemplateArchive;
00084     fTemplateArchive=NULL;
00085   }
00086   if(fTemplateArchive2) {
00087     delete fTemplateArchive2;
00088     fTemplateArchive2=NULL;
00089   }
00090 }

Member Function Documentation

void TVAnalysedPulseGenerator::CalibratePulses ( AnalysedPulseList &  theAnalysedPulses  )  const [virtual, inherited]

Definition at line 23 of file TVAnalysedPulseGenerator.cpp.

References TVAnalysedPulseGenerator::fAdcToEnergyGain, TVAnalysedPulseGenerator::fAdcToEnergyOffset, and TVAnalysedPulseGenerator::fCanCalibrate.

00023                                                                                        {
00024    if(fCanCalibrate){
00025       for(AnalysedPulseList::iterator i_tap=theAnalysedPulses.begin(); i_tap != theAnalysedPulses.end(); ++i_tap){
00026          const double amplitude=(*i_tap)->GetAmplitude();
00027          (*i_tap)->SetEnergy(fAdcToEnergyGain * amplitude + fAdcToEnergyOffset);
00028       }
00029    }
00030 }

bool TVAnalysedPulseGenerator::Debug (  )  const [inline, inherited]

Definition at line 77 of file TVAnalysedPulseGenerator.h.

References TVAnalysedPulseGenerator::fDebug.

Referenced by GaussFitAPGenerator::FitPulse(), TemplateConvolveAPGenerator::ProcessPulses(), and IntegralRatioAPGenerator::ProcessPulses().

00077 {return fDebug;};

std::string TVAnalysedPulseGenerator::GetBank (  )  const [inline, inherited]

A convenience method for analysis to get the channel ID of the channel being analysed

Definition at line 85 of file TVAnalysedPulseGenerator.h.

References TVAnalysedPulseGenerator::fBankName.

00085 {return fBankName;};

IDs::channel TVAnalysedPulseGenerator::GetChannel (  )  const [inline, inherited]

A convenience method for analysis to get the channel ID of the channel being analysed

Definition at line 81 of file TVAnalysedPulseGenerator.h.

References IDs::source::Channel(), and TVAnalysedPulseGenerator::fSource.

Referenced by FirstCompleteAPGenerator::DrawPulse(), FirstCompleteAPGenerator::FirstCompleteAPGenerator(), IntegralRatioAPGenerator::ProcessPulses(), TemplateConvolveAPGenerator::TemplateConvolveAPGenerator(), TemplateFitAPGenerator(), and TVAnalysedPulseGenerator::TVAnalysedPulseGenerator().

00081 {return fSource.Channel();};

const IDs::source& TVAnalysedPulseGenerator::GetSource (  )  const [inline, inherited]

Get the source id for this generator being used on the current channel.

Useful for a generator to know the full source much like in the above GetChannel method, but this could also be useful for checking that this generator is the one that made a given TAP in later analysis by comparing this value to that stored in the TAP itself.

Definition at line 94 of file TVAnalysedPulseGenerator.h.

References TVAnalysedPulseGenerator::fSource.

Referenced by TVAnalysedPulseGenerator::MakeNewTAP(), and IntegralRatioAPGenerator::ProcessPulses().

00094 {return fSource;};

void TemplateFitAPGenerator::InitializeSecondPulse ( TH1D *  tpi,
const TTemplateFitAnalysedPulse *  tap_one,
int &  second_time,
double &  second_scale 
) const [private]

Definition at line 220 of file TemplateFitAPGenerator.cpp.

References fTemplate, fTemplate2, TTemplate::GetAmplitude(), TTemplateFitAnalysedPulse::GetBinContent(), TTemplate::GetHisto(), TTemplate::GetTime(), and TAnalysedPulse::GetTime().

Referenced by RefitWithTwo().

00222                                                       {
00223     // scan from the time of the first tap and find the bin with the largest residual (within some window)
00224     int limit = tpi->GetNbinsX();
00225     int template_limit=tap_one->GetTime() - fTemplate->GetTime() + fTemplate->GetHisto()->GetNbinsX()-10;
00226     if(template_limit <  limit ) limit= template_limit;
00227     double residual, max_residual=-1e6;
00228     int max_bin=0;
00229     for( int bin=tap_one->GetTime(); bin < limit; ++bin){
00230       residual=tpi->GetBinContent(bin) - tap_one->GetBinContent(bin);
00231       if(residual>max_residual){
00232         max_residual=residual;
00233         max_bin=bin;
00234       }
00235     }
00236     second_time=max_bin - fTemplate2->GetTime();
00237     second_scale=max_residual / fTemplate2->GetAmplitude();
00238 }

TAnalysedPulse* TVAnalysedPulseGenerator::MakeNewTAP ( int  parent_index  )  const [inline, inherited]

Definition at line 73 of file TVAnalysedPulseGenerator.h.

00073                                                          {
00074             return MakeNewTAP<TAnalysedPulse>(parent_index);
00075         }

template<typename TypeOfTAP >
TypeOfTAP * TVAnalysedPulseGenerator::MakeNewTAP ( int  parent_index  )  const [inline, inherited]

The suggested method for constructing a new TAP.

In the process of constructing TAP, information that isn't immediately obvious how to get needs to be passed to TAP. This method returns a pointer to a TAP construced for you, and all you need to pass it is the TPulseIslandID.

In the case where a generator wants to add extra information to the standard TAP information, we expect people to derive from TAnalysedPulse. If your generator is one of these, then use the template argument to produce the type of TAP you desire. Note that this forces the constructor of the specialised TAP to be the same as for TAnalysedPulse itself.

For example, for to make a specialied analysed pulse called TSpecialAnalysedPulse (original, huh?) you would do: 

 TSpecialAnalysedPulse* tsap=MakeNewTAP<TSpecialAnalysedPulse>(parent_index);
Parameters:
[in] parent_index The TPulseIslandID of the TPI being used to make the new TAP.
Template Parameters:
in] TypeOfTAP The type of specialisation of TAnalysedPulse that you want to create.

Definition at line 137 of file TVAnalysedPulseGenerator.h.

References TVAnalysedPulseGenerator::fPulseList, and TVAnalysedPulseGenerator::GetSource().

Referenced by FirstCompleteAPGenerator::AnalyseOneTpi(), SimpIntAPGenerator::ProcessPulses(), MaxBinAPGenerator::ProcessPulses(), CFTimeMBAmpAPGenerator::ProcessPulses(), and CFTimeAPGenerator::ProcessPulses().

00137                                                                            {
00138     TypeOfTAP* pulse=NULL;
00139     TPulseIsland* parent = fPulseList->at(parent_index);
00140     pulse=new TypeOfTAP(GetSource(),parent_index,parent);
00141     return pulse;
00142 }

virtual bool TemplateFitAPGenerator::MayDivideTPIs (  )  [inline, virtual]
Todo:
Document this

Implements TVAnalysedPulseGenerator.

Definition at line 25 of file TemplateFitAPGenerator.h.

00025 {return true;};

bool TemplateFitAPGenerator::PassesIntegralRatio ( const TPulseIsland *  pulse,
double &  integral,
double &  ratio 
) const [private]

Definition at line 149 of file TemplateFitAPGenerator.cpp.

References fIntegralRatio, Algorithm::IntegralRatio::GetRatio(), Algorithm::IntegralRatio::GetTotal(), and Algorithm::IntegralRatio::SetPedestalToMinimum().

Referenced by ProcessPulses().

00149                                                                                                                {
00150    if(!fIntegralRatio) return true;
00151    try{
00152      fIntegralRatio->SetPedestalToMinimum(pulse);
00153      (*fIntegralRatio)(pulse);
00154    }catch(std::out_of_range& e){
00155      return false;
00156    }
00157    integral=fIntegralRatio->GetTotal();
00158    ratio=fIntegralRatio->GetRatio();
00159    if( fIntegralMax < integral || fIntegralMin > integral
00160        || fIntegralRatioMax < ratio || fIntegralRatioMin > ratio) {
00161        return false;
00162    }
00163    return true;
00164 }

int TemplateFitAPGenerator::ProcessPulses ( const PulseIslandList &  pil,
AnalysedPulseList &  apl 
) [virtual]

This method is called on each vector of pulses from a MIDAS event.

Parameters:
[in] pil The vector of TPIs to produce TAPs from.
[out] apl The vector of TAPs to append the new TAPs to.

Implements TVAnalysedPulseGenerator.

Definition at line 92 of file TemplateFitAPGenerator.cpp.

References fChi2MinToRefit, fFitter, fInitPedestal, fIntegralRatio, TemplateMultiFitter::FitWithOneTimeFree(), fMaxBin, fTemplate, fTemplate2, fTemplateAmp, fTemplateTime, TemplateMultiFitter::GetAmplitude(), TemplateMultiFitter::GetChi2(), TemplateMultiFitter::GetNDoF(), TemplateMultiFitter::GetPedestal(), TTemplate::GetRefineFactor(), TemplateMultiFitter::GetTime(), Algorithm::MaxBinAmplitude::GetTime(), functions::InterpolatePulse(), PassesIntegralRatio(), RefitWithTwo(), TTemplateFitAnalysedPulse::SetAmplitude(), TTemplateFitAnalysedPulse::SetChi2(), TTemplateFitAnalysedPulse::SetFitStatus(), TAnalysedPulse::SetIntegral(), TTemplateFitAnalysedPulse::SetIntegralRatio(), TTemplateFitAnalysedPulse::SetNDoF(), TTemplateFitAnalysedPulse::SetPedestal(), TemplateMultiFitter::SetPedestal(), TemplateMultiFitter::SetPulseEstimates(), TTemplateFitAnalysedPulse::SetTemplate(), and TTemplateFitAnalysedPulse::SetTime().

00094                                       {
00095 
00096   // Loop over all the TPIs given to us
00097   TTemplateFitAnalysedPulse* tap;
00098   double integral, ratio;
00099   for (PulseIslandList::const_iterator tpi=pulseList.begin();
00100        tpi!=pulseList.end(); tpi++){
00101 
00102     if(fIntegralRatio && !PassesIntegralRatio(*tpi, integral,ratio)){
00103        continue;
00104     }
00105     double init_amp=fMaxBin(*tpi)/fTemplateAmp;
00106     double init_time=  fMaxBin.GetTime() * fTemplate->GetRefineFactor()- fTemplateTime ;
00107     fFitter->SetPedestal(fInitPedestal);
00108     fFitter->SetPulseEstimates(0, init_amp, init_time);
00109 
00110     // Make histo for TPI
00111     TH1D* hPulseToFit=InterpolatePulse(*tpi,"hPulseToFit","hPulseToFit",false,fTemplate->GetRefineFactor());
00112     
00113     int fit_status = fFitter->FitWithOneTimeFree(0, hPulseToFit);
00114 
00115     // Now that we've found the information we were looking for make a TAP to
00116     // hold it.  This method makes a TAP and sets the parent TPI info.  It needs
00117     // the index of the parent TPI in the container as an argument
00118     tap = MakeNewTAP<TTemplateFitAnalysedPulse>(tpi-pulseList.begin());
00119     tap->SetTemplate(fTemplate);
00120     tap->SetPedestal(fFitter->GetPedestal());
00121     tap->SetAmplitude(fFitter->GetAmplitude(0));
00122     tap->SetTime(-fFitter->GetTime(0));
00123     tap->SetChi2(fFitter->GetChi2());
00124     tap->SetNDoF(fFitter->GetNDoF());
00125     tap->SetFitStatus(fit_status);
00126     tap->SetIntegral(integral);
00127     tap->SetIntegralRatio(ratio);
00128 
00129     if(fTemplate2 && fFitter->GetChi2() > fChi2MinToRefit){
00130         TTemplateFitAnalysedPulse* second_tap=NULL;
00131         bool better_with_2 = RefitWithTwo(hPulseToFit, tap, second_tap);
00132         if(better_with_2){
00133            analysedList.push_back(tap);
00134            analysedList.push_back(second_tap);
00135         } else{
00136            analysedList.push_back(tap);
00137            if(second_tap) delete second_tap;
00138         }
00139     } else {
00140        analysedList.push_back(tap);
00141     }
00142 
00143    }
00144 
00145    // returning 0 tells the caller that we were successful, return non-zero if not
00146    return 0;
00147 }

bool TemplateFitAPGenerator::RefitWithTwo ( TH1D *  tpi,
TTemplateFitAnalysedPulse *&  tap_one,
TTemplateFitAnalysedPulse *&  tap_two 
) const [private]

Definition at line 166 of file TemplateFitAPGenerator.cpp.

References fDoubleFitter, TemplateMultiFitter::FitWithAllTimesFixed(), TemplateMultiFitter::FitWithOneTimeFree(), fTemplate2, TemplateMultiFitter::GetAmplitude(), TAnalysedPulse::GetAmplitude(), TemplateMultiFitter::GetChi2(), TTemplateFitAnalysedPulse::GetChi2(), TemplateMultiFitter::GetNDoF(), TTemplateFitAnalysedPulse::GetNDoF(), TAnalysedPulse::GetParentID(), TemplateMultiFitter::GetPedestal(), TAnalysedPulse::GetPedestal(), TemplateMultiFitter::GetTime(), TAnalysedPulse::GetTime(), InitializeSecondPulse(), TTemplateFitAnalysedPulse::IsPileUpPulse(), TTemplateFitAnalysedPulse::SetAmplitude(), TTemplateFitAnalysedPulse::SetChi2(), TTemplateFitAnalysedPulse::SetFitStatus(), TTemplateFitAnalysedPulse::SetNDoF(), TTemplateFitAnalysedPulse::SetOtherPulse(), TTemplateFitAnalysedPulse::SetPedestal(), TemplateMultiFitter::SetPedestal(), TemplateMultiFitter::SetPulseEstimates(), TTemplateFitAnalysedPulse::SetTemplate(), and TTemplateFitAnalysedPulse::SetTime().

Referenced by ProcessPulses().

00166                                                                                                                                  {
00167 
00168   // find the max bin after the current fitted tap
00169   int second_time=-9999999;
00170   double second_scale=-9999999;
00171   InitializeSecondPulse(tpi,tap_one,second_time,second_scale);
00172 
00173   // fit the second template around the second peak
00174   fDoubleFitter->SetPedestal(tap_one->GetPedestal());
00175   fDoubleFitter->SetPulseEstimates( 0, tap_one->GetAmplitude(), tap_one->GetTime());
00176   fDoubleFitter->SetPulseEstimates( 1, second_scale, second_time);
00177   int fit_status = fDoubleFitter->FitWithOneTimeFree(1, tpi);
00178 
00179   // fit the first pulse again
00180   fit_status = fDoubleFitter->FitWithOneTimeFree(0, tpi);
00181 
00182   // fit the second pulse again
00183   fit_status = fDoubleFitter->FitWithAllTimesFixed(tpi);
00184 
00185   if(fit_status==0){
00186     // Has the double fit improved the chi-2 per NDoF
00187     double old_chi2=tap_one->GetChi2()/tap_one->GetNDoF();
00188     double new_chi2=fDoubleFitter->GetChi2()/fDoubleFitter->GetNDoF();
00189     if( (old_chi2 - new_chi2) < 0){
00190       // refill tap_one's values
00191       tap_one->SetPedestal(fDoubleFitter->GetPedestal());
00192       tap_one->SetAmplitude(fDoubleFitter->GetAmplitude(0));
00193       tap_one->SetTime(fDoubleFitter->GetTime(0));
00194       tap_one->SetChi2(fDoubleFitter->GetChi2());
00195       tap_one->SetNDoF(fDoubleFitter->GetNDoF());
00196       tap_one->SetFitStatus(fit_status);
00197 
00198       // make the second tap
00199       tap_two = MakeNewTAP<TTemplateFitAnalysedPulse>(tap_one->GetParentID());
00200       tap_two->SetTemplate(fTemplate2);
00201       tap_two->SetPedestal(fDoubleFitter->GetPedestal());
00202       tap_two->SetAmplitude(fDoubleFitter->GetAmplitude(1));
00203       tap_two->SetTime(fDoubleFitter->GetTime(1));
00204       tap_two->SetChi2(fDoubleFitter->GetChi2());
00205       tap_two->SetNDoF(fDoubleFitter->GetNDoF());
00206       tap_two->SetFitStatus(fit_status);
00207 
00208       // link the two pulses together
00209       tap_one->SetOtherPulse(tap_two);
00210       tap_two->SetOtherPulse(tap_one);
00211       tap_two->IsPileUpPulse();
00212 
00213       return true;
00214     }
00215   } 
00216 
00217   return false;
00218 }

virtual void TVAnalysedPulseGenerator::SetChannel ( const std::string &  det  )  [inline, protected, virtual, inherited]

Set the channel for this generator. Should NOT be called by user code.

Called by MakeAnalysedPulses to tell this generator what channel it is looking at.

Definition at line 108 of file TVAnalysedPulseGenerator.h.

References IDs::source::Channel(), TVAnalysedPulseGenerator::fBankName, TVAnalysedPulseGenerator::fSource, SetupNavigator::GetBank(), and SetupNavigator::Instance().

Referenced by TVAnalysedPulseGenerator::TVAnalysedPulseGenerator().

00108                                                      {
00109            fSource.Channel()=det;
00110            fBankName= SetupNavigator::Instance()->GetBank(det);
00111          };

void TVAnalysedPulseGenerator::SetPulseList ( PulseIslandList *  list  )  [inline, inherited]

Definition at line 44 of file TVAnalysedPulseGenerator.h.

References TVAnalysedPulseGenerator::fPulseList.

00044 {fPulseList=list;};

static const char* TemplateFitAPGenerator::TapType (  )  [inline, static]

Reimplemented from TVAnalysedPulseGenerator.

Definition at line 28 of file TemplateFitAPGenerator.h.

00028                                  {
00029         return TTemplateFitAnalysedPulse::Class()->GetName();
00030     }

Friends And Related Function Documentation

friend class MakeAnalysedPulses [friend, inherited]

Definition at line 101 of file TVAnalysedPulseGenerator.h.

Member Data Documentation

double TemplateFitAPGenerator::fChi2MinToRefit [private]

Definition at line 46 of file TemplateFitAPGenerator.h.

Referenced by ProcessPulses(), and TemplateFitAPGenerator().

TemplateMultiFitter* TemplateFitAPGenerator::fDoubleFitter [private]

Definition at line 50 of file TemplateFitAPGenerator.h.

Referenced by RefitWithTwo(), TemplateFitAPGenerator(), and ~TemplateFitAPGenerator().

TemplateMultiFitter* TemplateFitAPGenerator::fFitter [private]

Definition at line 49 of file TemplateFitAPGenerator.h.

Referenced by ProcessPulses(), TemplateFitAPGenerator(), and ~TemplateFitAPGenerator().

double TemplateFitAPGenerator::fInitPedestal [private]

Definition at line 45 of file TemplateFitAPGenerator.h.

Referenced by ProcessPulses().

double TemplateFitAPGenerator::fIntegralMax [private]

Definition at line 41 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

double TemplateFitAPGenerator::fIntegralMin [private]

Definition at line 41 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

Algorithm::IntegralRatio* TemplateFitAPGenerator::fIntegralRatio [private]

Definition at line 51 of file TemplateFitAPGenerator.h.

Referenced by PassesIntegralRatio(), ProcessPulses(), TemplateFitAPGenerator(), and ~TemplateFitAPGenerator().

double TemplateFitAPGenerator::fIntegralRatioMax [private]

Definition at line 42 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

double TemplateFitAPGenerator::fIntegralRatioMin [private]

Definition at line 42 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

Algorithm::MaxBinAmplitude TemplateFitAPGenerator::fMaxBin [private]

Definition at line 52 of file TemplateFitAPGenerator.h.

Referenced by ProcessPulses().

TTemplate* TemplateFitAPGenerator::fTemplate [private]

Definition at line 47 of file TemplateFitAPGenerator.h.

Referenced by InitializeSecondPulse(), ProcessPulses(), and TemplateFitAPGenerator().

TTemplate* TemplateFitAPGenerator::fTemplate2 [private]

Definition at line 48 of file TemplateFitAPGenerator.h.

Referenced by InitializeSecondPulse(), ProcessPulses(), RefitWithTwo(), and TemplateFitAPGenerator().

double TemplateFitAPGenerator::fTemplate2Amp [private]

Definition at line 44 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

double TemplateFitAPGenerator::fTemplate2Ped [private]

Definition at line 44 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

double TemplateFitAPGenerator::fTemplate2Time [private]

Definition at line 44 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

double TemplateFitAPGenerator::fTemplateAmp [private]

Definition at line 43 of file TemplateFitAPGenerator.h.

Referenced by ProcessPulses(), and TemplateFitAPGenerator().

TemplateArchive * TemplateFitAPGenerator::fTemplateArchive = NULL [static, private]

Definition at line 39 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator(), and ~TemplateFitAPGenerator().

TemplateArchive * TemplateFitAPGenerator::fTemplateArchive2 = NULL [static, private]

Definition at line 40 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator(), and ~TemplateFitAPGenerator().

double TemplateFitAPGenerator::fTemplatePed [private]

Definition at line 43 of file TemplateFitAPGenerator.h.

Referenced by TemplateFitAPGenerator().

double TemplateFitAPGenerator::fTemplateTime [private]

Definition at line 43 of file TemplateFitAPGenerator.h.

Referenced by ProcessPulses(), and TemplateFitAPGenerator().

The documentation for this class was generated from the following files:
Generated on 15 Jun 2016 for AlcapDAQ by  doxygen 1.6.1