Inheritance diagram for protoana::diffusioncathodet0:

Public Member Functions
	diffusioncathodet0 (fhicl::ParameterSet const &pset)

virtual	~diffusioncathodet0 ()

void	beginJob ()

void	endJob ()

void	beginRun (const art::Run &run)

void	analyze (const art::Event &evt)

void	reset ()

Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDAnalyzer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept

	Analyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	Analyzer (Table< Config > const &config)

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

fhicl::ParameterSetID	selectorConfig () const

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Attributes
ProtoDUNEDataUtils	fDataUtils

TTree *	fEventTree

geo::GeometryCore const *	fGeometry

Int_t	run

Int_t	subrun

Int_t	event

Double_t	evttime

int	fNactivefembs [6]

std::vector< float >	trackthetaxz

std::vector< float >	trackthetayz

std::vector< float >	trkstartx

std::vector< float >	trkstarty

std::vector< float >	trkstartz

std::vector< std::vector< float > >	trkstartcosxyz

std::vector< std::vector< float > >	trkendcosxyz

std::vector< float >	trkendx

std::vector< float >	trkendy

std::vector< float >	trkendz

std::vector< float >	trklen

std::vector< int >	TrkID

std::vector< float >	xprojectedlen

std::vector< double >	T0_values

std::vector< int >	tot_trks

std::vector< std::vector< float > >	hit_peakT0

std::vector< std::vector< int > >	hit_tpc0

std::vector< std::vector< int > >	hit_wire0

std::vector< std::vector< float > >	hit_rms0

std::vector< std::vector< float > >	hit_deltaT

std::vector< std::vector< float > >	trkhitx0

std::vector< std::vector< float > >	trkhity0

std::vector< std::vector< float > >	trkhitz0

std::vector< std::vector< float > >	trkdq_amp0

std::vector< std::vector< float > >	trkdq_int0

std::vector< std::vector< float > >	hit_peakT1

std::vector< std::vector< int > >	hit_tpc1

std::vector< std::vector< int > >	hit_wire1

std::vector< std::vector< float > >	hit_rms1

std::vector< std::vector< float > >	trkhitx1

std::vector< std::vector< float > >	trkhity1

std::vector< std::vector< float > >	trkhitz1

std::vector< std::vector< float > >	trkdq_amp1

std::vector< std::vector< float > >	trkdq_int1

std::vector< std::vector< float > >	hit_peakT2

std::vector< std::vector< int > >	hit_tpc2

std::vector< std::vector< int > >	hit_wire2

std::vector< std::vector< float > >	hit_rms2

std::vector< std::vector< float > >	hit_rms_true

std::vector< std::vector< float > >	trkhitx2

std::vector< std::vector< float > >	trkhity2

std::vector< std::vector< float > >	trkhitz2

std::vector< std::vector< float > >	trkhitz_wire2

std::vector< std::vector< float > >	trkdq_amp2

std::vector< std::vector< float > >	trkdq_int2

std::vector< std::vector< float > >	multiplicity2

std::vector< std::vector< float > >	goodnessoffit2

std::string	fHitsModuleLabel

std::string	fTrackModuleLabel

std::string	fCalorimetryModuleLabel

bool	fSaveTrackInfo

bool	fSaveCaloInfo

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Protected Member Functions inherited from art::Observer
std::string const &	processName () const

bool	wantAllEvents () const noexcept

bool	wantEvent (ScheduleID id, Event const &e) const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 95 of file diffusioncathodet0_module.cc.

Constructor & Destructor Documentation

protoana::diffusioncathodet0::diffusioncathodet0 ( fhicl::ParameterSet const & pset )

explicit

Definition at line 174 of file diffusioncathodet0_module.cc.

                                                                       :
     EDAnalyzer(pset),
     fDataUtils                  (pset.get<fhicl::ParameterSet>("DataUtils")),
     fHitsModuleLabel          (pset.get< std::string >("HitsModuleLabel","")         ), 
     fTrackModuleLabel         (pset.get< std::string >("TrackModuleLabel","")        ),
     fCalorimetryModuleLabel   (pset.get< std::string >("CalorimetryModuleLabel","")  ),
     fSaveTrackInfo            (pset.get< bool>("SaveTrackInfo",false)),
     fSaveCaloInfo             (pset.get< bool>("SaveCaloInfo",false))
 
   {
     if (fSaveTrackInfo == false) fSaveCaloInfo = false;
   }

