PlotTME_activeSiRmuStops Class Reference
[Modules]

Produce various plots that characterise the produced TMuonEvents. More...

#include <PlotTME_activeSiRmuStops.h>

Inheritance diagram for PlotTME_activeSiRmuStops:
BaseModule

List of all members.

Public Member Functions

 PlotTME_activeSiRmuStops (modules::options *opts)
 Constructor description. If necessary, add a details tag like above.
 ~PlotTME_activeSiRmuStops ()
 Is anything done in the destructor?
int ProcessGenericEntry (TGlobalData *gData, const TSetupData *gSetup)
int Preprocess (TGlobalData *gData, const TSetupData *gSetup)
 Method called by the main pre-process loop.
int Postprocess (TGlobalData *gData, const TSetupData *gSetup)
 Method called by the main pre-process loop.
void SetAlias (const std::string &alias)
std::string GetAlias () const
const char * GetName () const
 Get the name of this module as given to the constructor of the base class.

Protected Member Functions

bool Debug () const
TDirectory * GetDirectory () const
 Get the TDirectory for this module.
TDirectory * GetDirectory (const std::string &name="")

Protected Attributes

TDirectory * dir

Private Member Functions

virtual int ProcessEntry (TGlobalData *gData, const TSetupData *gSetup)
 What's calculated for every entry? Don't hesitate to repeat what was said in the class description.
virtual int BeforeFirstEntry (TGlobalData *gData, const TSetupData *setup)
 What needes to be done before each run? Don't hesitate to repeat what was said in the class description.
virtual int AfterLastEntry (TGlobalData *gData, const TSetupData *setup)
 What needs to be done after each run? Don't hesitate to repeat what was said in the class description.
void FillHistograms (const TMuonEvent *tme, const IDs::source &muSc_source, const IDs::source &siR2_source)

Private Attributes

long int fStoppedMus
long int fStoppedMus_PP
long int fNStopsThisEvent
long int fNStopsThisEvent_PP
long int fEventNo
IDs::channel fMuSc
IDs::channel fSiR2
TDetectorPulse::ParentChannel_t fChannel
double fMuScMax
double fMuScMin
double fSiR2Max
double fSiR2Min
TMEAlgorithm::ActiveSiRStop * fHasStoppedMuon
TH1F * fTDiff_PP
TH1F * fTDiff
TH1F * fTDiffMuons
TH1F * fTDiffMuons_PP
TH1F * fStopsPerEvent
TH1F * fStopsPerEvent_PP
TH1F * fStops
TH1F * fStops_PP
TH2F * fAmplitudes
TH2F * fAmplitudes_PP
TH2F * fTDiffVsAmpSiR2
TH2F * fTDiffVsAmpSiR2_PP
TH2F * fTDiffVsAmpSiR2_MuStop
TH2F * fTDiffVsAmpSiR2_MuStop_PP

Detailed Description

Produce various plots that characterise the produced TMuonEvents.

Author:
Ben Krikler

A longer, more descriptive block of text. Specifics like members and methods will be described later. You can add this to other groups instead of rootana_modules or in addition to rootana_modules by adding more of the ingroup tags.

Definition at line 29 of file PlotTME_activeSiRmuStops.h.

Constructor & Destructor Documentation

PlotTME_activeSiRmuStops::PlotTME_activeSiRmuStops ( modules::options *  opts  ) 

Constructor description. If necessary, add a details tag like above.

Parameters:
[in] opts Describe the options this module takes.

Definition at line 22 of file PlotTME_activeSiRmuStops.cpp.

References DEBUG_VALUE, fChannel, fMuSc, and fSiR2.

