PreFilter Class Reference

#include <PreFilter.h>

Inheritance diagram for PreFilter:

List of all members.

Public Member Functions
	PreFilter ()
	~PreFilter ()
void	BeginJob ()
JobCResult	Ana (const MomNavigator *mom)
const Registry &	DefaultConfig () const
void	Config (const Registry &r)
Private Member Functions
float	LSFSlope (std::vector< CandDigitHandle * > &cluster)
float	LSFIntercept (std::vector< CandDigitHandle * > &cluster)
std::vector< std::vector< CandDigitHandle * > >	Cluster (std::vector< CandDigitHandle * > &digits)
std::vector< std::pair< int, int > >	ClusterMatch (std::vector< std::vector< CandDigitHandle * > > &Uclusters, std::vector< std::vector< CandDigitHandle * > > &Vclusters)
float	GetCDHTPos (CandDigitHandle *cdh)
float	GetCDHZPos (CandDigitHandle *cdh)
void	BeginSnarl ()
void	Diagnostic (std::vector< std::vector< CandDigitHandle * > > &Uclusters, std::vector< std::vector< CandDigitHandle * > > &Vclusters)
void	SimCheck (const MomNavigator *mom)
Private Attributes
Bool_t	cDiagnosticMode
Float_t	cSnrlChrgCut
Float_t	cUVdistcut
Float_t	cXYUVcut
Int_t	cMinNPlanes
std::string	cListIn
Int_t	fSnrlChrgDecD
Int_t	fContainDecD
Int_t	fNPlanesDecD
Int_t	fSnrlChrgDecT
Int_t	fContainDecT
Int_t	fNPlanesDecT
Int_t	fProblems
Float_t	cPEcut
Float_t	cDmxWtcut
Float_t	cClustDistcut
Float_t	cDigFitDcut
Int_t	fMinPln
Int_t	fMaxPln
Float_t	fSnrlZMin
Float_t	fSnrlZMax
Int_t	fRun
Int_t	fSubrun
Int_t	fSnrl
Int_t	fNRawDig
Int_t	fNCandDig
Int_t	fNPlanes
Int_t	fNTruPlanes
Int_t	fUdigSize
Int_t	fVdigSize
Int_t	fNUClusters
Int_t	fNVClusters
Int_t	fNOLClusters
Int_t	fTotUClustDig
Int_t	fTotVClustDig
Int_t	fNSnarls
Float_t	fSnrlChrg
Float_t	fUDigChrg
Float_t	fVDigChrg
Float_t	fTotUClustChrg
Float_t	fTotVClustChrg
Float_t	fTotTruE
Int_t	fUClustSize [50]
Int_t	fVClustSize [50]
Float_t	fUClustChrg [50]
Float_t	fVClustChrg [50]
Float_t	fUClustMinZ [50]
Float_t	fVClustMinZ [50]
Float_t	fUClustMaxZ [50]
Float_t	fVClustMaxZ [50]
Float_t	fUSlope [50]
Float_t	fUIntercept [50]
Float_t	fVSlope [50]
Float_t	fVIntercept [50]
Float_t	fP4Neu [4]
TFile *	outfile
TTree *	MyTree

---

Detailed Description

Definition at line 23 of file PreFilter.h.

---

Constructor & Destructor Documentation

PreFilter::PreFilter

(

)

Definition at line 42 of file PreFilter.cxx.

References Msg::kVerbose, and MSG.

00042                      :
00043     cDiagnosticMode(0),
00044     cSnrlChrgCut(-1.),
00045     cUVdistcut(-1.),
00046     cXYUVcut(-1.),
00047     cMinNPlanes(-1),
00048     cListIn("demuxdigitlist"),
00049 
00050     fSnrlChrgDecD(-1),
00051     fContainDecD(-1),
00052     fNPlanesDecD(-1),
00053     fSnrlChrgDecT(-1),
00054     fContainDecT(-1),
00055     fNPlanesDecT(-1),
00056     
00057     fProblems(-1),
00058     
00059     cPEcut(-1.),
00060     cDmxWtcut(-1.),
00061     cClustDistcut(-1.),
00062     cDigFitDcut(-1.),
00063     
00064     fMinPln(-1),
00065     fMaxPln(-1),
00066     fSnrlZMin(-1.),
00067     fSnrlZMax(-1.),
00068     fRun(-1),
00069     fSubrun(-1),
00070     fSnrl(-1),
00071     fNRawDig(-1),
00072     fNCandDig(-1),
00073     fNPlanes(-1),
00074     fNTruPlanes(-1),
00075     fUdigSize(-1),
00076     fVdigSize(-1),
00077     fNUClusters(0),
00078     fNVClusters(0),
00079     fNOLClusters(0),
00080     fTotUClustDig(0),
00081     fTotVClustDig(0),
00082     fNSnarls(0),
00083     
00084     fSnrlChrg(0.),
00085     fUDigChrg(0.),
00086     fVDigChrg(0.),
00087     fTotUClustChrg(0.),
00088     fTotVClustChrg(0.),
00089     fTotTruE(0.)
00090 {
00091     MSG("PreFilter",Msg::kVerbose) << "constructor" << std::endl;
00092 }
//.............................................................................

PreFilter::~PreFilter

(

)

Definition at line 94 of file PreFilter.cxx.

References cClustDistcut, cDiagnosticMode, cDigFitDcut, cDmxWtcut, cMinNPlanes, cPEcut, cSnrlChrgCut, cUVdistcut, cXYUVcut, MyTree, and outfile.

{
    // cut variables
    if(cDiagnosticMode){
      MyTree->Branch("cPEcut",&cPEcut,"cPEcut/F");
      MyTree->Branch("cDmxWtcut",&cDmxWtcut,"cDmxWtcut/F");  
      MyTree->Branch("cUVdistcut",&cUVdistcut,"cUVdistcut/F");  
      MyTree->Branch("cClustDistcut",&cClustDistcut,"cClustDistcut/F");  
      MyTree->Branch("cXYUVcut",&cXYUVcut,"cXYUVcut/F");
      MyTree->Branch("cDigFitDcut",&cDigFitDcut,"cDigFitDcut/F");  
      MyTree->Branch("cSnrlChrgCut",&cSnrlChrgCut,"cSnrlChrgCut/F");  
      MyTree->Branch("cMinNPlanes",&cMinNPlanes,"cMinNPlanes/I");  
      
      MyTree->Fill();
      outfile->cd();
      MyTree->Write();
      MyTree->Delete();
      outfile->Close();
    }
    delete MyTree;
    delete outfile;
}

---

Member Function Documentation

JobCResult PreFilter::Ana

(

const MomNavigator *

mom

)

[virtual]

Implement this for read only access to the MomNavigator

Reimplemented from JobCModule.

Definition at line 173 of file PreFilter.cxx.