protoana::diffusioncathodet0::~diffusioncathodet0 ( )

virtual

Definition at line 188 of file diffusioncathodet0_module.cc.

188 {

189 }

Member Function Documentation

void protoana::diffusioncathodet0::analyze ( const art::Event & evt )

this block just saves the t0 values while I include entries with no T0s as well also this saves T0 coming from pandroaTrack alg only

evt.IsRealData

Definition at line 266 of file diffusioncathodet0_module.cc.

                                                       {//analyze
     reset();  
 
     // art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
     fGeometry = &*(art::ServiceHandle<geo::Geometry>());
    
     std::vector<art::Ptr<recob::Track> > tracklist;
     auto trackListHandle = evt.getHandle< std::vector<recob::Track> >("pandoraTrack");
     if(trackListHandle) {
       art::fill_ptr_vector(tracklist, trackListHandle);
     }
     else return;
 
     std::vector<art::Ptr<recob::PFParticle> > pfplist;
     auto PFPListHandle = evt.getHandle< std::vector<recob::PFParticle> >("pandora");
     if (PFPListHandle) art::fill_ptr_vector(pfplist, PFPListHandle);
    
     // get information about the hits
     std::vector<art::Ptr<recob::Hit>> hitlist;
     auto hitListHandle = evt.getHandle< std::vector<recob::Hit> >(fHitsModuleLabel); 
     if (hitListHandle) art::fill_ptr_vector(hitlist, hitListHandle);
     art::FindManyP<recob::Hit, recob::TrackHitMeta> fmthm(trackListHandle, evt, fTrackModuleLabel); // to associate tracks and hits
     art::FindManyP<anab::T0> trk_t0_assn_v(PFPListHandle, evt ,"pandora");
     art::FindManyP<recob::PFParticle> pfp_trk_assn(trackListHandle,evt,"pandoraTrack");
     art::FindManyP<anab::T0> fmT0(trackListHandle, evt ,"pmtrack");
     std::vector<const sim::SimChannel*> fSimChannels;
     try{
       evt.getView("largeant", fSimChannels);
     }catch (art::Exception const&e){
     }
 
     
     run = evt.run();
     subrun = evt.subRun();
     event = evt.id().event();
     art::Timestamp ts = evt.time();
     TTimeStamp tts(ts.timeHigh(), ts.timeLow());
     evttime=tts.AsDouble();
 
 
 
     // Get number of active fembs
     if(!evt.isRealData()){
       for(int k=0; k < 6; k++)
         fNactivefembs[k] = 20;
     }
     else{
       for(int k=0; k < 6; k++)
         fNactivefembs[k] = fDataUtils.GetNActiveFembsForAPA(evt, k);
     }
 
 
     //defining the 1D temporary storage vectors
     std::vector< float> peakT_0;  std::vector< float> peakT_1;  std::vector< float> peakT_2; 
     std::vector< int > tpc_0;  std::vector< int > tpc_1;  std::vector<int> tpc_2; 
     std::vector< int > wire_0;  std::vector< int > wire_1;  std::vector<int> wire_2; 
     std::vector< float > int_0;  std::vector< float > int_1;  std::vector<float> int_2; 
     std::vector< float > amp_0;  std::vector< float > amp_1;  std::vector<float> amp_2; 
     std::vector<float> rms_0;   std::vector<float> rms_1; std::vector<float> rms_2;
     std::vector<float> hitx_0; std::vector<float> hitx_1; std::vector<float> hitx_2;
     std::vector<float> hity_0; std::vector<float> hity_1; std::vector<float> hity_2;
     std::vector<float> hitz_0; std::vector<float> hitz_1; std::vector<float> hitz_2;
     std::vector<float> hitz_wire2; std::vector<float> startcosxyz; std::vector<float> endcosxyz;
     std::vector<float> dT_buffer; std::vector<float> gof, multi,truerms;
    
     float max_value;
     float min_value;
     int trks=0;
     size_t NTracks = tracklist.size();
     for(size_t i=0; i<NTracks;++i){
  
       //clearing the 1D temporary storage vectors
       peakT_0.clear(); peakT_1.clear();  peakT_2.clear(); 
       tpc_0.clear();  tpc_1.clear();  tpc_2.clear(); 
       wire_0.clear();  wire_1.clear();  wire_2.clear(); 
       int_0.clear(); int_1.clear() ;   int_2.clear(); 
       amp_0.clear(); amp_1.clear() ;   amp_2.clear(); 
       rms_0.clear();   rms_1.clear(); rms_2.clear();
       hitx_0.clear();  hitx_1.clear();  hitx_2.clear();
       hity_0.clear();  hity_1.clear();  hity_2.clear();
       hitz_0.clear();  hitz_1.clear();  hitz_2.clear();
       hitz_wire2.clear(); startcosxyz.clear();endcosxyz.clear();
       dT_buffer.clear(); gof.clear(); multi.clear();
       truerms.clear();
 
 
       art::Ptr<recob::Track> ptrack(trackListHandle, i);
 
       ///this block just saves the t0 values while I include entries with no T0s as well also this saves T0 coming from pandroaTrack alg only
       double t_zero=-999999;
       max_value=0.0;
       min_value=0.0;
       if(fTrackModuleLabel=="pandoraTrack"){ 
         std::vector<art::Ptr<recob::PFParticle>> pfps=pfp_trk_assn.at(i);
         if(!pfps.size()) continue;
         std::vector<art::Ptr<anab::T0>> t0s=trk_t0_assn_v.at(pfps[0].key());
         // if(!t0s.size()) continue;
         //auto t0 = t0s.at(0);
         // double t_zero=t0->Time();
         if(t0s.size()==0) continue;
         if(t0s.size()){ 
           auto t0=t0s.at(0);
           t_zero=t0->Time();
         }
       }
      
       if(fTrackModuleLabel=="pmtrack"){
         std::vector<art::Ptr<anab::T0>> T0s=fmT0.at(i);
         if(T0s.size()==0)
           continue;
       }
   
       const recob::Track& track = *ptrack;
       auto pos = track.Vertex();
       auto dir_start = track.VertexDirection();
       auto dir_end   = track.EndDirection();
       auto end = track.End();
       double theta_xz = std::atan2(dir_start.X(), dir_start.Z());
       double theta_yz = std::atan2(dir_start.Y(), dir_start.Z());
      
       int planenum=999;
       float xpos=-9999;
       float ypos=-9999;
       float zpos=-9999;
       auto allHits=fmthm.at(i);
     
       //hits and calorimetry loop
       if(fmthm.isValid()){
         auto vhit=fmthm.at(i);
         auto vmeta=fmthm.data(i);
         for (size_t ii = 0; ii<vhit.size(); ++ii){ //loop over all meta data hit
           bool fBadhit = false;
           if (vmeta[ii]->Index() == static_cast<unsigned int>(std::numeric_limits<int>::max())){
             fBadhit = true;
             //cout<<"fBadHit"<<fBadhit<<endl;
             continue;
           }
           if (vmeta[ii]->Index()>=tracklist[i]->NumberTrajectoryPoints()){
             throw cet::exception("Calorimetry_module.cc") << "Requested track trajectory index "<<vmeta[ii]->Index()<<" exceeds the total number of trajectory points "<<tracklist[i]->NumberTrajectoryPoints()<<" for track index "<<i<<". Something is wrong with the track reconstruction. Please contact tjyang@fnal.gov!!";
           }
           if (!tracklist[i]->HasValidPoint(vmeta[ii]->Index())){
             fBadhit = true;
             // cout<<"had valid point "<<fBadhit<<endl;
             continue;
           }
         
           auto loc = tracklist[i]->LocationAtPoint(vmeta[ii]->Index());
           xpos=loc.X();
           ypos=loc.Y();
           zpos=loc.Z();
           //    cout<<"x, y, z "<<xpos<<"  "<<ypos<<"  "<<zpos<<endl;
           //    cout<<"BadHit"<<fBadhit<<endl;
           if (fBadhit) continue; //HY::If BAD hit, skip this hit and go next
           if (zpos<-100) continue; //hit not on track
           planenum=vhit[ii]->WireID().Plane;
           if(planenum==0){       
             peakT_0.push_back(vhit[ii]->PeakTime());
             tpc_0.push_back(vhit[ii]->WireID().TPC);
             wire_0.push_back(vhit[ii]->WireID().Wire);
             int_0.push_back(vhit[ii]->Integral());
             amp_0.push_back(vhit[ii]->PeakAmplitude());
             rms_0.push_back(vhit[ii]->RMS());
             hitx_0.push_back(xpos);
             hity_0.push_back(ypos);
             hitz_0.push_back(zpos);             
           }//planenum 0
           if(planenum==1){       
             peakT_1.push_back(vhit[ii]->PeakTime());
             tpc_1.push_back(vhit[ii]->WireID().TPC);
             wire_1.push_back(vhit[ii]->WireID().Wire);
             int_1.push_back(vhit[ii]->Integral());
             amp_1.push_back(vhit[ii]->PeakAmplitude());
             rms_1.push_back(vhit[ii]->RMS());
             hitx_1.push_back(xpos);
             hity_1.push_back(ypos);
             hitz_1.push_back(zpos);     
           }//planenum 1
           if(planenum==2){
             peakT_2.push_back(vhit[ii]->PeakTime());
             tpc_2.push_back(vhit[ii]->WireID().TPC);
             wire_2.push_back(vhit[ii]->WireID().Wire);
             int_2.push_back(vhit[ii]->Integral());
             amp_2.push_back(vhit[ii]->PeakAmplitude());
             rms_2.push_back(vhit[ii]->RMS());
             dT_buffer.push_back(vhit[ii]->EndTick()-vhit[ii]->StartTick());
             hitx_2.push_back(xpos);
             hity_2.push_back(ypos);
             hitz_2.push_back(zpos);
             gof.push_back(vhit[ii]->GoodnessOfFit());
             multi.push_back(vhit[ii]->Multiplicity());
             double xyzStart[3];
             double xyzEnd[3];
             unsigned int wireno=vhit[ii]->WireID().Wire;
             fGeometry->WireEndPoints(0,vhit[ii]->WireID().TPC,2,wireno, xyzStart, xyzEnd);
             hitz_wire2.push_back(xyzStart[2]);
             double truermsb=-1;
 
             //section for using tuth information
             unsigned int t0=vhit[ii]->PeakTime()-3*(vhit[ii]->RMS());
             if(t0<0) t0=0;
             unsigned int t1=vhit[ii]->PeakTime()+3*(vhit[ii]->RMS());
             if(t1>6000) t1=6000-1;
             
             if(!evt.isRealData()){
               const sim::SimChannel* chan=0;
               for(size_t sc=0;sc<fSimChannels.size();++sc){
                 if(fSimChannels[sc]->Channel()==vhit[ii]->Channel()) chan=fSimChannels[sc];
               }
               if(chan){
                 const auto &tdcidemap = chan->TDCIDEMap();
                 double hit_ch=0;
                 double mean_t=0;
                 double mean_t2=0;
                 double hit_rmsvalue=0;
                 for(auto mapitr = tdcidemap.begin(); mapitr != tdcidemap.end(); mapitr++){
                   if(!((*mapitr).first>t0 && (*mapitr).first<=t1)) continue;
                   // loop over the vector of IDE objects.
                   int hit_nelec=0;
                   const std::vector<sim::IDE> idevec = (*mapitr).second;
                   for(size_t iv = 0; iv < idevec.size(); ++iv){ 
                     hit_nelec+=idevec[iv].numElectrons;
                   }//iv loop
                   hit_ch+=hit_nelec;
                   // std::cout<<"hit_ch "<<hit_ch<<std::endl; 
                   int j=(*mapitr).first;
                   mean_t+=double(j)*double(hit_nelec);
                   double jterm=double(j)*double(j)*double(hit_nelec);
                   mean_t2=mean_t2+jterm;
                 }//mapitr loop
                 mean_t/=hit_ch;
                 mean_t2/=hit_ch;
                 hit_rmsvalue=sqrt(mean_t2-mean_t*mean_t);
                 //      std::cout<<"hit rms "<<hit_rmsvalue<<" reco rms "<<vhit[ii]->RMS()<<std::endl;
                 truermsb=hit_rmsvalue;
               }//if(chan)
             }//!evt.IsRealData
             truerms.push_back(truermsb);
 
            
           }//planenum 2
         }//loop over vhit
       }//fmthm valid
       //hits and calorimetry loop
       if(peakT_2.size()<10) continue;
       max_value=*std::max_element(peakT_2.begin(),peakT_2.end());
       min_value=*std::min_element(peakT_2.begin(),peakT_2.end());
       // if(max_value-min_value<4300) continue;
       std::cout<<max_value<<"  "<<min_value<<std::endl;
       trks++;
       hit_peakT0.push_back(peakT_0);
       hit_tpc0.push_back(tpc_0);
       hit_wire0.push_back(wire_0);
       hit_rms0.push_back(rms_0);
       trkhitx0.push_back(hitx_0);
       trkhity0.push_back(hity_0);
       trkhitz0.push_back(hitz_0);
       trkdq_amp0.push_back(amp_0);
       trkdq_int0.push_back(int_0);
 
       hit_peakT1.push_back(peakT_1);
       hit_tpc1.push_back(tpc_1);
       hit_wire1.push_back(wire_1);
       hit_rms1.push_back(rms_1);
       trkhitx1.push_back(hitx_1);
       trkhity1.push_back(hity_1);
       trkhitz1.push_back(hitz_1);
       trkdq_amp1.push_back(amp_1);
       trkdq_int1.push_back(int_1);
 
       hit_peakT2.push_back(peakT_2);
       hit_tpc2.push_back(tpc_2);
       hit_wire2.push_back(wire_2);
       hit_rms2.push_back(rms_2);
       hit_rms_true.push_back(truerms);
       trkhitx2.push_back(hitx_2);
       trkhity2.push_back(hity_2);
       trkhitz2.push_back(hitz_2);
       trkhitz_wire2.push_back(hitz_wire2);
       trkdq_amp2.push_back(amp_2);
       trkdq_int2.push_back(int_2);
       hit_deltaT.push_back(dT_buffer);
       multiplicity2.push_back(multi);
       goodnessoffit2.push_back(gof);
 
      
 
       xprojectedlen.push_back(TMath::Abs(end.X()-pos.X()));
       trackthetaxz.push_back(theta_xz);
       trackthetayz.push_back(theta_yz);
       trkstartx.push_back(pos.X());
       trkstarty.push_back(pos.Y());
       trkstartz.push_back(pos.Z());
       startcosxyz.push_back(dir_start.X());
       startcosxyz.push_back(dir_start.Y());
       startcosxyz.push_back(dir_start.Z());
       endcosxyz.push_back(dir_end.X());
       endcosxyz.push_back(dir_end.Y());
       endcosxyz.push_back(dir_end.Z());
 
       trkstartcosxyz.push_back(startcosxyz);
       trkendcosxyz.push_back(endcosxyz);
       trkendx.push_back(end.X());
 
       trkendy.push_back(end.Y());
       trkendz.push_back(end.Z());
       trklen.push_back(track.Length());
       TrkID.push_back(track.ID());
       T0_values.push_back(t_zero);
     } // loop over trks...
     tot_trks.push_back(trks);
     fEventTree->Fill();
   } // end of analyze function