00022                                                                       :
00023    BaseModule("PlotTME_activeSiRmuStops",opts),
00024    fStoppedMus(0),fStoppedMus_PP(0), fNStopsThisEvent(0),fNStopsThisEvent_PP(0), fEventNo(1),
00025    fMuSc(opts->GetString("second","muSc")),
00026    fSiR2(opts->GetString("first","SiR2")),
00027    fChannel((TDetectorPulse::ParentChannel_t) (IDs::channel::GetSlowFastEnum(opts->GetString("channel","fast"))-IDs::kFast)),
00028    fMuScMax(opts->GetDouble("muSc_max",1e9)),
00029    fMuScMin(opts->GetDouble("muSc_min",0)),
00030    fSiR2Max(opts->GetDouble("SiR2_max",1e9)),
00031    fSiR2Min(opts->GetDouble("SiR2_min",0)),
00032    fHasStoppedMuon(new TMEAlgorithm::ActiveSiRStop(IDs::source(),fMuScMin,fMuScMax,fSiR2Min,fSiR2Max))
00033 { 
00034 DEBUG_VALUE(fMuSc, fSiR2,fChannel);
00035 }

PlotTME_activeSiRmuStops::~PlotTME_activeSiRmuStops (  ) 

Is anything done in the destructor?

Definition at line 37 of file PlotTME_activeSiRmuStops.cpp.

References fHasStoppedMuon.

00037                                                    {
00038   if(fHasStoppedMuon) delete fHasStoppedMuon;
00039 }

Member Function Documentation

int PlotTME_activeSiRmuStops::AfterLastEntry ( TGlobalData *  gData,
const TSetupData *  setup 
) [private, virtual]

What needs to be done after each run? Don't hesitate to repeat what was said in the class description.

Returns:
Non-zero to indicate a problem.

Implements BaseModule.

Definition at line 180 of file PlotTME_activeSiRmuStops.cpp.

References fAmplitudes, fAmplitudes_PP, fMuScMax, fMuScMin, fStoppedMus, and fTDiffVsAmpSiR2_MuStop_PP.

00180                                                                                       {
00181   double y_min=fAmplitudes->GetYaxis()->GetXmin();
00182   double y_max=fAmplitudes->GetYaxis()->GetXmax();
00183   TLine* muSc_cut=new TLine(fMuScMin, y_min, fMuScMin, y_max);
00184   muSc_cut->SetLineColor(kRed);
00185   fAmplitudes->GetListOfFunctions()->Add(muSc_cut->Clone());
00186   fAmplitudes_PP->GetListOfFunctions()->Add(muSc_cut->Clone());
00187   muSc_cut->SetX1(fMuScMax);
00188   muSc_cut->SetX2(fMuScMax);
00189   fAmplitudes->GetListOfFunctions()->Add(muSc_cut->Clone());
00190   fAmplitudes_PP->GetListOfFunctions()->Add(muSc_cut->Clone());
00191   fTDiffVsAmpSiR2_MuStop_PP->ProjectionY("_py",236);
00192 
00193   cout<<"PlotTME_activeSiRmuStops::AfterLastEntry: Total number of muon stops = "<<fStoppedMus<<endl;
00194   return 0;
00195 }

int PlotTME_activeSiRmuStops::BeforeFirstEntry ( TGlobalData *  gData,
const TSetupData *  setup 
) [private, virtual]

What needes to be done before each run? Don't hesitate to repeat what was said in the class description.

Returns:
Non-zero to indicate a problem.

Implements BaseModule.

Definition at line 41 of file PlotTME_activeSiRmuStops.cpp.

References fAmplitudes, fAmplitudes_PP, fStops, fStops_PP, fStopsPerEvent, fStopsPerEvent_PP, fTDiff, fTDiff_PP, fTDiffMuons, fTDiffMuons_PP, fTDiffVsAmpSiR2, fTDiffVsAmpSiR2_MuStop_PP, fTDiffVsAmpSiR2_PP, EventNavigator::GetLoopNEntries(), EventNavigator::GetStartEntry(), EventNavigator::GetStopEntry(), and EventNavigator::Instance().

