Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes

WCSimDataCleaner Class Reference

#include "WCSimDataCleaner.hh"

List of all members.

Public Types

enum  EFilterConfig { kNone = 0, kPulseHeight = 1, kPulseHeightAndNeighbours = 2, kPulseHeightAndClusters = 3 }
typedef enum
WCSimDataCleaner::EFilterConfig 
FilterConfig_t

Public Member Functions

void RunPrintParameters ()
void SetConfig (Int_t config)
void SetMinPulseHeight (Double_t min)
void SetNeighbourRadius (Double_t radius)
void SetNeighbourDigits (Int_t digits)
void SetClusterRadius (Double_t radius)
void SetClusterDigits (Int_t digits)
void SetTimeWindow (Double_t window)
std::vector< WCSimRecoDigit * > * Run (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoDigit * > * ResetDigits (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoDigit * > * FilterDigits (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoDigit * > * FilterAll (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoDigit * > * FilterByPulseHeight (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoDigit * > * FilterByNeighbours (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoDigit * > * FilterByClusters (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoCluster * > * RecoClusters (std::vector< WCSimRecoDigit * > *digitlist)
std::vector< WCSimRecoDigit * > * FilterGoldenDigits (std::vector< WCSimRecoDigit * > *digitlist)

Static Public Member Functions

static WCSimDataCleanerInstance ()
static void Config (Int_t config)
static void MinPulseHeight (Double_t min)
static void NeighbourRadius (Double_t radius)
static void NeighbourDigits (Int_t digits)
static void ClusterRadius (Double_t radius)
static void ClusterDigits (Int_t digits)
static void TimeWindow (Double_t window)
static void PrintParameters ()

Private Member Functions

 WCSimDataCleaner ()
 ~WCSimDataCleaner ()
void Reset ()

Private Attributes

Int_t fConfig
Double_t fMinPulseHeight
Double_t fNeighbourRadius
Int_t fMinNeighbourDigits
Double_t fClusterRadius
Int_t fMinClusterDigits
Double_t fTimeWindow
std::vector< WCSimRecoCluster * > vClusterList
std::vector
< WCSimRecoClusterDigit * > 
vClusterDigitList
std::vector
< WCSimRecoClusterDigit * > 
vClusterDigitCollection
std::vector< WCSimRecoDigit * > * fFilterAll
std::vector< WCSimRecoDigit * > * fFilterByPulseHeight
std::vector< WCSimRecoDigit * > * fFilterByNeighbours
std::vector< WCSimRecoDigit * > * fFilterByClusters
std::vector< WCSimRecoCluster * > * fClusterList

Detailed Description

Definition at line 12 of file WCSimDataCleaner.hh.


Member Typedef Documentation


Member Enumeration Documentation

Enumerator:
kNone 
kPulseHeight 
kPulseHeightAndNeighbours 
kPulseHeightAndClusters 

Definition at line 16 of file WCSimDataCleaner.hh.

                             {
    kNone  = 0,
    kPulseHeight = 1,
    kPulseHeightAndNeighbours = 2,
    kPulseHeightAndClusters = 3
  } FilterConfig_t;


Constructor & Destructor Documentation

WCSimDataCleaner::WCSimDataCleaner (  )  [private]

Definition at line 72 of file WCSimDataCleaner.cc.

References fClusterList, fClusterRadius, fConfig, fFilterAll, fFilterByClusters, fFilterByNeighbours, fFilterByPulseHeight, fMinClusterDigits, fMinNeighbourDigits, fMinPulseHeight, fNeighbourRadius, and fTimeWindow.

{
  // cleaning mode
  fConfig = WCSimDataCleaner::kPulseHeightAndClusters;

  // default cleaning parameters
  fMinPulseHeight = 1.0;     // minimum pulse height (PEs)
  fNeighbourRadius = 200.0;  // clustering window (cm)
  fMinNeighbourDigits = 2;   // minimum neighbouring digits
  fClusterRadius = 200.0;    // clustering window (cm)
  fMinClusterDigits = 50;    // minimum clustered digits
  fTimeWindow = 25.0;        // timing window (ns)

  // vector of filtered digits
  fFilterAll = new std::vector<WCSimRecoDigit*>;
  fFilterByPulseHeight = new std::vector<WCSimRecoDigit*>;
  fFilterByNeighbours = new std::vector<WCSimRecoDigit*>;
  fFilterByClusters = new std::vector<WCSimRecoDigit*>;
  
  // vector of clusters
  fClusterList = new std::vector<WCSimRecoCluster*>;
}

WCSimDataCleaner::~WCSimDataCleaner (  )  [private]

Member Function Documentation

void WCSimDataCleaner::ClusterDigits ( Int_t  digits  )  [static]

Definition at line 57 of file WCSimDataCleaner.cc.

References Instance(), and SetClusterDigits().

void WCSimDataCleaner::ClusterRadius ( Double_t  radius  )  [static]

Definition at line 52 of file WCSimDataCleaner.cc.

References Instance(), and SetClusterRadius().

void WCSimDataCleaner::Config ( Int_t  config  )  [static]

Definition at line 32 of file WCSimDataCleaner.cc.

References Instance(), and SetConfig().

std::vector< WCSimRecoDigit * > * WCSimDataCleaner::FilterAll ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 188 of file WCSimDataCleaner.cc.

References fFilterAll.

Referenced by Run().

{
  // clear vector of filtered digits
  // ==============================
  fFilterAll->clear();

  // filter all digits
  // =================
  for( UInt_t idigit=0; idigit<myDigitList->size(); idigit++ ){
    WCSimRecoDigit* recoDigit = (WCSimRecoDigit*)(myDigitList->at(idigit));
    fFilterAll->push_back(recoDigit);
  }

  // return vector of filtered digits
  // ================================
  std::cout << "  filter all: " << fFilterAll->size() << std::endl;
  
  return fFilterAll;
}

std::vector< WCSimRecoDigit * > * WCSimDataCleaner::FilterByClusters ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 292 of file WCSimDataCleaner.cc.

References fFilterByClusters, WCSimRecoCluster::GetDigit(), WCSimRecoCluster::GetNDigits(), and RecoClusters().

Referenced by Run().

{
  // clear vector of filtered digits
  // ===============================
  fFilterByClusters->clear();

  // run clustering algorithm
  // ========================
  std::vector<WCSimRecoCluster*>* myClusterList = (std::vector<WCSimRecoCluster*>*)(this->RecoClusters(myDigitList));

  for( UInt_t icluster=0; icluster<myClusterList->size(); icluster++ ){
    WCSimRecoCluster* myCluster = (WCSimRecoCluster*)(myClusterList->at(icluster));
    for( Int_t idigit=0; idigit<myCluster->GetNDigits(); idigit++ ){
      WCSimRecoDigit* myDigit = (WCSimRecoDigit*)(myCluster->GetDigit(idigit));
      fFilterByClusters->push_back(myDigit);
    }
  }
  
  // return vector of filtered digits
  // ================================
  std::cout << "  filter by clusters: " << fFilterByClusters->size() << std::endl;
  
  return fFilterByClusters;
}

std::vector< WCSimRecoDigit * > * WCSimDataCleaner::FilterByNeighbours ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 230 of file WCSimDataCleaner.cc.

References fFilterByNeighbours, fMinNeighbourDigits, fNeighbourRadius, fTimeWindow, WCSimRecoDigit::GetTime(), WCSimRecoDigit::GetX(), WCSimRecoDigit::GetY(), and WCSimRecoDigit::GetZ().

Referenced by Run().

{
  // clear vector of filtered digits
  // ===============================
  fFilterByNeighbours->clear();

  // create array of neighbours
  // ==========================
  Int_t Ndigits = myDigitList->size();

  if( Ndigits<=0 ){
    return fFilterByNeighbours;
  }

  Int_t* numNeighbours = new Int_t[Ndigits];

  for( Int_t idigit=0; idigit<Ndigits; idigit++ ){
    numNeighbours[idigit] = 0;
  }

  // count number of neighbours
  // ==========================
  for( UInt_t idigit1=0; idigit1<myDigitList->size(); idigit1++ ){
    for( UInt_t idigit2=idigit1+1; idigit2<myDigitList->size(); idigit2++ ){
      WCSimRecoDigit* fdigit1 = (WCSimRecoDigit*)(myDigitList->at(idigit1));
      WCSimRecoDigit* fdigit2 = (WCSimRecoDigit*)(myDigitList->at(idigit2));

      Double_t dx = fdigit1->GetX() - fdigit2->GetX();
      Double_t dy = fdigit1->GetY() - fdigit2->GetY();
      Double_t dz = fdigit1->GetZ() - fdigit2->GetZ();
      Double_t dt = fdigit1->GetTime() - fdigit2->GetTime();
      Double_t drsq = dx*dx + dy*dy + dz*dz;

      if( drsq>0.0
       && drsq<fNeighbourRadius*fNeighbourRadius
       && fabs(dt)<fTimeWindow ){
        numNeighbours[idigit1]++;
        numNeighbours[idigit2]++;
      }
    }
  }

  // filter by number of neighbours
  // ==============================
  for( UInt_t idigit=0; idigit<myDigitList->size(); idigit++ ){
    WCSimRecoDigit* fdigit = (WCSimRecoDigit*)(myDigitList->at(idigit));
    if( numNeighbours[idigit]>=fMinNeighbourDigits ){
      fFilterByNeighbours->push_back(fdigit);
    }
  }

  // delete array of neighbours
  // ==========================
  delete [] numNeighbours;

  // return vector of filtered digits
  // ================================
  std::cout << "  filter by neighbours: " << fFilterByNeighbours->size() << std::endl;
  
  return fFilterByNeighbours;
}

std::vector< WCSimRecoDigit * > * WCSimDataCleaner::FilterByPulseHeight ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 208 of file WCSimDataCleaner.cc.

References fFilterByPulseHeight, fMinPulseHeight, and WCSimRecoDigit::GetQPEs().

Referenced by Run().

{
  // clear vector of filtered digits
  // ===============================
  fFilterByPulseHeight->clear();

  // filter by pulse height
  // ======================
  for( UInt_t idigit=0; idigit<myDigitList->size(); idigit++ ){
    WCSimRecoDigit* recoDigit = (WCSimRecoDigit*)(myDigitList->at(idigit));
    if( recoDigit->GetQPEs()>fMinPulseHeight ){
      fFilterByPulseHeight->push_back(recoDigit);
    }
  }

  // return vector of filtered digits
  // ================================
  std::cout << "  filter by pulse height: " << fFilterByPulseHeight->size() << std::endl;
  
  return fFilterByPulseHeight;
}

std::vector< WCSimRecoDigit * > * WCSimDataCleaner::FilterDigits ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 178 of file WCSimDataCleaner.cc.

References WCSimRecoDigit::PassFilter().

Referenced by Run().

{
  for( UInt_t idigit=0; idigit<myDigitList->size(); idigit++ ){
    WCSimRecoDigit* recoDigit = (WCSimRecoDigit*)(myDigitList->at(idigit));
    recoDigit->PassFilter();
  }

  return myDigitList;
}

std::vector<WCSimRecoDigit*>* WCSimDataCleaner::FilterGoldenDigits ( std::vector< WCSimRecoDigit * > *  digitlist  ) 
WCSimDataCleaner * WCSimDataCleaner::Instance (  )  [static]

Definition at line 15 of file WCSimDataCleaner.cc.

Referenced by ClusterDigits(), ClusterRadius(), Config(), MinPulseHeight(), NeighbourDigits(), NeighbourRadius(), PrintParameters(), WCSimRecoAB::RunFilter(), and TimeWindow().

{
  if( !fgDataCleaner ){
    fgDataCleaner = new WCSimDataCleaner();
  }

  if( !fgDataCleaner ){
    assert(fgDataCleaner);
  }

  if( fgDataCleaner ){

  }

  return fgDataCleaner;
}

void WCSimDataCleaner::MinPulseHeight ( Double_t  min  )  [static]

Definition at line 37 of file WCSimDataCleaner.cc.

References Instance(), and SetMinPulseHeight().

void WCSimDataCleaner::NeighbourDigits ( Int_t  digits  )  [static]

Definition at line 47 of file WCSimDataCleaner.cc.

References Instance(), and SetNeighbourDigits().

void WCSimDataCleaner::NeighbourRadius ( Double_t  radius  )  [static]

Definition at line 42 of file WCSimDataCleaner.cc.

References Instance(), and SetNeighbourRadius().

void WCSimDataCleaner::PrintParameters (  )  [static]

Definition at line 67 of file WCSimDataCleaner.cc.

References Instance(), and RunPrintParameters().

Referenced by main().

std::vector< WCSimRecoCluster * > * WCSimDataCleaner::RecoClusters ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 317 of file WCSimDataCleaner.cc.

References WCSimRecoClusterDigit::AddClusterDigit(), WCSimRecoCluster::AddDigit(), fClusterList, fClusterRadius, fMinClusterDigits, fTimeWindow, WCSimRecoClusterDigit::GetClusterDigit(), WCSimRecoClusterDigit::GetNClusterDigits(), WCSimRecoClusterDigit::GetRecoDigit(), WCSimRecoClusterDigit::GetTime(), WCSimRecoClusterDigit::GetX(), WCSimRecoClusterDigit::GetY(), WCSimRecoClusterDigit::GetZ(), WCSimRecoClusterDigit::IsAllClustered(), WCSimRecoClusterDigit::IsClustered(), WCSimRecoClusterDigit::SetClustered(), vClusterDigitCollection, vClusterDigitList, and vClusterList.

Referenced by FilterByClusters().

{  

  // delete cluster digits
  // =====================
  for( UInt_t i=0; i<vClusterDigitList.size(); i++ ){
    delete (WCSimRecoClusterDigit*)(vClusterDigitList.at(i));
  }
  vClusterDigitList.clear();

  // delete clusters
  // ===============
  for( UInt_t i=0; i<vClusterList.size(); i++ ){
    delete (WCSimRecoCluster*)(vClusterList.at(i));
  }
  vClusterList.clear();

  // clear vector clusters
  // =====================
  fClusterList->clear();

  // make cluster digits
  // ===================
  for( UInt_t idigit=0; idigit<myDigitList->size(); idigit++ ){
    WCSimRecoDigit* recoDigit = (WCSimRecoDigit*)(myDigitList->at(idigit));
    WCSimRecoClusterDigit* clusterDigit = new WCSimRecoClusterDigit(recoDigit);
    vClusterDigitList.push_back(clusterDigit);
  }

  // run clustering algorithm
  // ========================
  for( UInt_t idigit1=0; idigit1<vClusterDigitList.size(); idigit1++ ){
    for( UInt_t idigit2=idigit1+1; idigit2<vClusterDigitList.size(); idigit2++ ){

      WCSimRecoClusterDigit* fdigit1 = (WCSimRecoClusterDigit*)(vClusterDigitList.at(idigit1));
      WCSimRecoClusterDigit* fdigit2 = (WCSimRecoClusterDigit*)(vClusterDigitList.at(idigit2));

      Double_t dx = fdigit1->GetX() - fdigit2->GetX();
      Double_t dy = fdigit1->GetY() - fdigit2->GetY();
      Double_t dz = fdigit1->GetZ() - fdigit2->GetZ();
      Double_t dt = fdigit1->GetTime() - fdigit2->GetTime();
      Double_t drsq = dx*dx + dy*dy + dz*dz;

      if( drsq>0.0
       && drsq<fClusterRadius*fClusterRadius
       && fabs(dt)<fTimeWindow ){
        fdigit1->AddClusterDigit(fdigit2);
        fdigit2->AddClusterDigit(fdigit1);
      }
    }
  }

  // collect up clusters
  // ===================
  Bool_t carryon = 0;

  for( UInt_t idigit=0; idigit<vClusterDigitList.size(); idigit++ ){
    WCSimRecoClusterDigit* fdigit = (WCSimRecoClusterDigit*)(vClusterDigitList.at(idigit));

    if( fdigit->IsClustered()==0
     && fdigit->GetNClusterDigits()>0 ){
        
      vClusterDigitCollection.clear();
      vClusterDigitCollection.push_back(fdigit);
      fdigit->SetClustered();

      carryon = 1;
      while( carryon ){
        carryon = 0;

        for( UInt_t jdigit=0; jdigit<vClusterDigitCollection.size(); jdigit++ ){
          WCSimRecoClusterDigit* cdigit = (WCSimRecoClusterDigit*)(vClusterDigitCollection.at(jdigit));

          if( cdigit->IsAllClustered()==0 ){
            for( Int_t kdigit=0; kdigit<cdigit->GetNClusterDigits(); kdigit++ ){
              WCSimRecoClusterDigit* cdigitnew = (WCSimRecoClusterDigit*)(cdigit->GetClusterDigit(kdigit));
                
              if( cdigitnew->IsClustered()==0 ){
                vClusterDigitCollection.push_back(cdigitnew);
                cdigitnew->SetClustered();
                carryon = 1;
              }
            }
          }
        }
      }
    
      if( (Int_t)vClusterDigitCollection.size()>=fMinClusterDigits ){
        WCSimRecoCluster* cluster = new WCSimRecoCluster();
        fClusterList->push_back(cluster);
        vClusterList.push_back(cluster);

        for( UInt_t jdigit=0; jdigit<vClusterDigitCollection.size(); jdigit++ ){
          WCSimRecoClusterDigit* cdigit = (WCSimRecoClusterDigit*)(vClusterDigitCollection.at(jdigit));
          WCSimRecoDigit* recodigit = (WCSimRecoDigit*)(cdigit->GetRecoDigit());
          cluster->AddDigit(recodigit);        
        }
      }
    }
  }

  // return vector of clusters
  // =========================
  return fClusterList;
}

void WCSimDataCleaner::Reset (  )  [private]

Definition at line 120 of file WCSimDataCleaner.cc.

{

  return;
}

std::vector< WCSimRecoDigit * > * WCSimDataCleaner::ResetDigits ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 168 of file WCSimDataCleaner.cc.

References WCSimRecoDigit::ResetFilter().

Referenced by Run().

{
  for( UInt_t idigit=0; idigit<myDigitList->size(); idigit++ ){
    WCSimRecoDigit* recoDigit = (WCSimRecoDigit*)(myDigitList->at(idigit));
    recoDigit->ResetFilter();
  }

  return myDigitList;
}

std::vector< WCSimRecoDigit * > * WCSimDataCleaner::Run ( std::vector< WCSimRecoDigit * > *  digitlist  ) 

Definition at line 126 of file WCSimDataCleaner.cc.

References fConfig, FilterAll(), FilterByClusters(), FilterByNeighbours(), FilterByPulseHeight(), FilterDigits(), kNone, kPulseHeight, kPulseHeightAndClusters, kPulseHeightAndNeighbours, and ResetDigits().

Referenced by WCSimRecoAB::RunFilter().

{
  std::cout << " *** WCSimDataCleaner::Run(...) *** " << std::endl;

  // input digit list
  // ================
  std::vector<WCSimRecoDigit*>* myInputList = myDigitList;
  std::vector<WCSimRecoDigit*>* myOutputList = myDigitList;

  // filter all digits
  // =================
  myInputList = ResetDigits(myOutputList);
  myOutputList = (std::vector<WCSimRecoDigit*>*)(this->FilterAll(myInputList));
  myOutputList = FilterDigits(myOutputList);
  if( fConfig==WCSimDataCleaner::kNone ) return myOutputList;

  // filter by pulse height
  // ======================
  myInputList = ResetDigits(myOutputList);
  myOutputList = (std::vector<WCSimRecoDigit*>*)(this->FilterByPulseHeight(myInputList));
  myOutputList = FilterDigits(myOutputList);
  if( fConfig==WCSimDataCleaner::kPulseHeight ) return myOutputList;

  // filter using neighbouring digits
  // ================================
  myInputList = ResetDigits(myOutputList);
  myOutputList = (std::vector<WCSimRecoDigit*>*)(this->FilterByNeighbours(myInputList));
  myOutputList = FilterDigits(myOutputList);
  if( fConfig==WCSimDataCleaner::kPulseHeightAndNeighbours ) return myOutputList;

  // filter using clustered digits
  // =============================
  myInputList = ResetDigits(myOutputList);
  myOutputList = (std::vector<WCSimRecoDigit*>*)(this->FilterByClusters(myInputList));
  myOutputList = FilterDigits(myOutputList);
  if( fConfig==WCSimDataCleaner::kPulseHeightAndClusters ) return myOutputList;

  // return vector of filtered digits
  // ================================
  return myOutputList;
}

void WCSimDataCleaner::RunPrintParameters (  ) 

Definition at line 104 of file WCSimDataCleaner.cc.

References fClusterRadius, fConfig, fMinClusterDigits, fMinNeighbourDigits, fMinPulseHeight, fNeighbourRadius, and fTimeWindow.

Referenced by PrintParameters().

{
  std::cout << " *** WCSimDataCleaner::PrintParameters() *** " << std::endl;
  
  std::cout << "  Data Cleaner Parameters: " << std::endl
            << "   Config = " << fConfig<< std::endl
            << "   MinPulseHeight = " << fMinPulseHeight << std::endl
            << "   NeighbourRadius = " << fNeighbourRadius << std::endl
            << "   MinNeighbourDigits = " << fMinNeighbourDigits << std::endl
            << "   ClusterRadius = " << fClusterRadius << std::endl
            << "   MinClusterDigits = " << fMinClusterDigits << std::endl
            << "   TimeWindow = " << fTimeWindow << std::endl;

  return;
}

void WCSimDataCleaner::SetClusterDigits ( Int_t  digits  )  [inline]

Definition at line 41 of file WCSimDataCleaner.hh.

References fMinClusterDigits.

Referenced by ClusterDigits().

{ fMinClusterDigits = digits; }

void WCSimDataCleaner::SetClusterRadius ( Double_t  radius  )  [inline]

Definition at line 40 of file WCSimDataCleaner.hh.

References fClusterRadius.

Referenced by ClusterRadius().

{ fClusterRadius = radius; }

void WCSimDataCleaner::SetConfig ( Int_t  config  )  [inline]

Definition at line 36 of file WCSimDataCleaner.hh.

References fConfig.

Referenced by Config().

{ fConfig = config; }

void WCSimDataCleaner::SetMinPulseHeight ( Double_t  min  )  [inline]

Definition at line 37 of file WCSimDataCleaner.hh.

References fMinPulseHeight.

Referenced by MinPulseHeight().

{ fMinPulseHeight = min; }

void WCSimDataCleaner::SetNeighbourDigits ( Int_t  digits  )  [inline]

Definition at line 39 of file WCSimDataCleaner.hh.

References fMinNeighbourDigits.

Referenced by NeighbourDigits().

{ fMinNeighbourDigits = digits; }

void WCSimDataCleaner::SetNeighbourRadius ( Double_t  radius  )  [inline]

Definition at line 38 of file WCSimDataCleaner.hh.

References fNeighbourRadius.

Referenced by NeighbourRadius().

{ fNeighbourRadius = radius; }

void WCSimDataCleaner::SetTimeWindow ( Double_t  window  )  [inline]

Definition at line 42 of file WCSimDataCleaner.hh.

References fTimeWindow.

Referenced by TimeWindow().

{ fTimeWindow = window; }

void WCSimDataCleaner::TimeWindow ( Double_t  window  )  [static]

Definition at line 62 of file WCSimDataCleaner.cc.

References Instance(), and SetTimeWindow().


Member Data Documentation

Definition at line 87 of file WCSimDataCleaner.hh.

Referenced by RecoClusters(), WCSimDataCleaner(), and ~WCSimDataCleaner().

Int_t WCSimDataCleaner::fConfig [private]

Definition at line 65 of file WCSimDataCleaner.hh.

Referenced by Run(), RunPrintParameters(), SetConfig(), and WCSimDataCleaner().

std::vector<WCSimRecoDigit*>* WCSimDataCleaner::fFilterAll [private]

Definition at line 81 of file WCSimDataCleaner.hh.

Referenced by FilterAll(), WCSimDataCleaner(), and ~WCSimDataCleaner().

Definition at line 84 of file WCSimDataCleaner.hh.

Referenced by FilterByClusters(), WCSimDataCleaner(), and ~WCSimDataCleaner().

Definition at line 83 of file WCSimDataCleaner.hh.

Referenced by FilterByNeighbours(), WCSimDataCleaner(), and ~WCSimDataCleaner().

Definition at line 82 of file WCSimDataCleaner.hh.

Referenced by FilterByPulseHeight(), WCSimDataCleaner(), and ~WCSimDataCleaner().

Double_t WCSimDataCleaner::fTimeWindow [private]

Definition at line 78 of file WCSimDataCleaner.hh.

Referenced by RecoClusters().

Definition at line 77 of file WCSimDataCleaner.hh.

Referenced by RecoClusters().

Definition at line 76 of file WCSimDataCleaner.hh.

Referenced by RecoClusters().


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