void protoana::diffusioncathodet0::beginJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 193 of file diffusioncathodet0_module.cc.

                                    {
     std::cout<<"job begin..."<<std::endl;
     art::ServiceHandle<art::TFileService> tfs;
     fEventTree = tfs->make<TTree>("Event", "Event Tree from Reco");
     fEventTree->Branch("event", &event,"event/I");
     fEventTree->Branch("evttime",&evttime,"evttime/D");
     fEventTree->Branch("run", &run,"run/I");
     fEventTree->Branch("Nactivefembs",&fNactivefembs,"Nactivefembs[6]/I");
     fEventTree->Branch("subrun", &subrun,"surbrun/I");
     fEventTree->Branch("T0_values",&T0_values);
     fEventTree->Branch("xprojectedlen",&xprojectedlen);
     fEventTree->Branch("trackthetaxz",&trackthetaxz);
     fEventTree->Branch("trackthetayz",&trackthetayz);
     fEventTree->Branch("trkstartx",&trkstartx);
     fEventTree->Branch("trkstarty",&trkstarty);
     fEventTree->Branch("trkstartz",&trkstartz);
     fEventTree->Branch("trkendx",&trkendx);
     fEventTree->Branch("trkendy",&trkendy);
     fEventTree->Branch("trkendz",&trkendz);
     fEventTree->Branch("trklen",&trklen);
     fEventTree->Branch("TrkID",&TrkID);
     fEventTree->Branch("tot_trks",&tot_trks);
     fEventTree->Branch("hit_peakT0",&hit_peakT0);
     fEventTree->Branch("hit_tpc0",&hit_tpc0);
     fEventTree->Branch("hit_wire0",&hit_wire0);
     fEventTree->Branch("hit_rms0",&hit_rms0);
     fEventTree->Branch("hit_deltaT",&hit_deltaT);
     fEventTree->Branch("trkhitx0",&trkhitx0);
     fEventTree->Branch("trkhity0",&trkhity0);
     fEventTree->Branch("trkhitz0",&trkhitz0);
     fEventTree->Branch("trkdq_int0",&trkdq_int0);
     fEventTree->Branch("trkdq_amp0",&trkdq_amp0);
     fEventTree->Branch("hit_peakT1",&hit_peakT1);
     fEventTree->Branch("hit_tpc1",&hit_tpc1);
     fEventTree->Branch("hit_wire1",&hit_wire1);
     fEventTree->Branch("hit_rms1",&hit_rms1);
     fEventTree->Branch("trkhitx1",&trkhitx1);
     fEventTree->Branch("trkhity1",&trkhity1);
     fEventTree->Branch("trkhitz1",&trkhitz1);
     fEventTree->Branch("trkdq_int1",&trkdq_int1);
     fEventTree->Branch("trkdq_amp1",&trkdq_amp1);
     fEventTree->Branch("hit_peakT2",&hit_peakT2);
     fEventTree->Branch("hit_tpc2",&hit_tpc2);
     fEventTree->Branch("hit_wire2",&hit_wire2);
     fEventTree->Branch("hit_rms2",&hit_rms2);
     fEventTree->Branch("hit_rms_true",&hit_rms_true);
     fEventTree->Branch("trkhitx2",&trkhitx2);
     fEventTree->Branch("trkhity2",&trkhity2);
     fEventTree->Branch("trkhitz2",&trkhitz2);
     fEventTree->Branch("trkhitz_wire2",&trkhitz_wire2);
     fEventTree->Branch("trkdq_int2",&trkdq_int2);
     fEventTree->Branch("trkdq_amp2",&trkdq_amp2);
     fEventTree->Branch("trkstartcosxyz",&trkstartcosxyz);
     fEventTree->Branch("trkendcosxyz",&trkendcosxyz);
     fEventTree->Branch("multiplicity2",&multiplicity2);
     fEventTree->Branch("goodnessoffit2",&goodnessoffit2);
   }