00041                                                                                         {
00042 
00043     fTDiff=new TH1F("hTDiff", "TDiff of SiR2 hits compared to muSc (with pile-up)", 5000, -1.2e4,1.2e4);
00044     fTDiff->SetXTitle("t_{SiR2} - t_{muSc} (ns)");
00045     fTDiff_PP=new TH1F("hTDiff_PP", "TDiff of SiR2 hits compared to muSc (pile-up protected)", 5000, -1.2e4,1.2e4);
00046     fTDiff_PP->SetXTitle(fTDiff->GetXaxis()->GetTitle());
00047 
00048     fTDiffMuons=new TH1F("hTDiffMuons", "TDiff of muons considered to have stopped (with pile-up)", 5000, -1.2e4,1.2e4);
00049     fTDiffMuons->SetXTitle("t_{SiR2} - t_{muSc} (ns)");
00050     fTDiffMuons_PP=new TH1F("hTDiffMuons_PP", "TDiff of muons considered to have stopped (pile-up protected)", 5000, -1.2e4,1.2e4);
00051     fTDiffMuons_PP->SetXTitle(fTDiffMuons->GetXaxis()->GetTitle());
00052 
00053     fTDiffVsAmpSiR2=new TH2F("hTDiffVsAmpSiR2",
00054                              "Amplitudes of SiR2 hits (with pile-up) against the time difference compared to muSc ",
00055                               400, -1.1e4, 1.1e4, 400,0,4000);
00056     fTDiffVsAmpSiR2->SetXTitle(fTDiff->GetXaxis()->GetTitle());
00057     fTDiffVsAmpSiR2->SetYTitle("Amplitude in SiR2 (ADC units)");
00058     fTDiffVsAmpSiR2_PP=new TH2F("hTDiffVsAmpSiR2_PP",
00059                              "Amplitudes of SiR2 hits (pile-up protected) against the time diference compared to muSc",
00060                               400, -1.1e4, 1.1e4, 400,0,4000);
00061     fTDiffVsAmpSiR2_PP->SetXTitle(fTDiffVsAmpSiR2->GetXaxis()->GetTitle());
00062     fTDiffVsAmpSiR2_PP->SetYTitle(fTDiffVsAmpSiR2->GetYaxis()->GetTitle());
00063 
00064     //fTDiffVsAmpSiR2_MuStop=new TH2F("hTDiffVsAmpSiR2_MuStop",
00065     //                                "Amplitudes of SiR2 hits compared to muSc (with pile-up) against the time diference",
00066     //                                 400, -1.1e4, 1.1e4, 400,0,4000);
00067     //fTDiffVsAmpSiR2_MuStop->SetXTitle(fTDiff->GetXaxis()->GetTitle());
00068     //fTDiffVsAmpSiR2_MuStop->SetYTitle("Amplitude in SiR2 (ADC units)");
00069     fTDiffVsAmpSiR2_MuStop_PP=new TH2F("hTDiffVsAmpSiR2_MuStop_PP",
00070                                     "Amplitudes of SiR2 hits compared to muSc (pile-up protected) against the time diference",
00071                                      400, -1.1e4, 1.1e4, 400,0,4000);
00072     fTDiffVsAmpSiR2_MuStop_PP->SetXTitle(fTDiffVsAmpSiR2->GetXaxis()->GetTitle());
00073     fTDiffVsAmpSiR2_MuStop_PP->SetYTitle(fTDiffVsAmpSiR2->GetYaxis()->GetTitle());
00074 
00075 
00076     fAmplitudes=new TH2F("hAmp2d", "Amplitudes of SiR2 hits compared to muSc (with pile-up)", 400, 0,4000, 400,0,4000);
00077     fAmplitudes->SetXTitle("Amplitude in muSc (ADC units)");
00078     fAmplitudes->SetYTitle("Amplitude in SiR2 (ADC units)");
00079     fAmplitudes_PP=new TH2F("hAmp2d_PP", "Amplitudes of SiR2 hits compared to muSc (pile-up protected)", 400, 0,4000, 400,0,4000);
00080     fAmplitudes_PP->SetXTitle(fAmplitudes->GetXaxis()->GetTitle());
00081     fAmplitudes_PP->SetYTitle(fAmplitudes->GetYaxis()->GetTitle());
00082 
00083     const EventNavigator& event_ngtr= EventNavigator::Instance();
00084     fStopsPerEvent=new TH1F("hStoppedPerEvent","Number of #mu stops per midas event (with pile-up)",
00085                   event_ngtr.GetLoopNEntries(), event_ngtr.GetStartEntry(), event_ngtr.GetStopEntry());
00086     fStopsPerEvent->SetXTitle("Event Number");
00087     fStopsPerEvent->SetYTitle("Number of #mu stops");
00088 
00089     fStopsPerEvent_PP=new TH1F("hStoppedPerEvent_PP","Number of #mu stops per midas event (pile-up protected)",
00090                   event_ngtr.GetLoopNEntries(), event_ngtr.GetStartEntry(), event_ngtr.GetStopEntry());
00091     fStopsPerEvent_PP->SetXTitle("Event Number");
00092     fStopsPerEvent_PP->SetYTitle("Number of #mu stops");
00093 
00094     fStops=new TH1F("hStopped","Number of #mu stops per midas event (pile-up protected)", 250, 0, 250);
00095     fStops->SetXTitle("Number of #mu stops");
00096     fStops_PP=new TH1F("hStopped_PP","Number of #mu stops per midas event (pile-up protected)", 250, 0, 250);
00097     fStops_PP->SetXTitle("Number of #mu stops");
00098 
00099 
00100   return 0;
00101 }

