Inheritance diagram for sbnd::CRTTzeroProducer:

Public Member Functions
	CRTTzeroProducer (fhicl::ParameterSet const &p)

	CRTTzeroProducer (CRTTzeroProducer const &)=delete

	CRTTzeroProducer (CRTTzeroProducer &&)=delete

CRTTzeroProducer &	operator= (CRTTzeroProducer const &)=delete

CRTTzeroProducer &	operator= (CRTTzeroProducer &&)=delete

void	produce (art::Event &e) override

void	beginJob () override

void	endJob () override

Private Attributes
std::string	data_label_

double	max_time_difference_

int	store_tzero_

int	verbose_ = 0

Detailed Description

Definition at line 51 of file sbndcode/sbndcode/CRT/CRTTzeroProducer_module.cc.

Constructor & Destructor Documentation

sbnd::CRTTzeroProducer::CRTTzeroProducer ( fhicl::ParameterSet const & p )

explicit

Definition at line 88 of file sbndcode/sbndcode/CRT/CRTTzeroProducer_module.cc.

   : EDProducer(p),
 
   // Initialize member data here.
   data_label_(p.get<std::string>("data_label")),
   max_time_difference_(p.get<double>("max_time_difference")),
   store_tzero_(p.get<int>("store_tzero")),
   verbose_(p.get<int>("verbose"))
 
 {
 
   // Call appropriate produces<>() functions here.
   if(store_tzero_ == 1)  {
     produces< std::vector<sbn::crt::CRTTzero>   >();
     produces<art::Assns<sbn::crt::CRTTzero, sbn::crt::CRTHit> >();
   }
 
 }

sbnd::CRTTzeroProducer::CRTTzeroProducer ( CRTTzeroProducer const & )

delete

sbnd::CRTTzeroProducer::CRTTzeroProducer ( CRTTzeroProducer && )

delete

Member Function Documentation

void sbnd::CRTTzeroProducer::beginJob ( )

override

Definition at line 219 of file sbndcode/sbndcode/CRT/CRTTzeroProducer_module.cc.

 {
   
 }

void sbnd::CRTTzeroProducer::endJob ( )

override

Definition at line 224 of file sbndcode/sbndcode/CRT/CRTTzeroProducer_module.cc.

 {
   // Implementation of optional member function here.
 }

CRTTzeroProducer& sbnd::CRTTzeroProducer::operator= ( CRTTzeroProducer const & )

delete

CRTTzeroProducer& sbnd::CRTTzeroProducer::operator= ( CRTTzeroProducer && )

delete

void sbnd::CRTTzeroProducer::produce ( art::Event & e )

override

