//_____________________________________________________________________________
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;
}