References BeginSnarl(), cDiagnosticMode, cDigFitDcut, cDmxWtcut, cListIn, cMinNPlanes, cPEcut, cSnrlChrgCut, cUVdistcut, cXYUVcut, Diagnostic(), fContainDecD, find(), CandRecord::FindCandHandle(), RawRecord::FindRawBlock(), fMaxPln, fMinPln, fNCandDig, fNOLClusters, fNPlanes, fNPlanesDecD, fNRawDig, fNSnarls, fNUClusters, fNVClusters, fProblems, fRun, fSnrl, fSnrlChrg, fSnrlChrgDecD, fSnrlZMax, fSnrlZMin, fSubrun, fUDigChrg, fUdigSize, fUIntercept, fUSlope, fVDigChrg, fVdigSize, fVIntercept, fVSlope, GetCDHZPos(), CandHandle::GetDaughterIterator(), CandHandle::GetNDaughters(), RawDaqSnarlHeader::GetNumRawDigits(), PlexPlaneId::GetPlane(), UgliGeomHandle::GetPlaneIdFromZ(), RawRecord::GetRawHeader(), RawDaqHeaderBlock::GetRun(), RawDaqSnarlHeader::GetSnarl(), RawDaqHeaderBlock::GetSubRun(), UgliStripHandle::GetTPos(), RecMinosHdr::GetVldContext(), UgliGeomHandle::GetZExtent(), Msg::kError, JobCResult::kFailed, CalDigitType::kPE, PlaneView::kU, PlaneView::kV, Msg::kWarning, LSFIntercept(), MSG, MyTree, Munits::second, JobCResult::SetAOK(), JobCResult::SetPassed(), JobCResult::SetWarning(), and SimCheck().