bool BaseModule::Debug (  )  const [inline, protected, inherited]

Check whether this module was asked to print extra debug information

Returns:
true if 'debug' was given in the modules file, false if not

Definition at line 71 of file BaseModule.h.

References BaseModule::fDebug.

Referenced by MakeAnalysedPulses::AddGenerator(), ExportPulse::AddToExportList(), PulseCandidateFinder_InvestigateParameters::AfterLastEntry(), PlotTPI_PedestalAndNoise::AfterLastEntry(), PlotTDPs::AfterLastEntry(), PlotTDP_TDiff::AfterLastEntry(), IslandLength::AfterLastEntry(), IslandAmplitude::AfterLastEntry(), MakeDetectorPulses::BeforeFirstEntry(), TemplateCreator::BeforeFirstEntry(), PulseCandidateFinder_InvestigateParameters::BeforeFirstEntry(), PlotTPI_PedestalAndNoise::BeforeFirstEntry(), PlotTDPs::BeforeFirstEntry(), PlotTDP_TDiff::BeforeFirstEntry(), IslandLength::BeforeFirstEntry(), IslandAmplitude::BeforeFirstEntry(), PulseViewer::ConsiderDrawing(), MakeAnalysedPulses::MakeAnalysedPulses(), MakeDetectorPulses::MakeGenerator(), ExportPulse::PlotTPI(), MakeDetectorPulses::ProcessEntry(), TemplateCreator::ProcessEntry(), PulseCandidateFinder_InvestigateParameters::ProcessEntry(), MakeAnalysedPulses::ProcessEntry(), PulseViewer::ProcessEntry(), PlotTDP_TDiff::ProcessEntry(), and TemplateCreator::StartTemplate().

00071 {return fDebug;};

void PlotTME_activeSiRmuStops::FillHistograms ( const TMuonEvent *  tme,
const IDs::source &  muSc_source,
const IDs::source &  siR2_source 
) [private]

Definition at line 137 of file PlotTME_activeSiRmuStops.cpp.