Definition at line 107 of file sbndcode/sbndcode/CRT/CRTTzeroProducer_module.cc.

 {
   // Implementation of required member function here.
   
   art::Handle< std::vector<sbn::crt::CRTHit> > rawHandle;
   evt.getByLabel(data_label_, rawHandle);   
   //check to make sure the data we asked for is valid                                                                       
   if(!rawHandle.isValid()){
     std::cout << "Run " << evt.run() << ", subrun " << evt.subRun()
               << ", event " << evt.event() << " has zero"
               << " CRTHits " << " in module " << data_label_ << std::endl;
     std::cout << std::endl;
     return;
   }
   
   //get better access to the data               
   std::vector<sbn::crt::CRTHit> const& CRTHitCollection(*rawHandle);
 
   //CRTTzero collection on this event                                                              
   std::unique_ptr<std::vector<sbn::crt::CRTTzero> > CRTTzeroCol(new std::vector<sbn::crt::CRTTzero>);
   
   // Output collections  
   std::unique_ptr<art::Assns<sbn::crt::CRTTzero, sbn::crt::CRTHit>> outputHits(new art::Assns<sbn::crt::CRTTzero, sbn::crt::CRTHit>);
   //  auto outputHits    = std::make_unique<art::Assns<sbn::crt::CRTTzero, sbn::crt::CRTHit>>();
   art::PtrMaker<sbn::crt::CRTHit> hitPtrMaker(evt, rawHandle.id());
   art::PtrMaker<sbn::crt::CRTTzero> tzeroPtrMaker(evt);
  
   int N_CRTHits = CRTHitCollection.size();
 
   //int iflag[1000] = {};
   std::vector<int> iflag;
   for(int i = 0; i < N_CRTHits; i++) iflag.push_back(0);
   int nTzero = 0;
   uint planeA, planeB;
   for(int  i = 0; i < N_CRTHits; i++) {//A 
     if (iflag[i]==0) {  // new tzero
       //temporary hit collection for each tzero
       std::vector<art::Ptr<sbn::crt::CRTHit>> CRTHitCol;
       sbn::crt::CRTHit CRTHiteventA = CRTHitCollection[i];
       art::Ptr<sbn::crt::CRTHit> hptr = hitPtrMaker(i);
       CRTHitCol.push_back(hptr);
 
       double time_s_A = 0; //CRTHiteventA.ts0_s;
       double time_ns_A = CRTHiteventA.ts1_ns;
 
       iflag[i]=1;
 
       // create and initialize, ugly code :(
       sbn::crt::CRTTzero CRTcanTzero;
       CRTcanTzero.ts0_ns=0;
       CRTcanTzero.ts1_ns=0;
       for (int j=0; j<7 ;++j) { // NUMBER OF PLANES, CHANGE TO 7
         CRTcanTzero.nhits[j]=0;
         CRTcanTzero.pes[j]=0;
       }
 
       // 
       CRTcanTzero.ts0_s=CRTHiteventA.ts0_s;
       CRTcanTzero.ts0_s_err=0;
       planeA = CRTHiteventA.plane;
       CRTcanTzero.nhits[planeA]=1;      
 
       int icount=1;
 
       CRTcanTzero.pes[planeA]=CRTHiteventA.peshit;
       for(int j = i+1; j < N_CRTHits; j++) {//B
         if (iflag[j]==0) {
           sbn::crt::CRTHit CRTHiteventB = CRTHitCollection[j];
           //look for coincidences
           double time_s_B = 0; //CRTHiteventB.ts0_s;
           double time_ns_B = CRTHiteventB.ts1_ns;
           double time_diff = time_ns_B - time_ns_A;
 
           if( (time_s_A == time_s_B) && (abs(time_diff)<max_time_difference_)  ){//D
             art::Ptr<sbn::crt::CRTHit> hptr = hitPtrMaker(j);
             CRTHitCol.push_back(hptr);
             planeB = CRTHiteventB.plane; 
             CRTcanTzero.nhits[planeB]+=1;
             CRTcanTzero.pes[planeB]+=CRTHiteventB.peshit;
             iflag[j]=1;
             CRTcanTzero.ts1_ns+=(int)(time_diff);
             CRTcanTzero.ts0_ns+=(CRTHiteventB.ts0_ns-CRTHiteventA.ts0_ns);
             icount++;
           }
         }
       }      // done with this tzero
 
       // Make a tzero data product
       CRTcanTzero.ts1_ns/=icount; 
       CRTcanTzero.ts1_ns+=(int)time_ns_A;
       CRTcanTzero.ts0_ns/=icount;
       CRTcanTzero.ts0_ns+=(int)CRTHiteventA.ts0_ns;
       CRTcanTzero.ts1_ns_err=0.;
       CRTcanTzero.ts0_ns_err=0.;
       CRTTzeroCol->push_back(CRTcanTzero);
       nTzero++;
 
       //associate hits to this Tzero
       art::Ptr<sbn::crt::CRTTzero> aptz = tzeroPtrMaker(CRTTzeroCol->size()-1);
       util::CreateAssn(*this,evt,aptz,CRTHitCol,*outputHits);
      
     }//B
     
   }//A
 
   //store tzero collection into event
   if(store_tzero_ == 1) {
     evt.put(std::move(CRTTzeroCol));
     evt.put(std::move(outputHits));
   }
 }