diff --git a/src/THcHodoHit.h b/src/THcHodoHit.h
index be94afc2617375b995eb47125ed071b3bf1fb3b9..ce2d592bae12af5c7a690ae948e0293886475191 100644
--- a/src/THcHodoHit.h
+++ b/src/THcHodoHit.h
@@ -30,11 +30,21 @@ public:
Int_t GetNegTDC() const { return fNegTDC; }
Double_t GetPosCorrectedTime() const { return fPosCorrectedTime;}
Double_t GetNegCorrectedTime() const { return fNegCorrectedTime;}
+ Double_t GetPosTOFCorrectedTime() const { return fPosTOFCorrectedTime;}
+ Double_t GetNegTOFCorrectedTime() const { return fNegTOFCorrectedTime;}
+ Double_t GetScinCorrectedTime() const { return fScinCorrectedTime;}
Int_t GetPaddleNumber() const { return fPaddleNumber; }
- void SetCorrectedTimes(Double_t pos, Double_t neg) {
+ void SetCorrectedTimes(Double_t pos, Double_t neg, Double_t) {
fPosCorrectedTime = pos; fNegCorrectedTime = neg;
}
+ void SetCorrectedTimes(Double_t pos, Double_t neg,
+ Double_t postof, Double_t negtof,
+ Double_t timeave) {
+ fPosCorrectedTime = pos; fNegCorrectedTime = neg;
+ fPosTOFCorrectedTime = postof; fNegTOFCorrectedTime = negtof;
+ fScinCorrectedTime = timeave;
+ }
protected:
static const Double_t kBig; //!
@@ -46,7 +56,10 @@ protected:
Double_t fNegADC_Ped; // Pedestal subtracted ADC
Double_t fPosCorrectedTime; // Pulse height corrected time
Double_t fNegCorrectedTime; // Pulse height corrected time
-
+ Double_t fScinCorrectedTime; // Time average corrected for position
+ // based on ADCs.
+ Double_t fPosTOFCorrectedTime; // Times corrected for z position
+ Double_t fNegTOFCorrectedTime; // using nominal beta
THcScintillatorPlane* fPlane; // Pointer to parent scintillator plane
diff --git a/src/THcHodoscope.cxx b/src/THcHodoscope.cxx
index b3b2f6144adf55150f529990c071c77f7df65bf9..68b500967b70426f157c0960b2a6314d14e4f920 100644
--- a/src/THcHodoscope.cxx
+++ b/src/THcHodoscope.cxx
@@ -678,7 +678,6 @@ Int_t THcHodoscope::Decode( const THaEvData& evdata )
// Let each plane get its hits
Int_t nexthit = 0;
- fStartTime=0;
fNfptimes=0;
for(Int_t ip=0;ip<fNPlanes;ip++) {
@@ -689,24 +688,10 @@ Int_t THcHodoscope::Decode( const THaEvData& evdata )
// GN: select only events that have reasonable TDC values to start with
// as per the Engine h_strip_scin.f
nexthit = fPlanes[ip]->ProcessHits(fRawHitList,nexthit);
- if (fPlanes[ip]->GetNScinHits()>0) {
- fPlanes[ip]->EstimateFocalPlaneTimes();
- // GN: allow for more than one fptime per plane!!
- for (Int_t i=0;i<fPlanes[ip]->GetNScinGoodHits();i++) {
- if (TMath::Abs(fPlanes[ip]->GetFpTime(i)-fStartTimeCenter)<=fStartTimeSlop) {
- fStartTime=fStartTime+fPlanes[ip]->GetFpTime(i);
- fNfptimes++;
- }
- }
- }
- }
- if (fNfptimes>0) {
- fStartTime=fStartTime/fNfptimes;
- fGoodStartTime=kTRUE;
- } else {
- fGoodStartTime=kFALSE;
- fStartTime=fStartTimeCenter;
}
+
+ EstimateFocalPlaneTime();
+
if (fdebugprintscinraw == 1) {
for(UInt_t ihit = 0; ihit < fNRawHits ; ihit++) {
THcRawHodoHit* hit = (THcRawHodoHit *) fRawHitList->At(ihit);
@@ -721,6 +706,81 @@ Int_t THcHodoscope::Decode( const THaEvData& evdata )
return nhits;
}
+//_____________________________________________________________________________
+void THcHodoscope::EstimateFocalPlaneTime( void )
+{
+ Int_t timehist[200];
+ Int_t time_pos[100],time_neg[100];
+ Double_t scin_corrected_time[100];
+
+ for (Int_t i=0;i<200;i++) {
+ timehist[i] = 0;
+ }
+ Int_t ihit=0;
+ for(Int_t ip=0;ip<fNPlanes;ip++) {
+ Int_t nphits=fPlanes[ip]->GetNScinHits();
+ TClonesArray* hodoHits = fPlanes[ip]->GetHits();
+ for(Int_t i=0;i<nphits;i++) {
+ Double_t postime=((THcHodoHit*) hodoHits->At(i))->GetPosTOFCorrectedTime();
+ Double_t negtime=((THcHodoHit*) hodoHits->At(i))->GetNegTOFCorrectedTime();
+
+ for (Int_t k=0;k<200;k++) {
+ Double_t tmin=0.5*(k+1);
+ if ((postime> tmin) && (postime < tmin+fTofTolerance)) {
+ timehist[k]++;
+ }
+ if ((negtime> tmin) && (negtime < tmin+fTofTolerance)) {
+ timehist[k]++;
+ }
+ }
+ ihit++;
+ }
+ }
+
+ // Find the bin with most hits
+ ihit=0;
+ Int_t binmax=0;
+ Int_t maxhit=0;
+ for(Int_t i=0;i<200;i++) {
+ if(timehist[i]>maxhit) {
+ binmax = i;
+ maxhit = timehist[i];
+ }
+ }
+
+ ihit = 0;
+ Double_t fpTimeSum = 0.0;
+ fNfptimes=0;
+
+ for(Int_t ip=0;ip<fNPlanes;ip++) {
+ Int_t nphits=fPlanes[ip]->GetNScinHits();
+ TClonesArray* hodoHits = fPlanes[ip]->GetHits();
+ for(Int_t i=0;i<nphits;i++) {
+ Double_t tmin = 0.5*binmax;
+ if ((time_pos[ihit]>tmin) && (time_pos[ihit]<tmin+fTofTolerance) &&
+ (time_neg[ihit]>tmin) && (time_neg[ihit]<tmin+fTofTolerance)) {
+ // Both tubes fired
+ Int_t index=((THcHodoHit*)hodoHits->At(i))->GetPaddleNumber()-1;
+ Double_t fptime = ((THcHodoHit*)hodoHits->At(i))->GetScinCorrectedTime()
+ - (fPlanes[ip]->GetZpos()+(index%2)*fPlanes[ip]->GetDzpos())
+ / (29.979 * fBetaNominal);
+ if(TMath::Abs(fptime-fStartTimeCenter)<=fStartTimeSlop) {
+ // Should also fill the all FP times histogram
+ fpTimeSum += fptime;
+ fNfptimes++;
+ }
+ }
+ }
+ ihit++;
+ }
+ if(fNfptimes>0) {
+ fStartTime = fpTimeSum/fNfptimes;
+ fGoodStartTime=kTRUE;
+ } else {
+ fStartTime = fStartTimeCenter;
+ fGoodStartTime=kFALSE;
+ }
+}
//_____________________________________________________________________________
Int_t THcHodoscope::ApplyCorrections( void )
{
diff --git a/src/THcHodoscope.h b/src/THcHodoscope.h
index a72b32e01d5742285f080ab6ed16b4be4349a43b..8ce1b92e38256106ef6ddc1a55bbfb68b015b645 100644
--- a/src/THcHodoscope.h
+++ b/src/THcHodoscope.h
@@ -46,6 +46,7 @@ public:
virtual Int_t CoarseProcess( TClonesArray& tracks );
virtual Int_t FineProcess( TClonesArray& tracks );
+ void EstimateFocalPlaneTime(void);
virtual Int_t ApplyCorrections( void );
Double_t GetStartTime() const { return fStartTime; }
Bool_t IsStartTimeGood() const {return fGoodStartTime;};
diff --git a/src/THcScintillatorPlane.cxx b/src/THcScintillatorPlane.cxx
index 891f1f374253ef3ae845e4683b801b61b9dfc731..d4163f5fb7092b2776d741f79eae34ac47fa5333 100644
--- a/src/THcScintillatorPlane.cxx
+++ b/src/THcScintillatorPlane.cxx
@@ -337,7 +337,23 @@ Int_t THcScintillatorPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
Double_t timec_neg = hit->fTDC_neg*fScinTdcToTime - fHodoNegPhcCoeff[index]*
TMath::Sqrt(TMath::Max(0.0,(hit->fADC_neg/fHodoNegMinPh[index]-1)))
- fHodoNegTimeOffset[index];
- ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetCorrectedTimes(timec_pos,timec_neg);
+
+ // Find hit position using ADCs
+ // If postime larger, then hit was nearer negative side.
+ Double_t dist_from_center=0.5*(timec_neg-timec_pos)*fHodoVelLight[index];
+ Double_t scint_center=0.5*(fPosLeft+fPosRight);
+ Double_t hit_position=scint_center+dist_from_center;
+ hit_position=TMath::Min(hit_position,fPosLeft);
+ hit_position=TMath::Max(hit_position,fPosRight);
+ Double_t postime=timec_pos-(fPosLeft-hit_position)/fHodoVelLight[index];
+ Double_t negtime=timec_neg-(hit_position-fPosRight)/fHodoVelLight[index];
+ Double_t scin_corrected_time = 0.5*(postime+negtime);
+ postime = postime-(fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
+ negtime = postime-(fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
+
+ ((THcHodoHit*) fHodoHits->At(fNScinHits))->SetCorrectedTimes(timec_pos,timec_neg,
+ postime, negtime,
+ scin_corrected_time);
fNScinHits++;
}
else {
@@ -349,113 +365,7 @@ Int_t THcScintillatorPlane::ProcessHits(TClonesArray* rawhits, Int_t nexthit)
return(ihit);
}
-//________________________________________________________________________________
-
-Int_t THcScintillatorPlane::EstimateFocalPlaneTimes()
-{
- // Perform pulse height correction of the TDC values as in the original h_trans_scin
- // see original comments below
- /*! Calculate all corrected hit times and histogram
- ! This uses a copy of code below. Results are save in time_pos,neg
- ! including the z-pos. correction assuming nominal value of betap
- ! Code is currently hard-wired to look for a peak in the
- ! range of 0 to 100 nsec, with a group of times that all
- ! agree withing a time_tolerance of time_tolerance nsec. The normal
- ! peak position appears to be around 35 nsec (SOS0 or 31 nsec (HMS)
- ! NOTE: if want to find particles with beta different than
- ! reference particle, need to make sure this is big enough
- ! to accomodate difference in TOF for other particles
- ! Default value in case user hasn't defined something reasonable */
- Double_t scin_corrected_time[53]; // the 53 should go in a param file (was hmax_scin_hits originally)
- // Bool_t keep_pos[53],keep_neg[53]; // are these all really needed?
- Bool_t two_good_times[53];
- Double_t dist_from_center,scint_center,hit_position,time_pos[100],time_neg[100];
- Int_t timehist[200]; // This seems as a pretty old-fashioned way of doing things. Is there a better way?
-
-
- // protect against spam events
- if (fNScinHits>1000) {
- cout <<"Too many hits "<<fNScinHits<<" in this event! Skipping!\n";
- return -1;
- }
- // zero out histogram
- for (Int_t i=0;i<200;i++) {
- timehist[i]=0;
- }
- fpTime=-1e5;
- for (Int_t i=0;i<fNScinHits;i++) {
- Int_t index=((THcHodoHit*)fHodoHits->At(i))->GetPaddleNumber()-1;
-
- Double_t postime=((THcHodoHit*) fHodoHits->At(i))->GetPosCorrectedTime();
- Double_t negtime=((THcHodoHit*) fHodoHits->At(i))->GetNegCorrectedTime();
-
- // Find hit position. If postime larger, then hit was nearer negative side.
- dist_from_center=0.5*(negtime-postime)*fHodoVelLight[index];
- scint_center=0.5*(fPosLeft+fPosRight);
- hit_position=scint_center+dist_from_center;
- hit_position=TMath::Min(hit_position,fPosLeft);
- hit_position=TMath::Max(hit_position,fPosRight);
- postime=postime-(fPosLeft-hit_position)/fHodoVelLight[index];
- negtime=negtime-(hit_position-fPosRight)/fHodoVelLight[index];
- scin_corrected_time[i]=0.5*(postime+negtime);
-
- time_pos[i]=postime-(fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
- time_neg[i]=negtime-(fZpos+(index%2)*fDzpos)/(29.979*fBetaNominal);
- // nfound++;
- for (Int_t k=0;k<200;k++) {
- Double_t tmin=0.5*(k+1);
- if ((time_pos[i]> tmin) && (time_pos[i] < tmin+fTofTolerance)) {
- timehist[k]++;
- }
- if ((time_neg[i]> tmin) && (time_neg[i] < tmin+fTofTolerance)) {
- timehist[k]++;
- }
- }
- }
- // Find the bin with most hits
- Int_t jmax=0;
- Int_t maxhit=0;
- for (Int_t i=0;i<200;i++) {
- if (timehist[i]>maxhit) {
- jmax=i;
- maxhit=timehist[i];
- // cout << " i = " << i << " " << jmax << " " << timehist[i] << endl;
- }
- }
- // cout << " jmax = " << jmax << " " << maxhit << endl;
- // Resume regular tof code, now using time filer(?) from above
- // Check for TWO good TDC hits
- for (Int_t i=0;i<fNScinHits;i++) {
- Double_t tmin = 0.5*jmax;
- if ((time_pos[i]>tmin) && (time_pos[i]<tmin+fTofTolerance) &&
- (time_neg[i]>tmin) && (time_neg[i]<tmin+fTofTolerance)) {
- two_good_times[i]=kTRUE;
- } else {
- two_good_times[i]=kFALSE;
- scin_corrected_time[i]=0.0; // not a very good "flag" but there is the logical two_good_hits...
- }
- } // end of loop that finds tube setting time
-
- //start time calculation. assume xp=yp=0 radians. project all
- //time values to focal plane. use average for start time.
-
- fNScinGoodHits=0;
- for (Int_t i=0;i<fNScinHits;i++) {
- Int_t j=((THcHodoHit*)fHodoHits->At(i))->GetPaddleNumber()-1;
- if (two_good_times[i]) { // both tubes fired
- fpTimes[fNScinGoodHits]=scin_corrected_time[i]-(fZpos+(j%2)*fDzpos)/(29.979*fBetaNominal);
- fScinTime[fNScinGoodHits]=scin_corrected_time[i];
- // Should we precompute these
- fScinSigma[fNScinGoodHits]=fHodoSigma[j];
- fScinZpos[fNScinGoodHits]=fZpos+(j%2)*fDzpos; // see comment above
- // h_rfptime(hscin_plane_num(ihit))=fptime
- fNScinGoodHits++; // increment the number of good hits
- }
- }
- CalcFpTime();
- return 0;
- }
//_____________________________________________________________________________
Int_t THcScintillatorPlane::AccumulatePedestals(TClonesArray* rawhits, Int_t nexthit)
{
diff --git a/src/THcScintillatorPlane.h b/src/THcScintillatorPlane.h
index 0e45a5034e31700b5fb12f57dcfdef87c328c716..1ef42cba2485bc2e586c3f869a12d97c0ecc3a23 100644
--- a/src/THcScintillatorPlane.h
+++ b/src/THcScintillatorPlane.h
@@ -35,7 +35,6 @@ class THcScintillatorPlane : public THaSubDetector {
virtual Bool_t IsPid() { return kFALSE; }
virtual Int_t ProcessHits(TClonesArray* rawhits, Int_t nexthit);
- virtual Int_t EstimateFocalPlaneTimes();
virtual Int_t AccumulatePedestals(TClonesArray* rawhits, Int_t nexthit);
virtual void CalculatePedestals( );