References fAmplitudes, fAmplitudes_PP, fChannel, fHasStoppedMuon, fMuScMax, fMuScMin, fNStopsThisEvent, fNStopsThisEvent_PP, fTDiff, fTDiff_PP, fTDiffMuons_PP, fTDiffVsAmpSiR2, fTDiffVsAmpSiR2_MuStop_PP, fTDiffVsAmpSiR2_PP, TDetectorPulse::GetAmplitude(), TMuonEvent::GetCentralMuon(), TDetectorPulse::GetTime(), TMuonEvent::GetTime(), TDetectorPulse::kFast, TMuonEvent::NumPulses(), and TMEAlgorithm::ActiveSiRStop::SetSiR2Source().

Referenced by ProcessEntry().

00137                                                                                                                               {
00138   //check if we pass the muSc muon cut
00139   const double muSc_amp=tme->GetCentralMuon()->GetAmplitude(TDetectorPulse::kFast);
00140 
00141   const double time=tme->GetTime();
00142   const int N_muSc=tme->NumPulses(muSc_source);
00143   const int N_sir2=tme->NumPulses(sir2_source);
00144 
00145   // Scan for a muon hit in the SiR2
00146   fHasStoppedMuon->SetSiR2Source(sir2_source);
00147   bool a_stop=(*fHasStoppedMuon)(tme,fChannel);
00148   if(a_stop) {
00149     ++fNStopsThisEvent;
00150     if(!tme->HasMuonPileup()) ++fNStopsThisEvent_PP;
00151   }
00152 
00153   // Fill all plots for SiR2
00154   for(int i=0; i< N_sir2; ++i){
00155     const TDetectorPulse* sir2_tdp=tme->GetPulse(sir2_source,i);
00156     const double t_diff=sir2_tdp->GetTime(fChannel) - time;
00157     const double sir2_amp=sir2_tdp->GetAmplitude(fChannel);
00158     fTDiff->Fill(t_diff);
00159     fTDiffVsAmpSiR2->Fill(t_diff, sir2_amp );
00160     if(!tme->HasMuonPileup()){
00161       if(muSc_amp>fMuScMin && muSc_amp< fMuScMax){
00162          fTDiff_PP->Fill(t_diff);
00163          fTDiffVsAmpSiR2_PP->Fill(t_diff, sir2_amp );
00164          if(a_stop){
00165            fTDiffMuons_PP->Fill(t_diff);
00166            fTDiffVsAmpSiR2_MuStop_PP->Fill(t_diff,sir2_amp);
00167          }
00168       }
00169     }
00170     for(int j=0; j< N_muSc; ++j){
00171       const double muSc_amp=tme->GetPulse(muSc_source,j)->GetAmplitude(TDetectorPulse::kFast);
00172       fAmplitudes->Fill(muSc_amp, sir2_amp );
00173       if(!tme->HasMuonPileup()){
00174          fAmplitudes_PP->Fill(muSc_amp, sir2_amp );
00175       }
00176     }
00177   }
00178 }

std::string BaseModule::GetAlias (  )  const [inline, inherited]

Returns a string for the alias of this module. May be empty if no alias was given in the modules file.

Definition at line 63 of file BaseModule.h.

References BaseModule::fAlias.

Referenced by BaseModule::BaseModule().

00063 {return fAlias;};

TDirectory * BaseModule::GetDirectory ( const std::string &  name = ""  )  [protected, inherited]

Definition at line 77 of file BaseModule.cpp.

References BaseModule::dir, and BaseModule::fDirectory.

00077                                                          {
00078   if(name.empty()) return fDirectory;
00079   TDirectory* dir=fDirectory->GetDirectory(name.c_str());
00080   if(dir) return dir;
00081   return fDirectory->mkdir(name.c_str());
00082 }

TDirectory* BaseModule::GetDirectory (  )  const [inline, protected, inherited]

Get the TDirectory for this module.

Definition at line 74 of file BaseModule.h.

References BaseModule::fDirectory.

