diff --git a/examples/PARAM/hcana.param b/examples/PARAM/hcana.param
index 47b4766b5526cbf1fd9f0da9393347d6fe98188a..e437cdfb4e56c3aa9468c98c6eec7e5e5b970938 100644
--- a/examples/PARAM/hcana.param
+++ b/examples/PARAM/hcana.param
@@ -77,3 +77,7 @@ sdc_fix_lr = 0
# If 1, don't do the the propagation along the wire each time the hit
# appears in a space point. (Which means the correction accumulates)
sdc_fix_propcorr = 0
+
+# Total number of PMTs in Gas Cherenkov detector.
+hcer_tot_pmts = 2
+
diff --git a/src/THcCherenkov.cxx b/src/THcCherenkov.cxx
index 5587a54c3a50baaa1a4e345c350cea433e37cb35..fe32f7eb2c632abe31bedaabe08708f03915b69c 100644
--- a/src/THcCherenkov.cxx
+++ b/src/THcCherenkov.cxx
@@ -4,14 +4,7 @@
// //
// Class for an Cherenkov detector consisting of onw pair of PMT's //
// //
-// Zafar Ahmed. Updated on December 24 2013. //
-// Four more variables are added. //
-// //
-// npe Total Number of photo electrons //
-// hit_1 Total hits in adc 1 //
-// hit_2 Total hits in adc 2 //
-// hit Total hits in adc 1 and 2 //
-// //
+// Zafar Ahmed. Second attempt. November 14 2013. //
// Comment:No need to cahnge the Map file but may need to change the parameter file //
// //
// This code is written for following variables: //
@@ -65,9 +58,8 @@ THcCherenkov::THcCherenkov( const char* name, const char* description,
THaNonTrackingDetector(name,description,apparatus)
{
// Normal constructor with name and description
- fPosADCHits = new TClonesArray("THcSignalHit",16);
+ fADCHits = new TClonesArray("THcSignalHit",16);
-// fTrackProj = new TClonesArray( "THaTrackProj", 5 );
}
//_____________________________________________________________________________
@@ -81,9 +73,15 @@ THcCherenkov::THcCherenkov( ) :
THcCherenkov::~THcCherenkov()
{
// Destructor
- delete [] fPosGain;
- delete [] fPosPedLimit;
- delete [] fPosPedMean;
+ delete [] fNPMT;
+ delete [] fADC;
+ delete [] fADC_P;
+ delete [] fNPE;
+
+ delete [] fCerWidth;
+ delete [] fGain;
+ delete [] fPedLimit;
+ delete [] fPedMean;
}
//_____________________________________________________________________________
@@ -121,21 +119,34 @@ Int_t THcCherenkov::ReadDatabase( const TDatime& date )
cout << "THcCherenkov::ReadDatabase " << GetName() << endl; // Ahmed
char prefix[2];
+ char parname[100];
prefix[0]=tolower(GetApparatus()->GetName()[0]);
prefix[1]='\0';
- fNelem = 2; // Default if not defined
-
- fPosGain = new Double_t[fNelem];
- fPosPedLimit = new Int_t[fNelem];
- fPosPedMean = new Double_t[fNelem];
+ strcpy(parname,prefix); // This is taken from
+ strcat(parname,"cer_tot_pmts"); // THcScintillatorPlane
+ fNelem = (Int_t)gHcParms->Find(parname)->GetValue(); // class.
+
+ // fNelem = 2; // Default if not defined
+
+ fNPMT = new Int_t[fNelem];
+ fADC = new Double_t[fNelem];
+ fADC_P = new Double_t[fNelem];
+ fNPE = new Double_t[fNelem];
+
+ fCerWidth = new Double_t[fNelem];
+ fGain = new Double_t[fNelem];
+ fPedLimit = new Int_t[fNelem];
+ fPedMean = new Double_t[fNelem];
DBRequest list[]={
- {"cer_adc_to_npe", fPosGain, kDouble, fNelem}, // Ahmed
- {"cer_ped_limit", fPosPedLimit, kInt, fNelem}, // Ahmed
+ {"cer_adc_to_npe", fGain, kDouble, fNelem}, // Ahmed
+ {"cer_ped_limit", fPedLimit, kInt, fNelem}, // Ahmed
+ {"cer_width", fCerWidth, kDouble, fNelem}, // Ahmed
{0}
};
+
gHcParms->LoadParmValues((DBRequest*)&list,prefix);
fIsInit = true;
@@ -162,17 +173,12 @@ Int_t THcCherenkov::DefineVariables( EMode mode )
// No. They show up in tree as Ndata.H.aero.postdchits for example
RVarDef vars[] = {
- {"adc_1", "Raw First ADC Amplitude", "fA_1"},
- {"adc_2", "Raw Second ADC Amplitude", "fA_2"},
- {"adc_p_1", "Pedestal Subtracted First ADC Amplitude", "fA_p_1"},
- {"adc_p_2", "Pedestal Subtracted Second ADC Amplitude", "fA_p_2"},
- {"npe_1", "PEs of First Tube", "fNpe_1"},
- {"npe_2", "PEs of Second Tube", "fNpe_2"},
- {"npe", "Total number of PEs", "fNpe"},
- {"hit_1", "ADC hits First Tube", "fNHits_1"},
- {"hit_2", "ADC hits Second Tube", "fNHits_2"},
- {"hit", "Total ADC hits", "fNHits"},
- {"posadchits", "List of Positive ADC hits","fPosADCHits.THcSignalHit.GetPaddleNumber()"},
+ {"PhotoTubes", "Nuber of Cherenkov photo tubes", "fNPMT"},
+ {"ADC", "Raw ADC values", "fADC"},
+ {"ADC_P", "Pedestal Subtracted ADC values", "fADC_P"},
+ {"NPE", "Number of Photo electrons", "fNPE"},
+ {"NPEsum", "Sum of Number of Photo electrons", "fNPEsum"},
+ {"NCherHit", "Number of Hits(Cherenkov)", "fNCherHit"},
{ 0 }
};
@@ -183,22 +189,20 @@ inline
void THcCherenkov::Clear(Option_t* opt)
{
// Clear the hit lists
- fPosADCHits->Clear();
+ fADCHits->Clear();
// Clear Cherenkov variables from h_trans_cer.f
fNhits = 0; // Don't really need to do this. (Be sure this called before Decode)
-
- fA_1 = 0;
- fA_2 = 0;
- fA_p_1 = 0;
- fA_p_2 = 0;
- fNpe_1 = 0;
- fNpe_2 = 0;
- fNpe = 0;
- fNHits_1 = 0;
- fNHits_2 = 0;
- fNHits = 0;
+ fNPEsum = 0;
+ fNCherHit = 0;
+
+ for(Int_t itube = 0;itube < fNelem;itube++) {
+ fNPMT[itube] = 0;
+ fADC[itube] = 0;
+ fADC_P[itube] = 0;
+ fNPE[itube] = 0;
+ }
}
@@ -209,29 +213,25 @@ Int_t THcCherenkov::Decode( const THaEvData& evdata )
fNhits = DecodeToHitList(evdata);
if(gHaCuts->Result("Pedestal_event")) {
-
AccumulatePedestals(fRawHitList);
-
fAnalyzePedestals = 1; // Analyze pedestals first normal events
return(0);
}
if(fAnalyzePedestals) {
-
CalculatePedestals();
-
fAnalyzePedestals = 0; // Don't analyze pedestals next event
}
Int_t ihit = 0;
- Int_t nPosADCHits=0;
+ Int_t nADCHits=0;
while(ihit < fNhits) {
THcCherenkovHit* hit = (THcCherenkovHit *) fRawHitList->At(ihit);
- // ADC positive hit
+ // ADC hit
if(hit->fADC_pos > 0) {
- THcSignalHit *sighit = (THcSignalHit*) fPosADCHits->ConstructedAt(nPosADCHits++);
+ THcSignalHit *sighit = (THcSignalHit*) fADCHits->ConstructedAt(nADCHits++);
sighit->Set(hit->fCounter, hit->fADC_pos);
}
@@ -274,7 +274,6 @@ Int_t THcCherenkov::CoarseProcess( TClonesArray& ) //tracks
enddo
------------------------------------------------------------------------------------------------------------------
*/
-
for(Int_t ihit=0; ihit < fNhits; ihit++) {
THcCherenkovHit* hit = (THcCherenkovHit *) fRawHitList->At(ihit); // nhit = 1, hcer_tot_hits
@@ -291,42 +290,21 @@ Int_t THcCherenkov::CoarseProcess( TClonesArray& ) //tracks
if ( ihit != npmt )
cout << "ihit != npmt " << endl;
- if ( npmt == 0 ) {
- fA_1 = hit->fADC_pos;
- fA_p_1 = hit->fADC_pos - fPosPedMean[npmt];
- if ( ( fA_p_1 > 50 ) && ( hit->fADC_pos < 8000 ) ) {
- fNpe_1 = fPosGain[npmt]*fA_p_1;
- fNHits_1 ++;
- } else if ( hit->fADC_pos > 8000 ) {
- fNpe_1 = 100.0;
- } else {
- fNpe_1 = 0.0;
- }
- }
-
- if ( npmt == 1 ) {
- fA_2 = hit->fADC_pos;
- fA_p_2 = hit->fADC_pos - fPosPedMean[npmt];
- if ( ( fA_p_2 > 50 ) && ( hit->fADC_pos < 8000 ) ) {
- fNpe_2 = fPosGain[npmt]*fA_p_2;
- fNHits_2 ++;
- } else if ( hit->fADC_pos > 8000 ) {
- fNpe_2 = 100.0;
- } else {
- fNpe_2 = 0.0;
- }
- }
-
- if ( npmt == 0 ) {
- fNpe += fNpe_1;
- fNHits += fNHits_1;
- }
+ fNPMT[npmt] = hit->fCounter;
+ fADC[npmt] = hit->fADC_pos;
+ fADC_P[npmt] = hit->fADC_pos - fPedMean[npmt];
- if ( npmt == 1 ) {
- fNpe += fNpe_2;
- fNHits += fNHits_2;
+ if ( ( fADC_P[npmt] > fCerWidth[npmt] ) && ( hit->fADC_pos < 8000 ) ) {
+ fNPE[npmt] = fGain[npmt]*fADC_P[npmt];
+ fNCherHit ++;
+ } else if ( hit->fADC_pos > 8000 ) {
+ fNPE[npmt] = 100.0;
+ } else {
+ fNPE[npmt] = 0.0;
}
+ fNPEsum += fNPE[npmt];
+
}
ApplyCorrections();
@@ -346,18 +324,16 @@ void THcCherenkov::InitializePedestals( )
{
fNPedestalEvents = 0;
fMinPeds = 500; // In engine, this is set in parameter file
- fPosPedSum = new Int_t [fNelem];
- fPosPedSum2 = new Int_t [fNelem];
- fPosPedLimit = new Int_t [fNelem];
- fPosPedCount = new Int_t [fNelem];
+ fPedSum = new Int_t [fNelem];
+ fPedSum2 = new Int_t [fNelem];
+ fPedCount = new Int_t [fNelem];
- fPosPed = new Double_t [fNelem];
- fPosThresh = new Double_t [fNelem];
+ fPed = new Double_t [fNelem];
+ fThresh = new Double_t [fNelem];
for(Int_t i=0;i<fNelem;i++) {
- fPosPedSum[i] = 0;
- fPosPedSum2[i] = 0;
- fPosPedLimit[i] = 1000; // In engine, this are set in parameter file
- fPosPedCount[i] = 0;
+ fPedSum[i] = 0;
+ fPedSum2[i] = 0;
+ fPedCount[i] = 0;
}
}
@@ -375,13 +351,13 @@ void THcCherenkov::AccumulatePedestals(TClonesArray* rawhits)
THcCherenkovHit* hit = (THcCherenkovHit *) rawhits->At(ihit);
Int_t element = hit->fCounter - 1;
- Int_t adcpos = hit->fADC_pos;
- if(adcpos <= fPosPedLimit[element]) {
- fPosPedSum[element] += adcpos;
- fPosPedSum2[element] += adcpos*adcpos;
- fPosPedCount[element]++;
- if(fPosPedCount[element] == fMinPeds/5) {
- fPosPedLimit[element] = 100 + fPosPedSum[element]/fPosPedCount[element];
+ Int_t nadc = hit->fADC_pos;
+ if(nadc <= fPedLimit[element]) {
+ fPedSum[element] += nadc;
+ fPedSum2[element] += nadc*nadc;
+ fPedCount[element]++;
+ if(fPedCount[element] == fMinPeds/5) {
+ fPedLimit[element] = 100 + fPedSum[element]/fPedCount[element];
}
}
ihit++;
@@ -400,19 +376,17 @@ void THcCherenkov::CalculatePedestals( )
// cout << "Plane: " << fPlaneNum << endl;
for(Int_t i=0; i<fNelem;i++) {
- // Positive tubes
- fPosPed[i] = ((Double_t) fPosPedSum[i]) / TMath::Max(1, fPosPedCount[i]);
- fPosThresh[i] = fPosPed[i] + 15;
-
- // cout << i+1 << " " << fPosPed[i] << " " << fNegPed[i] << endl;
+ // PMT tubes
+ fPed[i] = ((Double_t) fPedSum[i]) / TMath::Max(1, fPedCount[i]);
+ fThresh[i] = fPed[i] + 15;
// Just a copy for now, but allow the possibility that fXXXPedMean is set
// in a parameter file and only overwritten if there is a sufficient number of
// pedestal events. (So that pedestals are sensible even if the pedestal events were
// not acquired.)
if(fMinPeds > 0) {
- if(fPosPedCount[i] > fMinPeds) {
- fPosPedMean[i] = fPosPed[i];
+ if(fPedCount[i] > fMinPeds) {
+ fPedMean[i] = fPed[i];
}
}
}
@@ -428,9 +402,9 @@ void THcCherenkov::Print( const Option_t* opt) const {
cout << "Cherenkov Pedestals" << endl;
// Ahmed
- cout << "No. Pos" << endl;
+ cout << "No. ADC" << endl;
for(Int_t i=0; i<fNelem; i++){
- cout << " " << i << " " << fPosPed[i] << endl;
+ cout << " " << i << " " << fPed[i] << endl;
}
cout << endl;
diff --git a/src/THcCherenkov.h b/src/THcCherenkov.h
index 4040a56e54056154d27831e17dd32c1e4e026c10..3196321072bab83b612f6ba02603384c6935b5dc 100644
--- a/src/THcCherenkov.h
+++ b/src/THcCherenkov.h
@@ -36,78 +36,39 @@ class THcCherenkov : public THaNonTrackingDetector, public THcHitList {
THcCherenkov(); // for ROOT I/O
protected:
- Int_t fAnalyzePedestals;
+ Int_t fAnalyzePedestals;
// Parameters
- Double_t* fPosGain;
- Double_t* fNegGain;
+ Double_t* fGain;
+ Double_t* fCerWidth;
// Event information
- Int_t fNhits;
-
- Float_t* fA_Pos; // [fNelem] Array of ADC amplitudes
- Float_t* fA_Neg; // [fNelem] Array of ADC amplitudes
- Float_t* fA_Pos_p; // [fNelem] Array of ped-subtracted ADC amplitudes
- Float_t* fA_Neg_p; // [fNelem] Array of ped-subtracted ADC amplitudes
- Float_t* fT_Pos; // [fNelem] Array of TDCs
- Float_t* fT_Neg; // [fNelem] Array of TDCs
-
- Double_t fA_1; // Ahmed
- Double_t fA_2; // Ahmed
- Double_t fNHits_1; // Ahmed
- Double_t fNHits_2; // Ahmed
- Double_t fNHits; // Ahmed
- Double_t fA_p_1; // Ahmed
- Double_t fA_p_2; // Ahmed
- Double_t fNpe_1; // Ahmed
- Double_t fNpe_2; // Ahmed
- Double_t fNpe; // Ahmed
-
- Double_t fPosNpeSum;
- Double_t fNegNpeSum;
- Double_t fNpeSum;
- Int_t fNGoodHits;
- Int_t fNADCPosHits;
- Int_t fNADCNegHits;
- Int_t fNTDCPosHits;
- Int_t fNTDCNegHits;
-
- Double_t* fPosNpe; // [fNelem] # Photoelectrons per positive tube
- Double_t* fNegNpe; // [fNelem] # Photoelectrons per negative tube
-
+ Int_t fNhits;
+ Int_t* fNPMT; // [fNelem] Array of ADC amplitudes
+ Double_t* fADC; // [fNelem] Array of ADC amplitudes
+ Double_t* fADC_P; // [fNelem] Array of ADC amplitudes
+ Double_t* fNPE; // [fNelem] Array of ADC amplitudes
+ Double_t fNPEsum; // [fNelem] Array of ADC amplitudes
+ Double_t fNCherHit; // [fNelem] Array of ADC amplitudes
// Hits
- TClonesArray* fPosTDCHits;
- TClonesArray* fNegTDCHits;
- TClonesArray* fPosADCHits;
- TClonesArray* fNegADCHits;
+ TClonesArray* fADCHits;
// Pedestals
- Int_t fNPedestalEvents;
- Int_t fMinPeds;
- Int_t *fPosPedSum; /* Accumulators for pedestals */
- Int_t *fPosPedSum2;
- Int_t *fPosPedLimit;
- Int_t *fPosPedCount;
- Int_t *fNegPedSum;
- Int_t *fNegPedSum2;
- Int_t *fNegPedLimit;
- Int_t *fNegPedCount;
-
- Double_t *fPosPed;
- Double_t *fPosSig;
- Double_t *fPosThresh;
- Double_t *fNegPed;
- Double_t *fNegSig;
- Double_t *fNegThresh;
-
- Double_t *fPosPedMean; /* Can be supplied in parameters and then */
- Double_t *fNegPedMean; /* be overwritten from ped analysis */
+ Int_t fNPedestalEvents;
+ Int_t fMinPeds;
+ Int_t* fPedSum; /* Accumulators for pedestals */
+ Int_t* fPedSum2;
+ Int_t* fPedLimit;
+ Double_t* fPedMean; /* Can be supplied in parameters and then */
+ Int_t* fPedCount;
+ Double_t* fPed;
+ Double_t* fThresh;
void Setup(const char* name, const char* description);
virtual void InitializePedestals( );
- ClassDef(THcCherenkov,0) // Generic cherenkov class
+ ClassDef(THcCherenkov,0) // Generic cherenkov class
};
#endif