void protoana::diffusioncathodet0::beginRun ( const art::Run & run )

Definition at line 257 of file diffusioncathodet0_module.cc.

                                                 {
     mf::LogInfo("diffusioncathodet0")<<"begin run..."<<std::endl;
   }

void protoana::diffusioncathodet0::endJob ( )

virtual

Reimplemented from art::EDAnalyzer.

Definition at line 252 of file diffusioncathodet0_module.cc.

                                  {     
 
   }

void protoana::diffusioncathodet0::reset ( )

Definition at line 580 of file diffusioncathodet0_module.cc.

                                 {
     run = -9999;
     subrun = -9999;
     event = -9999;
     evttime = -9999;
     //all_trks = -9999;
     for(int k=0; k < 6; k++)
       fNactivefembs[k] = -9999;
     trackthetaxz.clear();
     trackthetayz.clear();
     trkstartx.clear();
     trkstarty.clear();
     trkstartz.clear();
     trkstartcosxyz.clear();
     trkendcosxyz.clear();
     trkendx.clear();
     trkendy.clear();
     trkendz.clear();
     trklen.clear();
     TrkID.clear();
     tot_trks.clear();
     T0_values.clear();
     xprojectedlen.clear();
     hit_peakT0.clear();
     hit_tpc0.clear();
     hit_wire0.clear();
     trkhitx0.clear();
     trkhity0.clear();
     trkhitz0.clear();
     trkdq_int0.clear();
     trkdq_amp0.clear();
     hit_rms0.clear();
     hit_peakT1.clear();
     hit_tpc1.clear();
     hit_wire1.clear();
     trkhitx1.clear();
     trkhity1.clear();
     trkhitz1.clear();
     trkdq_int1.clear();
     trkdq_amp1.clear();
     hit_rms1.clear();
     hit_peakT2.clear();
     hit_tpc2.clear();
     hit_wire2.clear();
     trkhitx2.clear();
     trkhity2.clear();
     trkhitz2.clear();
     trkhitz_wire2.clear();
     trkdq_int2.clear();
     trkdq_amp2.clear();
     hit_rms2.clear();
     hit_deltaT.clear();
     multiplicity2.clear();
     goodnessoffit2.clear();
     hit_rms_true.clear();
   }