Referenced by TemplateCreator::AfterLastEntry(), SavePulses::AfterLastEntry(), TemplateCreator::BeforeFirstEntry(), PlotTDPs::BeforeFirstEntry(), ExportPulse::ExportPulse(), and TemplateCreator::ProcessEntry().

00074 {return fDirectory;}

const char* BaseModule::GetName (  )  const [inline, inherited]

Get the name of this module as given to the constructor of the base class.

Definition at line 66 of file BaseModule.h.

References BaseModule::fName.

Referenced by SavePulses::BeforeFirstEntry(), PlotTDPs::BeforeFirstEntry(), PlotTDP_TDiff::BeforeFirstEntry(), PlotTAP_Time::ProcessEntry(), PlotTAP_Energy::ProcessEntry(), PlotTAP_Amplitude::ProcessEntry(), and LoopSequence::Run().

00066 {return fName.c_str();};

int BaseModule::Postprocess ( TGlobalData *  gData,
const TSetupData *  gSetup 
) [inherited]

Method called by the main pre-process loop.

Does some simple work, then hooks into the derived class through AfterLastEntry.

Returns:
0 on sucess and non-zero if a problem occurred

Definition at line 66 of file BaseModule.cpp.

References BaseModule::AfterLastEntry(), and BaseModule::fDirectory.

Referenced by LoopSequence::Postprocess().

00066                                                                        {
00067   // This is called by our main routine and would allow later to split into different 
00068   // process routines if we have more than one Tree and hence different tpyes of data input.
00069 
00070   if(fDirectory) fDirectory->cd();
00071   int ret = AfterLastEntry(gData, gSetup);
00072   gDirectory->cd("/");
00073 
00074   return ret;
00075 }

int BaseModule::Preprocess ( TGlobalData *  gData,
const TSetupData *  gSetup 
) [inherited]

Method called by the main pre-process loop.

Does some simple work, then hooks into the derived class through BeforeFirstEntry.

Returns:
0 on sucess and non-zero if a problem occurred

Definition at line 55 of file BaseModule.cpp.

References BaseModule::BeforeFirstEntry(), and BaseModule::fDirectory.

Referenced by LoopSequence::Preprocess().

00055                                                                       {
00056   // This is called by our main routine and would allow later to split into different 
00057   // process routines if we have more than one Tree and hence different tpyes of data input.
00058 
00059   if(fDirectory) fDirectory->cd();
00060   int ret = BeforeFirstEntry(gData, gSetup);
00061   gDirectory->cd("/");
00062 
00063   return ret;
00064 }

int PlotTME_activeSiRmuStops::ProcessEntry ( TGlobalData *  gData,
const TSetupData *  gSetup 
) [private, virtual]

What's calculated for every entry? Don't hesitate to repeat what was said in the class description.

Returns:
Non-zero to indicate a problem.

Implements BaseModule.

Definition at line 103 of file PlotTME_activeSiRmuStops.cpp.

References fEventNo, FillHistograms(), fMuSc, fNStopsThisEvent, fNStopsThisEvent_PP, fSiR2, fStoppedMus, fStoppedMus_PP, fStops, fStops_PP, fStopsPerEvent, fStopsPerEvent_PP, and gMuonEvents.