{
    JobCResult result(JobCResult::kFailed);
    result.SetWarning();

    if(cDiagnosticMode) fNSnarls++;
  
    this->BeginSnarl();
  
    if(cDiagnosticMode) this->SimCheck(mom);
    
    std::vector<CandDigitHandle*> uDigits;
    std::vector<CandDigitHandle*> vDigits;
    
    const RawRecord *rawrec = dynamic_cast<const RawRecord*>
      (mom->GetFragment("RawRecord"));
    
    if(!rawrec){
      MSG("PreFilter",Msg::kError) << "No rawrecord in mom!\n";
      return result;
      //return JobCResult::kError;
    }
    
    // part to get minimum and maximum planes for run...///////////////////
    VldContext snrlvld = rawrec->GetRawHeader()->GetVldContext();
    UgliGeomHandle snrlugh(snrlvld);
    snrlugh.GetZExtent(fSnrlZMin,fSnrlZMax,-1);
    fMinPln = snrlugh.GetPlaneIdFromZ(fSnrlZMin).GetPlane();
    fMaxPln = snrlugh.GetPlaneIdFromZ(fSnrlZMax).GetPlane();
    
    if(cDiagnosticMode){
      const RawDaqSnarlHeader* rdsh = dynamic_cast<const RawDaqSnarlHeader*>
        (rawrec->GetRawHeader());
      
      if(rdsh){
        fSnrl = rdsh->GetSnarl();
        fNRawDig = rdsh->GetNumRawDigits();
      }
      const RawDaqHeaderBlock* rdhb = dynamic_cast<const RawDaqHeaderBlock*>
        (rawrec->FindRawBlock("RawDaqHeaderBlock"));
      
      if(rdhb){
        fRun = rdhb->GetRun();
        fSubrun = rdhb->GetSubRun();
      }
    }

    CandRecord *candrec = dynamic_cast<CandRecord *>
      (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
    
    if(!candrec){
        MSG("PreFilter",Msg::kError) << "No candrecord in mom" << std::endl;
        return result;
        //return JobCResult::kError;
    }
    
    const CandDigitListHandle *cdlh = dynamic_cast<CandDigitListHandle*>
      (candrec->FindCandHandle("CandDeMuxDigitListHandle",cListIn.c_str()));
    
    if(!cdlh){
      MSG("PreFilter",Msg::kError) << "CandDigitListHandle Empty" << std::endl;
      return result;
      //return JobCResult::kError;
    }

    if(cDiagnosticMode){
      fNCandDig = cdlh->GetNDaughters();
    }

    CandDigitHandleItr cdhiter(cdlh->GetDaughterIterator());
    std::vector<int> tmpplanes;
    // loop to sum charge in snarl and count planes
    for(;cdhiter.IsValid();cdhiter.Next()){
      const PlexSEIdAltL &pseidalt = dynamic_cast<const PlexSEIdAltL&>
        ((*cdhiter)->GetPlexSEIdAltL());
      
      if(!pseidalt.IsVetoShield()){
        fSnrlChrg += (*cdhiter)->GetCharge(CalDigitType::kPE);
        
        if(tmpplanes.size()==0){
          tmpplanes.push_back(pseidalt.GetPlane());
        }
        else{
          int pln = pseidalt.GetPlane();
          std::vector<int>::iterator plnisfound = 
            std::find(tmpplanes.begin(),tmpplanes.end(),pln);
          if(plnisfound==tmpplanes.end()) tmpplanes.push_back(pln);
        }
      }
    }
    if(fSnrlChrg<cSnrlChrgCut){
      if(cDiagnosticMode){
          MSG("PreFilter",Msg::kError) << "Snarl Charge too low, non-signal"
          << " event" << std::endl;
        fSnrlChrgDecD = 0;
        MyTree->Fill();
      }
      else{
          MSG("PreFilter",Msg::kError) << "Snarl Charge too low, non-signal"
          << " event" << std::endl;
          return result;
          //return JobCResult::kError;
      }
    }
    else{
      if(cDiagnosticMode){
        fSnrlChrgDecD = 1;
      }
    }

    fNPlanes = tmpplanes.size();
    if(fNPlanes<cMinNPlanes){
      if(cDiagnosticMode){
        MSG("PreFilter",Msg::kWarning) << "Not enough planes" << std::endl;
        fNPlanesDecD = 0;
        MyTree->Fill();
      }
      else{
        MSG("PreFilter",Msg::kWarning) << "Not enough planes" << std::endl;
        return result;
        //return JobCResult::kError;
      }
    }
    else{
      if(cDiagnosticMode){
        fNPlanesDecD = 1;
      }
    }
    cdhiter.Reset();
    int nbaddmx = 0;
    for(;cdhiter.IsValid();cdhiter.Next()){
      // check to see if digit is greater than 3pe and kludge for now with
      // DeMux veto flag.
      // check to see if digit is contained in UV and demuxed well
      const PlexSEIdAltL &pseidalt = dynamic_cast<const PlexSEIdAltL&>
        ((*cdhiter)->GetPlexSEIdAltL());
      if(!pseidalt.IsVetoShield()){
        // check demux flag for IU demuxer?
        if(pseidalt.GetDemuxVetoFlag()==0){
          if((*cdhiter)->GetCharge(CalDigitType::kPE) > cPEcut){
            // check to see if digit is in first or last planes
            if(pseidalt.GetPlane()<=(fMinPln+2) ||
               pseidalt.GetPlane()>=(fMaxPln-2)){
              if(cDiagnosticMode){
                MSG("PreFilter",Msg::kError) << "Event at end of detector" <<
                std::endl;
                fContainDecD = 0;
                MyTree->Fill();
              }
              else{
               MSG("PreFilter",Msg::kError) << "Event at end of detector" <<
               std::endl;
               return result;
              }
            }
            if(pseidalt.GetBestWeight()>cDmxWtcut){
              //pseidalt.GetDemuxVetoFlag()==0){
              UgliGeomHandle ugh(*(*cdhiter)->GetVldContext());
              UgliStripHandle ush = ugh.GetStripHandle(pseidalt.GetBestSEId());
              
              if( (ush.GetTPos()*ush.GetTPos()) > cUVdistcut*cUVdistcut){
                if(cDiagnosticMode){
                  MSG("PreFilter",Msg::kError) << "UV containment not met." 
                  << std::endl;
                  fContainDecD = 0;
                  MyTree->Fill();
                }
                else{
                  MSG("PreFilter",Msg::kError) << "UV containment not met." 
                  << std::endl;
                  return result;
                }
              }
              // if get to this point, charge and UV containment met. need to 
              // put digit in vector for later use.
              switch(pseidalt.GetPlaneView(true)){
              case PlaneView::kU:
                fUDigChrg += (*cdhiter)->GetCharge(CalDigitType::kPE);
                uDigits.push_back((*cdhiter));
                break;
                
              case PlaneView::kV:
                fVDigChrg += (*cdhiter)->GetCharge(CalDigitType::kPE);
                vDigits.push_back((*cdhiter));
                break;
                
              default:
                MSG("PreFilter",Msg::kWarning) << "SEIdAltL not U or V.";
                MSG("PreFilter",Msg::kWarning) << std::endl;
              }
            }
          }
        }
        else{
            nbaddmx++;
            if( ((float)nbaddmx)/((float)fNRawDig) > 0.3){
              if(cDiagnosticMode){
                MSG("PreFilter",Msg::kError) << "TOO MANY DEMUX PROBLEMS"
                << std::endl;
                fProblems = 1;
                MyTree->Fill();
            }
            else{
              MSG("PreFilter",Msg::kError) << "TOO MANY DEMUX PROBLEMS"
              << std::endl;
              return result;
            }
          }
        }
       }
      }
    
    fUdigSize = uDigits.size();
    fVdigSize = vDigits.size();
    
    if(fUdigSize<=1 || fVdigSize<=1){
      if(cDiagnosticMode){
        MSG("PreFilter",Msg::kError) << "Not enough digits for clustering" <<
        std::endl;
        fProblems = 2;
        MyTree->Fill();
        return result;
      }
      else{
        MSG("PreFilter",Msg::kError) << "Not enough digits for clustering" <<
        std::endl;
        return result;
      }
    }
    
    std::vector<std::vector<CandDigitHandle*> >
      Vclusters(this->Cluster(vDigits));
    std::vector<std::vector<CandDigitHandle*> >
      Uclusters(this->Cluster(uDigits));
    
    fNUClusters = Uclusters.size();
    fNVClusters = Vclusters.size();
    
    if(fNUClusters==0 || fNVClusters==0){
      if(cDiagnosticMode){
        MSG("PreFilter",Msg::kError) << "Clustering failed" << std::endl;
        fProblems = 3;
        MyTree->Fill();
      }
      else{
       MSG("PreFilter",Msg::kError) << "Clustering failed" << std::endl;
       return result;
      }
    }
    
    for(unsigned int i=0;i<Vclusters.size();i++){
      fVSlope[i] = this->LSFSlope(Vclusters[i]);
      fVIntercept[i] = this->LSFIntercept(Vclusters[i]);
    }
    for(unsigned int i=0;i<Uclusters.size();i++){
      fUSlope[i] = this->LSFSlope(Uclusters[i]);
      fUIntercept[i] = this->LSFIntercept(Uclusters[i]);
    }
    
    std::vector<std::pair<int,int> >OLclusters(this->ClusterMatch(Uclusters,
                                                                  Vclusters));
    fNOLClusters = OLclusters.size();
    
    if(cDiagnosticMode) this->Diagnostic(Uclusters,Vclusters);
    
    for(unsigned int i=0;i<OLclusters.size();i++){
      std::vector<CandDigitHandle*> Ucluster(Uclusters[OLclusters[i].first]);
      std::vector<CandDigitHandle*> Vcluster(Vclusters[OLclusters[i].second]);
      
      // containment check. loop over U and V clusters and check XY containment
      // with other view's fit.
      
      for(std::vector<CandDigitHandle*>::iterator Vclustiter =
            Vcluster.begin(); Vclustiter!=Vcluster.end(); Vclustiter++){
        
        float vpos = this->GetCDHTPos((*Vclustiter));
        float zpos = this->GetCDHZPos((*Vclustiter));
        
        // check to see whether this particular digit is close to the
        // fit in its view. if not, don't bother checking containment with it.
        if( fabs(vpos - (fVSlope[OLclusters[i].second]*zpos + 
                         fVIntercept[OLclusters[i].second])) < cDigFitDcut){
          
          float upos = fUSlope[OLclusters[i].first]*zpos + 
            fUIntercept[OLclusters[i].first];
          float xpos = 0.707107*(upos-vpos);
          float ypos = 0.707107*(upos+vpos);
          
          if( ((upos*upos) > (cXYUVcut*cXYUVcut)) || 
              ((vpos*vpos) > (cXYUVcut*cXYUVcut)) ||
              ((xpos*xpos) > (cXYUVcut*cXYUVcut)) ||
              ((ypos*ypos) > (cXYUVcut*cXYUVcut)) ) {
            if(cDiagnosticMode){
              MSG("PreFilter",Msg::kError)<<"Containment failed" << std::endl;
              fContainDecD = 0;
              MyTree->Fill();
            }
            else{
             MSG("PreFilter",Msg::kError)<<"Containment failed" << std::endl;
             return result;
            }
          }
        }
      }
      for(std::vector<CandDigitHandle*>::iterator Uclustiter = 
            Ucluster.begin(); Uclustiter!=Ucluster.end(); Uclustiter++){
        
        float upos = this->GetCDHTPos((*Uclustiter));
        float zpos = this->GetCDHZPos((*Uclustiter));
        
        if( fabs(upos - (fUSlope[OLclusters[i].first]*zpos +
                         fUIntercept[OLclusters[i].first])) < cDigFitDcut){
          
          float vpos = fVSlope[OLclusters[i].second]*zpos + 
            fVIntercept[OLclusters[i].second];
          float xpos = 0.707107*(upos-vpos);
          float ypos = 0.707107*(upos+vpos);
          
          if( ((upos*upos) > (cXYUVcut*cXYUVcut)) ||
              ((vpos*vpos) > (cXYUVcut*cXYUVcut)) ||
              ((xpos*xpos) > (cXYUVcut*cXYUVcut)) ||
              ((ypos*ypos) > (cXYUVcut*cXYUVcut)) ) {
            if(cDiagnosticMode){
              MSG("PreFilter",Msg::kError)<<"Containment failed" << std::endl;
              fContainDecD = 0;
              MyTree->Fill();
            }
            else{
             MSG("PreFilter",Msg::kError)<<"Containment failed" << std::endl;
             return result;
            }
          }
        }
      }
    }
    
    //fProblems = 0;
    if(cDiagnosticMode){
        if(fContainDecD==-1) fContainDecD = 1;
        MyTree->Fill();
    }
    result.SetAOK().SetPassed();
    return result;
}

void PreFilter::BeginJob

(

)

[virtual]

Implement for notification of begin of job

Reimplemented from JobCModule.

Definition at line 117 of file PreFilter.cxx.

References cDiagnosticMode, fContainDecD, fContainDecT, fMaxPln, fMinPln, fNCandDig, fNOLClusters, fNPlanes, fNPlanesDecD, fNPlanesDecT, fNRawDig, fNSnarls, fNTruPlanes, fNUClusters, fNVClusters, fP4Neu, fProblems, fRun, fSnrl, fSnrlChrg, fSnrlChrgDecD, fSnrlChrgDecT, fSubrun, fTotTruE, fTotUClustChrg, fTotUClustDig, fTotVClustChrg, fTotVClustDig, fUClustChrg, fUClustMaxZ, fUClustMinZ, fUClustSize, fUDigChrg, fUdigSize, fUIntercept, fUSlope, fVClustChrg, fVClustMaxZ, fVClustMinZ, fVClustSize, fVDigChrg, fVdigSize, fVIntercept, fVSlope, Msg::kVerbose, MSG, MyTree, and outfile.

                        {

    MSG("PreFilter",Msg::kVerbose) << "BeginJob" << std::endl;
  
    if(cDiagnosticMode){
      outfile = new TFile("outfile","RECREATE");
      MyTree = new TTree("MyTree","MyTree");
      
      MyTree->Branch("fSnrlChrgDecD",&fSnrlChrgDecD,"fSnrlChrgDecD/I");
      MyTree->Branch("fContainDecD",&fContainDecD,"fContainDecD/I");
      MyTree->Branch("fNPlanesDecD",&fNPlanesDecD,"fNPlanesDecD/I");
      MyTree->Branch("fSnrlChrgDecT",&fSnrlChrgDecT,"fSnrlChrgDecT/I");
      MyTree->Branch("fContainDecT",&fContainDecT,"fContainDecT/I");
      MyTree->Branch("fNPlanesDecT",&fNPlanesDecT,"fNPlanesDecT/I");
      
      MyTree->Branch("fProblems",&fProblems,"fProblems/I");
      
      MyTree->Branch("fMinPln",&fMinPln,"fMinPln/I");
      MyTree->Branch("fMaxPln",&fMaxPln,"fMaxPln/I");
      MyTree->Branch("fRun",&fRun,"fRun/I");
      MyTree->Branch("fSubrun",&fSubrun,"fSubrun/I");
      MyTree->Branch("fSnrl",&fSnrl,"fSnrl/I");
      MyTree->Branch("fNRawDig",&fNRawDig,"fNRawDig/I");
      MyTree->Branch("fNCandDig",&fNCandDig,"fNCandDig/I");
      MyTree->Branch("fNPlanes",&fNPlanes,"fNPlanes/I");
      MyTree->Branch("fNTruPlanes",&fNTruPlanes,"fNTruPlanes/I");
      MyTree->Branch("fUdigSize",&fUdigSize,"fUdigSize/I");
      MyTree->Branch("fVdigSize",&fVdigSize,"fVdigSize/I");
      MyTree->Branch("fNUClusters",&fNUClusters,"fNUClusters/I");
      MyTree->Branch("fNVClusters",&fNVClusters,"fNVClusters/I");
      MyTree->Branch("fNOLClusters",&fNOLClusters,"fNOLClusters/I");
      MyTree->Branch("fTotUClustDig",&fTotUClustDig,"fTotUClustDig/I");  
      MyTree->Branch("fTotVClustDig",&fTotVClustDig,"fTotVClustDig/I");  
      MyTree->Branch("fNSnarls",&fNSnarls,"fNSnarls/I");
      MyTree->Branch("fSnrlChrg",&fSnrlChrg,"fSnrlChrg/F");  
      MyTree->Branch("fUDigChrg",&fUDigChrg,"fUDigChrg/F");  
      MyTree->Branch("fVDigChrg",&fVDigChrg,"fVDigChrg/F");  
      MyTree->Branch("fTotUClustChrg",&fTotUClustChrg,"fTotUClustChrg/F");  
      MyTree->Branch("fTotVClustChrg",&fTotVClustChrg,"fTotVClustChrg/F");
      MyTree->Branch("fTotTruE",&fTotTruE,"fTotTruE/F");
      MyTree->Branch("fUClustSize",fUClustSize,"fUClustSize[fNUClusters]/I");
      MyTree->Branch("fVClustSize",fVClustSize,"fVClustSize[fNVClusters]/I");
      MyTree->Branch("fUClustChrg",fUClustChrg,"fUClustChrg[fNUClusters]/F");
      MyTree->Branch("fVClustChrg",fVClustChrg,"fVClustChrg[fNVClusters]/F");
      MyTree->Branch("fUClustMinZ",fUClustMinZ,"fUClustMinZ[fNUClusters]/F");
      MyTree->Branch("fVClustMinZ",fVClustMinZ,"fVClustMinZ[fNVClusters]/F");
      MyTree->Branch("fUClustMaxZ",fUClustMaxZ,"fUClustMaxZ[fNUClusters]/F");
      MyTree->Branch("fVClustMaxZ",fVClustMaxZ,"fVClustMaxZ[fNVClusters]/F");
      MyTree->Branch("fUSlope",fUSlope,"fUSlope[fNUClusters]/F");
      MyTree->Branch("fUIntercept",fUIntercept,"fUIntercept[fNUClusters]/F");
      MyTree->Branch("fVSlope",fVSlope,"fVSlope[fNVClusters]/F");
      MyTree->Branch("fVIntercept",fVIntercept,"fVIntercept[fNVClusters]/F");
      MyTree->Branch("fP4Neu",fP4Neu,"fP4Neu[4]/F");
    }
}

void PreFilter::BeginSnarl

(

)

[private]

Definition at line 807 of file PreFilter.cxx.

References cDiagnosticMode, fContainDecD, fContainDecT, fNOLClusters, fNPlanes, fNPlanesDecD, fNPlanesDecT, fNRawDig, fNTruPlanes, fNUClusters, fNVClusters, fP4Neu, fProblems, fRun, fSnrl, fSnrlChrg, fSnrlChrgDecD, fSnrlChrgDecT, fSubrun, fTotTruE, fTotUClustChrg, fTotUClustDig, fTotVClustChrg, fTotVClustDig, fUClustChrg, fUClustMaxZ, fUClustMinZ, fUClustSize, fUDigChrg, fUdigSize, fUIntercept, fUSlope, fVClustChrg, fVClustMaxZ, fVClustMinZ, fVClustSize, fVDigChrg, fVdigSize, fVIntercept, and fVSlope.

Referenced by Ana().

                          {
    for(int i=0;i<50;i++){
        fUClustSize[i] = 0;
        fVClustSize[i] = 0;
        fUClustChrg[i] = 0.;
        fVClustChrg[i] = 0.;
        fUClustMinZ[i] = 100.;
        fVClustMinZ[i] = 100.;
        fUClustMaxZ[i] = -1.;
        fVClustMaxZ[i] = -1.;
        fUSlope[i] = 0.;
        fUIntercept[i] = 0.;
        fVSlope[i] = 0.;
        fVIntercept[i] = 0.;
    }

    if(cDiagnosticMode){
      fSnrlChrgDecD = -1;
      fContainDecD = -1;
      fNPlanesDecD = -1;
      fSnrlChrgDecT = -1;
      fContainDecT = -1;
      fNPlanesDecT = -1;
      fProblems = 0;
      
      fRun = -1;
      fSubrun = -1;
      fSnrl = -1;
      fNRawDig = -1;
      fNPlanes = -1;
      fNTruPlanes = 0;
      fUdigSize = -1;
      fVdigSize = -1;
      fNUClusters = 0;
      fNVClusters = 0;
      fNOLClusters = -1;
      fTotUClustDig = 0;
      fTotVClustDig = 0;
      fSnrlChrg = 0.;
      fUDigChrg = 0.;
      fVDigChrg = 0.;
      fTotUClustChrg = 0.;
      fTotVClustChrg = 0.;
      fTotTruE = 0.;

      for(int i=0;i<4;i++){
        fP4Neu[i] = 0.;
      }
    }    
}

std::vector< std::vector< CandDigitHandle * > > PreFilter::Cluster

(

std::vector< CandDigitHandle * > &

digits

)

[private]

Definition at line 634 of file PreFilter.cxx.

References cClustDistcut, and GetCDHZPos().

                                                     {

    int ndigits = digits.size();
    
    // initialize dst matrix
    std::vector<std::vector<float> > dst (ndigits);
    for(int i=0;i<ndigits;i++){
      dst[i] = std::vector<float>(ndigits);
    }
    // initialize group array. this holds the group assignment for each digit.
    // -2 => digit hasn't been assigned group yet. -1 => digit didn't fit into 
    // any group 
    std::vector<int> group(ndigits,-2);
    // initialize map of group number/size of group
    std::map<int,int> groupsize;
    
    // fill dst matrix  
    for(int i=0;i<ndigits;i++){
      
      float itpos = this->GetCDHTPos(digits[i]);
      float izpos = this->GetCDHZPos(digits[i]);
      
      for(int j=0;j<ndigits;j++){
        
        float jtpos = this->GetCDHTPos(digits[j]);
        float jzpos = this->GetCDHZPos(digits[j]);
        
        dst[i][j] = sqrt((itpos-jtpos)*(itpos-jtpos) + 
                         (izpos-jzpos)*(izpos-jzpos) );
      }
    }
    
    int igroup = 0;
    int i0 = 0;
    int j0 = 0;
    int nleft = ndigits-1;
    group[0]=igroup;
    
    while(nleft>0){
      //MSG("PreFilter",Msg::kWarning) << "in clustering while loop" << std::endl;
      int nlk = 0;
      float dmin;
      do{
        dmin = cClustDistcut+1.;
        for(int i=0;i<ndigits;i++){
          for(int j=0;j<ndigits;j++){
            if(group[i]==igroup && group[j]==-2 && dst[i][j]>0. && 
               dst[i][j]<dmin) {
              dmin = dst[i][j];
              i0 = i;
              j0 = j;
            }
          }
        }
        if(dmin<cClustDistcut){
          group[j0] = igroup;
          nlk++;
        }
      }while(dmin<cClustDistcut);
      
      if(nlk==0) group[i0] = -1;
      
      if(nlk>0){
        groupsize[igroup] = nlk+1;
        igroup++;
      }
      
      // calculate nleft
      nleft = 0;
      for(unsigned int i=0;i<group.size();i++){
        if(group[i]==-2) nleft++;
      }
      if(nleft>0){
        int i=0;
        while(group[i]!=-2) i++;
        i0 = i;
        group[i0] = igroup;
      }
    }
    
    std::vector<std::vector<CandDigitHandle*> >retclusters(groupsize.size());
    
    for(std::map<int,int>::iterator gsiter = groupsize.begin();
        gsiter!=groupsize.end();gsiter++){
      
      for(unsigned int i=0;i<group.size();i++){
        if((gsiter->first)==group[i]) 
          retclusters[gsiter->first].push_back(digits[i]);
      }
    }
    return retclusters;
}

std::vector< std::pair< int, int > > PreFilter::ClusterMatch	(	std::vector< std::vector< CandDigitHandle * > > &	Uclusters,
		std::vector< std::vector< CandDigitHandle * > > &	Vclusters
	)			[private]

Definition at line 728 of file PreFilter.cxx.

{
  // want to find the clusters that overlap in z to make meaningful containment
  // estimate. this method returns a vector holding pairs of ints. the first
  // int in each pair represents a particular U cluster, and the second int in
  // the pair represents a cluster in V that overlaps with that U cluster.

    std::vector<std::pair<float,float> >Uzminmax(Uclusters.size());
    std::vector<std::pair<float,float> >Vzminmax(Vclusters.size());
    
    for(unsigned int i=0;i<Uclusters.size();i++){
      float zmin = 35.;
      float zmax = 0.;
      
      for(unsigned int j=0;j<Uclusters[i].size();j++){
        float z = this->GetCDHZPos(Uclusters[i][j]);
        
        //MSG("PreFilter",Msg::kWarning) << "U digit z is " << z << std::endl;
        
        if(z<zmin) zmin = z;
        if(z>zmax) zmax = z;
      }
      Uzminmax[i] = std::make_pair(zmin,zmax);
    }
    
    for(unsigned int i=0;i<Vclusters.size();i++){
      float zmin = 35.;
      float zmax = 0.;
      
      for(unsigned int j=0;j<Vclusters[i].size();j++){
        float z = this->GetCDHZPos(Vclusters[i][j]);
        
        //MSG("PreFilter",Msg::kWarning) << "V digit z is " << z << std::endl;
        
        if(z<zmin) zmin = z;
        if(z>zmax) zmax = z;
      }
      Vzminmax[i] = std::make_pair(zmin,zmax);
    }
    
    std::vector<std::pair<int,int> >OLclusters;
    
    for(unsigned int i=0;i<Uzminmax.size();i++){
      float uzmin = Uzminmax[i].first;
      float uzmax = Uzminmax[i].second;
      
      for(unsigned int j=0;j<Vzminmax.size();j++){
        float vzmin = Vzminmax[j].first;
        float vzmax = Vzminmax[j].second;
        
        if( ((uzmin > vzmin) && (uzmin < vzmax)) || 
          ((uzmax > vzmin) && (uzmax < vzmax)) )
          OLclusters.push_back(std::make_pair(i,j));
      }
    }
    return OLclusters;
}

void PreFilter::Config

(

const Registry &

r

)

[virtual]

Return the actual configuration. If your module directly pulls its configuration from the fConfig Registry, you don't need to override this. Override if you have local config variables.

Reimplemented from JobCModule.

Definition at line 543 of file PreFilter.cxx.

References cClustDistcut, cDiagnosticMode, cDigFitDcut, cDmxWtcut, cListIn, cMinNPlanes, cPEcut, cSnrlChrgCut, cUVdistcut, cXYUVcut, Registry::Get(), Msg::kVerbose, and MSG.

                                        {

  MSG("PreFilter",Msg::kVerbose) << "We're in Config now." << std::endl;

    double tmpd;

    if(r.Get("PEcut",tmpd)) {cPEcut = tmpd;}
    if(r.Get("DmxWtcut",tmpd)) {cDmxWtcut = tmpd;}
    if(r.Get("UVdistcut",tmpd)) {cUVdistcut = tmpd;}
    if(r.Get("ClustDistcut",tmpd)) {cClustDistcut = tmpd;}
    if(r.Get("XYUVcut",tmpd)) {cXYUVcut = tmpd;}
    if(r.Get("DigFitDcut",tmpd)) {cDigFitDcut = tmpd;}
    if(r.Get("SnrlChrgCut",tmpd)) {cSnrlChrgCut = tmpd;}
    
    int tmpi;
    if(r.Get("MinNPlanes",tmpi)) {cMinNPlanes = tmpi;}
    if(r.Get("DiagnosticMode",tmpi)) {cDiagnosticMode = (bool)tmpi;}

    const char *tmps;
    if (r.Get("NameListIn",tmps)) { cListIn = tmps; }
}

const Registry & PreFilter::DefaultConfig

(

)

const [virtual]

Get the default configuration registry. This should normally be overridden. One useful idiom is to implement it like:

const Registry& MyModule::DefaultConfig() const { static Registry cfg; // never is destroyed if (cfg.Size()) return cfg; // already filled it // set defaults: cfg.Set("TheAnswer",42); cfg.Set("Units","unknown"); return cfg; }

Reimplemented from JobCModule.

Definition at line 519 of file PreFilter.cxx.

References JobCModule::GetName(), Registry::LockValues(), Registry::Set(), and Registry::UnLockValues().

                                               { 
    static Registry r;
  
    std::string name = this->JobCModule::GetName();
    name += ".config.default";
    r.SetName(name.c_str());
    r.UnLockValues();
    
    // Set values in configuration
    r.Set("PEcut",3.0);
    r.Set("DmxWtcut",0.4);
    r.Set("UVdistcut",3.75);
    r.Set("ClustDistcut",0.60);
    r.Set("XYUVcut",3.75);
    r.Set("DigFitDcut",1.0);
    r.Set("SnrlChrgCut",50.);
    r.Set("MinNPlanes",6);
    r.Set("NameListIn","demuxdigitlist");
    r.Set("DiagnosticMode",0);
    r.LockValues();
    
    return r;
}

void PreFilter::Diagnostic	(	std::vector< std::vector< CandDigitHandle * > > &	Uclusters,
		std::vector< std::vector< CandDigitHandle * > > &	Vclusters
	)			[private]

Definition at line 860 of file PreFilter.cxx.

References fTotUClustChrg, fTotUClustDig, fTotVClustChrg, fTotVClustDig, fUClustChrg, fUClustMaxZ, fUClustMinZ, fUClustSize, fVClustChrg, fVClustMaxZ, fVClustMinZ, fVClustSize, GetCDHZPos(), and CalDigitType::kPE.

Referenced by Ana().

                                      {
  
    // fill clustsize, clustchrg, clustminZ, clustmaxZ
    for(unsigned int i=0;i<Uclusters.size();i++){
      fUClustSize[i] = Uclusters[i].size();
      fTotUClustDig += Uclusters[i].size();
      
      for(std::vector<CandDigitHandle*>::iterator 
            uclustiter=Uclusters[i].begin();uclustiter!=Uclusters[i].end();
          uclustiter++){
        
        fUClustChrg[i] += (*uclustiter)->GetCharge(CalDigitType::kPE);
        
        float z = this->GetCDHZPos((*uclustiter));
        if(z>fUClustMaxZ[i]) fUClustMaxZ[i] = z;
        if(z<fUClustMinZ[i]) fUClustMinZ[i] = z;
      }
      fTotUClustChrg += fUClustChrg[i];
    }
    for(unsigned int i=0;i<Vclusters.size();i++){
      fVClustSize[i] = Vclusters[i].size();
      fTotVClustDig += Vclusters[i].size();
      
      for(std::vector<CandDigitHandle*>::iterator 
            vclustiter=Vclusters[i].begin();vclustiter!=Vclusters[i].end();
          vclustiter++){
        
        fVClustChrg[i] += (*vclustiter)->GetCharge(CalDigitType::kPE);
        
        float z = this->GetCDHZPos((*vclustiter));
        if(z>fVClustMaxZ[i]) fVClustMaxZ[i] = z;
        if(z<fVClustMinZ[i]) fVClustMinZ[i] = z;
      }
      fTotVClustChrg += fVClustChrg[i];
    }
}

float PreFilter::GetCDHTPos

(

CandDigitHandle *

cdh

)

[private]

Definition at line 787 of file PreFilter.cxx.

References PlexSEIdAltL::GetBestSEId(), CandDigitHandle::GetPlexSEIdAltL(), UgliStripHandle::GetTPos(), and CandHandle::GetVldContext().

                                                {
    const PlexSEIdAltL &pseidalt = dynamic_cast<const PlexSEIdAltL&>
      (cdh->GetPlexSEIdAltL());
    const VldContext *vld = dynamic_cast<const VldContext*> 
      (cdh->GetVldContext());
    UgliGeomHandle ugh(*vld);
    UgliStripHandle ush = ugh.GetStripHandle(pseidalt.GetBestSEId());
    return (ush.GetTPos());
}

float PreFilter::GetCDHZPos

(

CandDigitHandle *

cdh

)

[private]

Definition at line 797 of file PreFilter.cxx.

References PlexSEIdAltL::GetBestSEId(), CandDigitHandle::GetPlexSEIdAltL(), CandHandle::GetVldContext(), and UgliStripHandle::GlobalPos().

Referenced by Ana(), Cluster(), Diagnostic(), LSFIntercept(), and LSFSlope().

                                               {
    const PlexSEIdAltL &pseidalt = dynamic_cast<const PlexSEIdAltL&>
      (cdh->GetPlexSEIdAltL());
    const VldContext *vld = dynamic_cast<const VldContext*> 
      (cdh->GetVldContext());
    UgliGeomHandle ugh(*vld);
    UgliStripHandle ush = ugh.GetStripHandle(pseidalt.GetBestSEId());
    return (ush.GlobalPos(0).Z());
}

float PreFilter::LSFIntercept

(

std::vector< CandDigitHandle * > &

cluster

)

[private]

Definition at line 599 of file PreFilter.cxx.

References GetCDHZPos().

Referenced by Ana().

                                                                 {

    int size = cluster.size();

    std::vector<float> zpos(size,0.);
    std::vector<float> tpos(size,0.);
    
    for(int i=0;i<size;i++){
      tpos[i] = this->GetCDHTPos(cluster[i]);
      zpos[i] = this->GetCDHZPos(cluster[i]);
    }
    
    float x = 0.;
    float xsqr = 0.;
    float y = 0.;
    float xy = 0.;
    
    for(int i=0;i<size;i++){
      x+=zpos[i];
      xsqr+=zpos[i]*zpos[i];
      y+=tpos[i];
      xy+=zpos[i]*tpos[i];
    }
    
    float numerator = (xsqr*y - x*xy);
    float denominator = (size*xsqr - x*x);
    
    if(denominator!=0.){
      float intercept = numerator/denominator;
      return intercept;
    }
    else return 0.;
}

float PreFilter::LSFSlope

(

std::vector< CandDigitHandle * > &

cluster

)

[private]

Definition at line 565 of file PreFilter.cxx.

References GetCDHZPos().

                                                             {
  
    int size = cluster.size();
    
    std::vector<float> zpos(size,0.);
    std::vector<float> tpos(size,0.);
    
    for(int i=0;i<size;i++){
      tpos[i] = this->GetCDHTPos(cluster[i]);
      zpos[i] = this->GetCDHZPos(cluster[i]);
    }
    
    float x = 0.;
    float xsqr = 0.;
    float y = 0.;
    float xy = 0.;
    
    for(int i=0;i<size;i++){
      x+=zpos[i];
      xsqr+=zpos[i]*zpos[i];
      y+=tpos[i];
      xy+=zpos[i]*tpos[i];
    }
    
    float numerator = (x*y - size*xy);
    float denominator = (x*x - size*xsqr);
    
    if(denominator!=0.){
      float slope = numerator/denominator;
      return slope;
    }
    else return 0.;
}

void PreFilter::SimCheck

(

const MomNavigator *

mom

)

[private]

Definition at line 900 of file PreFilter.cxx.

References cMinNPlanes, cSnrlChrgCut, cUVdistcut, fContainDecT, RecDataRecord< T >::FindComponent(), fNPlanesDecT, fNTruPlanes, fP4Neu, fSnrlChrgDecT, fSnrlZMax, fSnrlZMin, fTotTruE, RecDataRecord< T >::GetComponents(), MomNavigator::GetFragment(), RawRecord::GetRawHeader(), UgliGeomHandle::GetStripHandle(), Ugli::kUseGlobal, UgliStripHandle::LocalToGlobal(), REROOT_NeuKin::P4Neu(), Munits::second, DigiScintHit::StripEndId(), DigiScintHit::X1(), DigiScintHit::Y1(), and DigiScintHit::Z1().

Referenced by Ana().

{
    const RawRecord *rawrec = dynamic_cast<const RawRecord*>
      (mom->GetFragment("RawRecord"));
    const RawDaqSnarlHeader* rdsh = dynamic_cast<const RawDaqSnarlHeader*>
      (rawrec->GetRawHeader());
    const VldContext &vld = rdsh->GetVldContext();
    
    const SimSnarlRecord* simrec = dynamic_cast<const SimSnarlRecord*>
      (mom->GetFragment("SimSnarlRecord"));
    
    if(simrec){
      // true kinematic info
      REROOT_NeuKin* neukin = NULL;
      int ctor = 0;
      TObjArray objarr = simrec->GetComponents();
      
      for(int i = 0;i <= objarr.GetLast();i++){
        neukin = dynamic_cast<REROOT_NeuKin*>(objarr.At(i));
        if(neukin){
          ctor = i;
        }
      }
      neukin = dynamic_cast<REROOT_NeuKin*>(objarr.At(ctor));
      
      const Float_t *tmp = neukin->P4Neu();
      fP4Neu[0] = tmp[0];
      fP4Neu[1] = tmp[1];
      fP4Neu[2] = tmp[2];
      fP4Neu[3] = tmp[3];
      
      // containment stuff
      const TClonesArray *digiscinthits = dynamic_cast<const TClonesArray*>
        (simrec->FindComponent("TClonesArray","DigiScintHits"));
      
      std::multimap<int,DigiScintHit*> plnhits;
      std::map<int,std::multimap<int,DigiScintHit*> > plnstriphits;
      
      for(int i=0;i<digiscinthits->GetEntries();i++){
        DigiScintHit *hit = dynamic_cast<DigiScintHit*>(digiscinthits->At(i));
        plnhits.insert(make_pair(hit->Plane(),hit));
      }
      
      for(int i=0;i<487;i++){
        std::pair<std::multimap<int,DigiScintHit*>::const_iterator,
          std::multimap<int,DigiScintHit*>::const_iterator> plnhititerpair = 
          plnhits.equal_range(i);
        
        if(plnhititerpair.first!=plnhititerpair.second){
          std::multimap<int,DigiScintHit*> striphits;
          for(std::multimap<int,DigiScintHit*>::const_iterator plnhititer = 
                plnhititerpair.first; plnhititer!=plnhititerpair.second;
              plnhititer++){
            striphits.insert(std::make_pair((plnhititer->second)->Strip(),
                                            plnhititer->second));
          }
          plnstriphits.insert(std::make_pair(i,striphits));
        }
      }
      
      UgliGeomHandle ugh(vld,Ugli::kUseGlobal);
      bool contfail = false;
      
      typedef std::map<int,std::multimap<int,DigiScintHit*> >::const_iterator
        MAPITER;
      typedef std::multimap<int,DigiScintHit*>::const_iterator MMAPITER;
      
      for(int i=0;i<487;i++){
        bool realplane = false;
        std::pair<MAPITER,MAPITER> plnstriphititerpair = 
          plnstriphits.equal_range(i);
        if(plnstriphititerpair.first!=plnstriphititerpair.second){
          
          for(int j=0;j<192;j++){
            std::pair<MMAPITER,MMAPITER> striphititerpair = 
              ((plnstriphititerpair.first)->second).equal_range(j);
            if(striphititerpair.first!=striphititerpair.second){
          
              float stripE = 0.;
              for(MMAPITER hititer = striphititerpair.first; 
                  hititer!= striphititerpair.second; hititer++){
                stripE += (hititer->second)->DE();
              }
              fTotTruE += stripE;
              if(stripE>0.0015){
                realplane = true;
                
                DigiScintHit *hit = (striphititerpair.first)->second;
                PlexStripEndId pseid = hit->StripEndId();
                const UgliStripHandle ush = ugh.GetStripHandle(pseid);
                TVector3 localvec(hit->X1(),hit->Y1(),hit->Z1());
                TVector3 globalvec(ush.LocalToGlobal(localvec));
                float x = globalvec.X();
                float y = globalvec.Y();
                float z = globalvec.Z();
                float u = 0.707107*(x+y);
                float v = 0.707107*(y-x);

                if( ((x*x) > cUVdistcut*cUVdistcut) || 
                    ((y*y) > cUVdistcut*cUVdistcut) || 
                    ((u*u) > cUVdistcut*cUVdistcut) || 
                    ((v*v) > cUVdistcut*cUVdistcut) || (z>(fSnrlZMax-0.13)) || 
                    (z<(fSnrlZMin+0.13)) ){
                  contfail = true;
                  //j = 192;
                  //i = 487;
                }
              }
            }
          }
        }
        if(realplane) fNTruPlanes++; 
      }
      // make cut decisions here. use gross estimate of 
      // 1.5 Gev Deposited : 5000 PE to compare true energy/snarl charge      
      fSnrlChrgDecT = ((fTotTruE*5000/1.5)<cSnrlChrgCut)?0:1;
      fContainDecT = (contfail)?0:1;
      fNPlanesDecT = (fNTruPlanes<cMinNPlanes)?0:1;
    }
}

---

Member Data Documentation

Float_t PreFilter::cClustDistcut [private]

Definition at line 61 of file PreFilter.h.

Referenced by Cluster(), Config(), and ~PreFilter().

Bool_t PreFilter::cDiagnosticMode [private]

Definition at line 41 of file PreFilter.h.

Referenced by Ana(), BeginJob(), BeginSnarl(), Config(), and ~PreFilter().

Float_t PreFilter::cDigFitDcut [private]

Definition at line 61 of file PreFilter.h.

Referenced by Ana(), Config(), and ~PreFilter().

Float_t PreFilter::cDmxWtcut [private]

Definition at line 61 of file PreFilter.h.

Referenced by Ana(), Config(), and ~PreFilter().

std::string PreFilter::cListIn [private]

Definition at line 46 of file PreFilter.h.

Referenced by Ana(), and Config().

Int_t PreFilter::cMinNPlanes [private]

Definition at line 45 of file PreFilter.h.

Referenced by Ana(), Config(), SimCheck(), and ~PreFilter().

Float_t PreFilter::cPEcut [private]

Definition at line 61 of file PreFilter.h.

Referenced by Ana(), Config(), and ~PreFilter().

Float_t PreFilter::cSnrlChrgCut [private]

Definition at line 44 of file PreFilter.h.

Referenced by Ana(), Config(), SimCheck(), and ~PreFilter().

Float_t PreFilter::cUVdistcut [private]

Definition at line 44 of file PreFilter.h.

Referenced by Ana(), Config(), SimCheck(), and ~PreFilter().

Float_t PreFilter::cXYUVcut [private]

Definition at line 44 of file PreFilter.h.

Referenced by Ana(), Config(), and ~PreFilter().

Int_t PreFilter::fContainDecD [private]

Definition at line 50 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fContainDecT [private]

Definition at line 51 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and SimCheck().

Int_t PreFilter::fMaxPln [private]

Definition at line 66 of file PreFilter.h.

Referenced by Ana(), and BeginJob().

Int_t PreFilter::fMinPln [private]

Definition at line 66 of file PreFilter.h.

Referenced by Ana(), and BeginJob().

Int_t PreFilter::fNCandDig [private]

Definition at line 70 of file PreFilter.h.

Referenced by Ana(), and BeginJob().

Int_t PreFilter::fNOLClusters [private]

Definition at line 71 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fNPlanes [private]

Definition at line 70 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fNPlanesDecD [private]

Definition at line 50 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fNPlanesDecT [private]

Definition at line 51 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and SimCheck().

Int_t PreFilter::fNRawDig [private]

Definition at line 70 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fNSnarls [private]

Definition at line 72 of file PreFilter.h.

Referenced by Ana(), and BeginJob().

Int_t PreFilter::fNTruPlanes [private]

Definition at line 70 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and SimCheck().

Int_t PreFilter::fNUClusters [private]

Definition at line 71 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fNVClusters [private]

Definition at line 71 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fP4Neu[4] [private]

Definition at line 90 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and SimCheck().

Int_t PreFilter::fProblems [private]

Definition at line 58 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fRun [private]

Definition at line 70 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fSnrl [private]

Definition at line 70 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fSnrlChrg [private]

Definition at line 74 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fSnrlChrgDecD [private]

Definition at line 50 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fSnrlChrgDecT [private]

Definition at line 51 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and SimCheck().

Float_t PreFilter::fSnrlZMax [private]

Definition at line 67 of file PreFilter.h.

Referenced by Ana(), and SimCheck().

Float_t PreFilter::fSnrlZMin [private]

Definition at line 67 of file PreFilter.h.

Referenced by Ana(), and SimCheck().

Int_t PreFilter::fSubrun [private]

Definition at line 70 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fTotTruE [private]

Definition at line 75 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and SimCheck().

Float_t PreFilter::fTotUClustChrg [private]

Definition at line 74 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Int_t PreFilter::fTotUClustDig [private]

Definition at line 72 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fTotVClustChrg [private]

Definition at line 74 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Int_t PreFilter::fTotVClustDig [private]

Definition at line 72 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fUClustChrg[50] [private]

Definition at line 79 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fUClustMaxZ[50] [private]

Definition at line 83 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fUClustMinZ[50] [private]

Definition at line 81 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Int_t PreFilter::fUClustSize[50] [private]

Definition at line 77 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fUDigChrg [private]

Definition at line 74 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fUdigSize [private]

Definition at line 71 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fUIntercept[50] [private]

Definition at line 87 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fUSlope[50] [private]

Definition at line 86 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fVClustChrg[50] [private]

Definition at line 80 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fVClustMaxZ[50] [private]

Definition at line 84 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fVClustMinZ[50] [private]

Definition at line 82 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Int_t PreFilter::fVClustSize[50] [private]

Definition at line 78 of file PreFilter.h.

Referenced by BeginJob(), BeginSnarl(), and Diagnostic().

Float_t PreFilter::fVDigChrg [private]

Definition at line 74 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Int_t PreFilter::fVdigSize [private]

Definition at line 71 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fVIntercept[50] [private]

Definition at line 89 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

Float_t PreFilter::fVSlope[50] [private]

Definition at line 88 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and BeginSnarl().

TTree* PreFilter::MyTree [private]

Definition at line 93 of file PreFilter.h.

Referenced by Ana(), BeginJob(), and ~PreFilter().

TFile* PreFilter::outfile [private]

Definition at line 92 of file PreFilter.h.

Referenced by BeginJob(), and ~PreFilter().

---

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

• PreFilter.h
• PreFilter.cxx

---