//_____________________________________________________________________________ Int_t Gmp_Raster::Decode( const THaEvData& evdata ) { // clears the event structure // loops over all modules defined in the detector map // copies raw data into local variables // pedestal subtraction is not foreseen for the raster ClearEvent(); UInt_t chancnt = 0; Int_t chan = 0; Int_t data = 0; Int_t k = 0; for (Int_t i = 0; i < fDetMap->GetSize(); i++ ){ THaDetMap::Module* d = fDetMap->GetModule( i ); for (Int_t j=0; j< evdata.GetNumChan( d->crate, d->slot ); j++) { chan = evdata.GetNextChan( d->crate, d->slot, j); if ((chan>=d->lo)&&(chan<=d->hi)) { data = evdata.GetData( d->crate, d->slot, chan, 0 ); k = chancnt+d->first + chan - d->lo -1; if (k<2) { fRawPos(k)= data; fNfired++; } else if (k<4) { fRawSlope(k-2)= data; fNfired++; } else { Warning( Here("Decode()"), "Illegal detector channel: %d", k ); } } } chancnt+=d->hi-d->lo+1; } if (fNfired!=4) { Warning( Here("Decode()"), "Number of fired Channels out of range. Setting beam position to nominal values"); } return 0; }
//_____________________________________________________________________________ Int_t THaBPM::Decode( const THaEvData& evdata ) { // clears the event structure // loops over all modules defined in the detector map // copies raw data into local variables // performs pedestal subtraction const char* const here = "Decode()"; for (Int_t i = 0; i < fDetMap->GetSize(); i++ ){ THaDetMap::Module* d = fDetMap->GetModule( i ); for (Int_t j=0; j< evdata.GetNumChan( d->crate, d->slot ); j++) { Int_t chan = evdata.GetNextChan( d->crate, d->slot, j); if ((chan>=d->lo)&&(chan<=d->hi)) { Int_t data = evdata.GetData( d->crate, d->slot, chan, 0 ); UInt_t k = d->first + chan - d->lo -1; if ((k<NCHAN)&&(fRawSignal(k)==-1)) { fRawSignal(k)= data; fNfired++; } else { Warning( Here(here), "Illegal detector channel: %d", k ); } } } } if (fNfired!=NCHAN) { Warning( Here(here), "Number of fired Channels out of range. " "Setting beam position to nominal values"); } else { fCorSignal=fRawSignal; fCorSignal-=fPedestals; } return 0; }
//_____________________________________________________________________________ Int_t THaScintillator::Decode( const THaEvData& evdata ) { // Decode scintillator data, correct TDC times and ADC amplitudes, and copy // the data to the local data members. // This implementation makes the following assumptions about the detector map: // - The first half of the map entries corresponds to ADCs, // the second half, to TDCs. // - The first fNelem detector channels correspond to the PMTs on the // right hand side, the next fNelem channels, to the left hand side. // (Thus channel numbering for each module must be consecutive.) // Loop over all modules defined for this detector for( Int_t i = 0; i < fDetMap->GetSize(); i++ ) { THaDetMap::Module* d = fDetMap->GetModule( i ); bool adc = ( d->model ? fDetMap->IsADC(d) : (i < fDetMap->GetSize()/2) ); // Loop over all channels that have a hit. for( Int_t j = 0; j < evdata.GetNumChan( d->crate, d->slot ); j++) { Int_t chan = evdata.GetNextChan( d->crate, d->slot, j ); if( chan < d->lo || chan > d->hi ) continue; // Not one of my channels #ifdef WITH_DEBUG Int_t nhit = evdata.GetNumHits(d->crate, d->slot, chan); if( nhit > 1 ) if (d->model != 250) Warning( Here("Decode"), "%d hits on %s channel %d/%d/%d", nhit, adc ? "ADC" : "TDC", d->crate, d->slot, chan ); #endif // Get the data. Scintillators are assumed to have only single hit (hit=0) Int_t data = evdata.GetData( d->crate, d->slot, chan, 0 ); // Get the detector channel number, starting at 0 Int_t k = d->first + chan - d->lo - 1; #ifdef WITH_DEBUG if( k<0 || k>NDEST*fNelem ) { // Indicates bad database Warning( Here("Decode()"), "Illegal detector channel: %d", k ); continue; } // cout << "adc,j,k = " <<adc<<","<<j<< ","<<k<< endl; #endif // Copy the data to the local variables. DataDest* dest = fDataDest + k/fNelem; k = k % fNelem; if( adc ) { dest->adc[k] = static_cast<Double_t>( data ); dest->adc_p[k] = data - dest->ped[k]; dest->adc_c[k] = dest->adc_p[k] * dest->gain[k]; (*dest->nahit)++; } else { dest->tdc[k] = static_cast<Double_t>( data ); dest->tdc_c[k] = (data - dest->offset[k])*fTdc2T; (*dest->nthit)++; } } } if ( fDebug > 3 ) { printf("\n\nEvent %d Trigger %d Scintillator %s\n:", evdata.GetEvNum(), evdata.GetEvType(), GetPrefix() ); printf(" paddle Left(TDC ADC ADC_p) Right(TDC ADC ADC_p)\n"); for ( int i=0; i<fNelem; i++ ) { printf(" %2d %5.0f %5.0f %5.0f %5.0f %5.0f %5.0f\n", i+1,fLT[i],fLA[i],fLA_p[i],fRT[i],fRA[i],fRA_p[i]); } } return fLTNhit+fRTNhit; }
//_____________________________________________________________________________ Int_t THaShower::Decode( const THaEvData& evdata ) { // Decode shower data, scale the data to energy deposition // ( in MeV ), and copy the data into the following local data structure: // // fNhits - Number of hits on shower; // fA[] - Array of ADC values of shower blocks; // fA_p[] - Array of ADC minus ped values of shower blocks; // fA_c[] - Array of corrected ADC values of shower blocks; // fAsum_p - Sum of shower blocks ADC minus pedestal values; // fAsum_c - Sum of shower blocks corrected ADC values; // Loop over all modules defined for shower detector for( UShort_t i = 0; i < fDetMap->GetSize(); i++ ) { THaDetMap::Module* d = fDetMap->GetModule( i ); // Loop over all channels that have a hit. for( Int_t j = 0; j < evdata.GetNumChan( d->crate, d->slot ); j++) { Int_t chan = evdata.GetNextChan( d->crate, d->slot, j ); if( chan > d->hi || chan < d->lo ) continue; // Not one of my channels. // Get the data. shower blocks are assumed to have only single hit (hit=0) Int_t data = evdata.GetData( d->crate, d->slot, chan, 0 ); // Copy the data to the local variables. Int_t k = *(*(fChanMap+i)+(chan-d->lo)) - 1; #ifdef WITH_DEBUG if( k<0 || k>=fNelem ) Warning( Here("Decode()"), "Bad array index: %d. Your channel map is " "invalid. Data skipped.", k ); else #endif { fA[k] = data; // ADC value fA_p[k] = data - fPed[k]; // ADC minus ped fA_c[k] = fA_p[k] * fGain[k]; // ADC corrected if( fA_p[k] > 0.0 ) fAsum_p += fA_p[k]; // Sum of ADC minus ped if( fA_c[k] > 0.0 ) fAsum_c += fA_c[k]; // Sum of ADC corrected fNhits++; } } } if ( fDebug > 3 ) { printf("\nShower Detector %s:\n",GetPrefix()); int ncol=3; for (int i=0; i<ncol; i++) { printf(" Block ADC ADC_p "); } printf("\n"); for (int i=0; i<(fNelem+ncol-1)/ncol; i++ ) { for (int c=0; c<ncol; c++) { int ind = c*fNelem/ncol+i; if (ind < fNelem) { printf(" %3d %5.0f %5.0f ",ind+1,fA[ind],fA_p[ind]); } else { // printf("\n"); break; } } printf("\n"); } } return fNhits; }
//_____________________________________________________________________________ Int_t THaVDCPlane::Decode( const THaEvData& evData ) { // Converts the raw data into hit information // Logical wire numbers a defined by the detector map. Wire number 0 // corresponds to the first defined channel, etc. // TODO: Support "reversed" detector map modules a la MWDC if (!evData.IsPhysicsTrigger()) return -1; // the event's T0-shift, due to the trigger-type // only an issue when adding in un-retimed trigger types Double_t evtT0=0; if ( fglTrg && fglTrg->Decode(evData)==kOK ) evtT0 = fglTrg->TimeOffset(); Int_t nextHit = 0; bool only_fastest_hit = false, no_negative = false; if( fVDC ) { // If true, add only the first (earliest) hit for each wire only_fastest_hit = fVDC->TestBit(THaVDC::kOnlyFastest); // If true, ignore negative drift times completely no_negative = fVDC->TestBit(THaVDC::kIgnoreNegDrift); } // Loop over all detector modules for this wire plane for (Int_t i = 0; i < fDetMap->GetSize(); i++) { THaDetMap::Module * d = fDetMap->GetModule(i); // Get number of channels with hits Int_t nChan = evData.GetNumChan(d->crate, d->slot); for (Int_t chNdx = 0; chNdx < nChan; chNdx++) { // Use channel index to loop through channels that have hits Int_t chan = evData.GetNextChan(d->crate, d->slot, chNdx); if (chan < d->lo || chan > d->hi) continue; //Not part of this detector // Wire numbers and channels go in the same order ... Int_t wireNum = d->first + chan - d->lo; THaVDCWire* wire = GetWire(wireNum); if( !wire || wire->GetFlag() != 0 ) continue; // Get number of hits for this channel and loop through hits Int_t nHits = evData.GetNumHits(d->crate, d->slot, chan); Int_t max_data = -1; Double_t toff = wire->GetTOffset(); for (Int_t hit = 0; hit < nHits; hit++) { // Now get the TDC data for this hit Int_t data = evData.GetData(d->crate, d->slot, chan, hit); // Convert the TDC value to the drift time. // Being perfectionist, we apply a 1/2 channel correction to the raw // TDC data to compensate for the fact that the TDC truncates, not // rounds, the data. Double_t xdata = static_cast<Double_t>(data) + 0.5; Double_t time = fTDCRes * (toff - xdata) - evtT0; // If requested, ignore hits with negative drift times // (due to noise or miscalibration). Use with care. // If only fastest hit requested, find maximum TDC value and record the // hit after the hit loop is done (see below). // Otherwise just record all hits. if( !no_negative || time > 0.0 ) { if( only_fastest_hit ) { if( data > max_data ) max_data = data; } else new( (*fHits)[nextHit++] ) THaVDCHit( wire, data, time ); } // Count all hits and wires with hits // fNWiresHit++; } // End hit loop // If we are only interested in the hit with the largest TDC value // (shortest drift time), it is recorded here. if( only_fastest_hit && max_data>0 ) { Double_t xdata = static_cast<Double_t>(max_data) + 0.5; Double_t time = fTDCRes * (toff - xdata) - evtT0; new( (*fHits)[nextHit++] ) THaVDCHit( wire, max_data, time ); } } // End channel index loop } // End slot loop // Sort the hits in order of increasing wire number and (for the same wire // number) increasing time (NOT rawtime) fHits->Sort(); if ( fDebug > 3 ) { printf("\nVDC %s:\n",GetPrefix()); int ncol=4; for (int i=0; i<ncol; i++) { printf(" Wire TDC "); } printf("\n"); for (int i=0; i<(nextHit+ncol-1)/ncol; i++ ) { for (int c=0; c<ncol; c++) { int ind = c*nextHit/ncol+i; if (ind < nextHit) { THaVDCHit* hit = static_cast<THaVDCHit*>(fHits->At(ind)); printf(" %3d %5d ",hit->GetWireNum(),hit->GetRawTime()); } else { // printf("\n"); break; } } printf("\n"); } } return 0; }