00103                                                                                     {
00104     // Reset the number of mu stops in the event
00105     fNStopsThisEvent=0;
00106     fNStopsThisEvent_PP=0;
00107 
00108     // Loop over each TME
00109     for(MuonEventList::const_iterator i_tme=gMuonEvents.begin();
00110             i_tme!=gMuonEvents.end(); ++i_tme){
00111        // Loop over each muSc source
00112        for(int muSc_source_index = (*i_tme)->GetFirstSourceIndex(fMuSc);
00113                muSc_source_index < (*i_tme)->GetLastSourceIndex(fMuSc) 
00114                   && muSc_source_index > -1; ++muSc_source_index){
00115          const IDs::source& muSc_source=(*i_tme)->GetSource(muSc_source_index);
00116          // Loop over each SiR2 source
00117          for(int siR2_source_index = (*i_tme)->GetFirstSourceIndex(fSiR2);
00118                  siR2_source_index < (*i_tme)->GetLastSourceIndex(fSiR2) 
00119                     && siR2_source_index > -1; ++siR2_source_index){
00120            const IDs::source& siR2_source=(*i_tme)->GetSource(siR2_source_index);
00121            // Fill histograms from the various sources
00122            FillHistograms(*i_tme, muSc_source, siR2_source);
00123          } // loop over SiR2 sources
00124        } // loop over muSc sources
00125     } // loop over each TME
00126 
00127     fStopsPerEvent->Fill(fEventNo, fNStopsThisEvent);
00128     fStopsPerEvent_PP->Fill(fEventNo, fNStopsThisEvent_PP);
00129     fStops->Fill( fNStopsThisEvent);
00130     fStops_PP->Fill( fNStopsThisEvent_PP);
00131     ++fEventNo;
00132     fStoppedMus+=fNStopsThisEvent;
00133     fStoppedMus_PP+=fNStopsThisEvent_PP;
00134   return 0;
00135 }

int BaseModule::ProcessGenericEntry ( TGlobalData *  gData,
const TSetupData *  gSetup 
) [inherited]

Method called by the main event loop for each entry in the input root tree. Does some simple work, then hooks into the derived class through ProcessEntry.

Returns:
0 on sucess and non-zero if a problem occurred

Definition at line 44 of file BaseModule.cpp.

References BaseModule::fDirectory, and BaseModule::ProcessEntry().

Referenced by LoopSequence::Process().

00044                                                                                {
00045   // This is called by our main routine and would allow later to split into different 
00046   // process routines if we have more than one Tree and hence different tpyes of data input.
00047 
00048   if(fDirectory) fDirectory->cd();
00049   int ret = ProcessEntry(gData, gSetup);
00050   gDirectory->cd("/");
00051 
00052   return ret;
00053 }

void BaseModule::SetAlias ( const std::string &  alias  )  [inline, inherited]

Sets the alias for this module, which should be provided in the modules file

Definition at line 59 of file BaseModule.h.

References BaseModule::fAlias.

Referenced by BaseModule::BaseModule().

00059 {fAlias=alias;};

Member Data Documentation

TDirectory* BaseModule::dir [protected, inherited]

Many modules use 'dir' still which was the old protected pointer to the modules directory. To prevent things being broken so soon, we keep this pointer available, but be warned that it will be removed shortly...

Definition at line 98 of file BaseModule.h.

Referenced by BaseModule::BaseModule(), FastSlowCompare::FastSlowCompare(), GeSpectrum::GeSpectrum(), BaseModule::GetDirectory(), MakeMuonEvents::MakeMuonEvents(), and PlotAmpVsTDiff::PlotAmpVsTDiff().

TH2F* PlotTME_activeSiRmuStops::fAmplitudes [private]

Definition at line 76 of file PlotTME_activeSiRmuStops.h.

Referenced by AfterLastEntry(), BeforeFirstEntry(), and FillHistograms().

TH2F * PlotTME_activeSiRmuStops::fAmplitudes_PP [private]

Definition at line 76 of file PlotTME_activeSiRmuStops.h.

Referenced by AfterLastEntry(), BeforeFirstEntry(), and FillHistograms().

TDetectorPulse::ParentChannel_t PlotTME_activeSiRmuStops::fChannel [private]

Definition at line 69 of file PlotTME_activeSiRmuStops.h.

Referenced by FillHistograms(), and PlotTME_activeSiRmuStops().

long int PlotTME_activeSiRmuStops::fEventNo [private]

Definition at line 66 of file PlotTME_activeSiRmuStops.h.

Referenced by ProcessEntry().

TMEAlgorithm::ActiveSiRStop* PlotTME_activeSiRmuStops::fHasStoppedMuon [private]

Definition at line 73 of file PlotTME_activeSiRmuStops.h.

Referenced by FillHistograms(), and ~PlotTME_activeSiRmuStops().

IDs::channel PlotTME_activeSiRmuStops::fMuSc [private]

Definition at line 68 of file PlotTME_activeSiRmuStops.h.

Referenced by PlotTME_activeSiRmuStops(), and ProcessEntry().

double PlotTME_activeSiRmuStops::fMuScMax [private]

Definition at line 71 of file PlotTME_activeSiRmuStops.h.

Referenced by AfterLastEntry(), and FillHistograms().

double PlotTME_activeSiRmuStops::fMuScMin [private]

Definition at line 71 of file PlotTME_activeSiRmuStops.h.

Referenced by AfterLastEntry(), and FillHistograms().

long int PlotTME_activeSiRmuStops::fNStopsThisEvent [private]

Definition at line 65 of file PlotTME_activeSiRmuStops.h.

Referenced by FillHistograms(), and ProcessEntry().

long int PlotTME_activeSiRmuStops::fNStopsThisEvent_PP [private]

Definition at line 65 of file PlotTME_activeSiRmuStops.h.

Referenced by FillHistograms(), and ProcessEntry().

IDs::channel PlotTME_activeSiRmuStops::fSiR2 [private]

Definition at line 68 of file PlotTME_activeSiRmuStops.h.

Referenced by PlotTME_activeSiRmuStops(), and ProcessEntry().

double PlotTME_activeSiRmuStops::fSiR2Max [private]

Definition at line 71 of file PlotTME_activeSiRmuStops.h.

double PlotTME_activeSiRmuStops::fSiR2Min [private]

Definition at line 71 of file PlotTME_activeSiRmuStops.h.

long int PlotTME_activeSiRmuStops::fStoppedMus [private]

Definition at line 64 of file PlotTME_activeSiRmuStops.h.

Referenced by AfterLastEntry(), and ProcessEntry().

long int PlotTME_activeSiRmuStops::fStoppedMus_PP [private]

Definition at line 64 of file PlotTME_activeSiRmuStops.h.

Referenced by ProcessEntry().

TH1F * PlotTME_activeSiRmuStops::fStops [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and ProcessEntry().

TH1F * PlotTME_activeSiRmuStops::fStops_PP [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and ProcessEntry().

TH1F * PlotTME_activeSiRmuStops::fStopsPerEvent [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and ProcessEntry().

TH1F * PlotTME_activeSiRmuStops::fStopsPerEvent_PP [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and ProcessEntry().

TH1F * PlotTME_activeSiRmuStops::fTDiff [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and FillHistograms().

TH1F* PlotTME_activeSiRmuStops::fTDiff_PP [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and FillHistograms().

TH1F * PlotTME_activeSiRmuStops::fTDiffMuons [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry().

TH1F * PlotTME_activeSiRmuStops::fTDiffMuons_PP [private]

Definition at line 75 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and FillHistograms().

TH2F * PlotTME_activeSiRmuStops::fTDiffVsAmpSiR2 [private]

Definition at line 76 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and FillHistograms().

TH2F * PlotTME_activeSiRmuStops::fTDiffVsAmpSiR2_MuStop [private]

Definition at line 76 of file PlotTME_activeSiRmuStops.h.

TH2F * PlotTME_activeSiRmuStops::fTDiffVsAmpSiR2_MuStop_PP [private]

Definition at line 76 of file PlotTME_activeSiRmuStops.h.

Referenced by AfterLastEntry(), BeforeFirstEntry(), and FillHistograms().

TH2F * PlotTME_activeSiRmuStops::fTDiffVsAmpSiR2_PP [private]

Definition at line 76 of file PlotTME_activeSiRmuStops.h.

Referenced by BeforeFirstEntry(), and FillHistograms().

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