//_____________________________________________________________________________
void CrateLoc::Load( const THaEvData& evdata )
{
// Load one data word from crate/slot/chan address
if( evdata.GetNumHits(crate,slot,chan) > 0 ) {
data = evdata.GetData(crate,slot,chan,0);
}
}
//_____________________________________________________________________________
void CrateLocMulti::Load( const THaEvData& evdata )
{
// Load all decoded hits from crate/slot/chan address
data = 0;
for (Int_t i = 0; i < evdata.GetNumHits(crate,slot,chan); ++i) {
rdata.push_back( evdata.GetData(crate,slot,chan,i) );
}
}
int main(int argc, char* argv[])
{
if (argc < 2) {
cout << "You made a mistake... \n" << endl;
cout << "Usage: tdecex filename" << endl;
cout << " where 'filename' is the CODA file"<<endl;
cout << "\n... exiting." << endl;
exit(0);
}
TString filename = argv[1];
THaCodaFile datafile;
if (datafile.codaOpen(filename) != S_SUCCESS) {
cout << "ERROR: Cannot open CODA data" << endl;
cout << "Perhaps you mistyped it" << endl;
cout << "... exiting." << endl;
exit(0);
}
THaEvData *evdata = new THaCodaDecoder();
THaGenDetTest mydetector;
mydetector.init();
// Loop over a finite number of events
int NUMEVT=50000;
int ievent;
for (ievent=0; ievent<NUMEVT; ievent++) {
if ( ievent > 0 && (
( (ievent <= 1000) && ((ievent%100) == 0) ) ||
( (ievent > 1000) && ((ievent%1000) == 0) ) ) )
cout << "\n ---- Event " << ievent <<endl;
int status = datafile.codaRead();
if ( status != S_SUCCESS ) {
if ( status == EOF) {
cout << "This is end of file !" << endl;
cout << "... exiting " << endl;
goto Finish;
} else {
cout << hex << "ERROR: codaRread status = " << status << endl;
exit(0);
}
}
evdata->LoadEvent( datafile.getEvBuffer() );
mydetector.process_event(evdata);
} // end of event loop
Finish:
cout << "\n Finished processing " << ievent << " events " << endl;
}
//_____________________________________________________________________________
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 THaQWEAKHelicityReader::FindWord( const THaEvData& evdata,
const ROCinfo& info )
// find the index of the word we are looking for given a header
// or simply return the index already stored in ROC info (in that case
// the header stored in ROC info needs to be 0
{
Int_t len = evdata.GetRocLength(info.roc);
if (len <= 4)
return -1;
Int_t i;
if( info.header == 0 )
i = info.index;
else {
for( i=0; i<len &&
(evdata.GetRawData(info.roc, i) & 0xffff000) != info.header;
++i) {}
i += info.index;
}
return (i < len) ? i : -1;
}
Int_t THaScaler::LoadData(const THaEvData& evdata) {
// Load data from THaEvData object. Return of 0 is ok.
// Note: GetEvBuffer is no faster than evdata.Get...
static int ldebug = 0;
static Int_t data[2*SCAL_NUMBANK*SCAL_NUMCHAN+100];
new_load = kFALSE;
Int_t nlen = 0;
if (evstr_type == 1) { // data in the event stream (physics triggers)
if (!evdata.IsPhysicsTrigger()) return 0;
nlen = evdata.GetRocLength(crate);
if (nlen == 0) return 0;
} else { // traditional scaler event type 140
if (evdata.GetEvType() != 140) return 0;
nlen = evdata.GetEvLength();
}
if (ldebug) cout << "Loading evdata, bank = "<<bankgroup<<" "<<evstr_type<<" "<<crate<<" "<<evdata.GetEvType()<<" "<<nlen<<endl;
Int_t maxlen = sizeof(data)/sizeof(Int_t);
if (nlen > maxlen) nlen = maxlen;
for (Int_t i = 0; i < nlen; i++) {
if (evstr_type == 1) {
data[i] = evdata.GetRawData(crate, i);
} else {
data[i] = evdata.GetRawData(i);
}
if (ldebug) {
cout << " data["<<i<<"] = "<<data[i]<<" =0x"<<hex<<data[i]<<dec<<endl;
}
}
ExtractRaw(data,nlen);
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;
}
//_____________________________________________________________________________
void WordLoc::Load( const THaEvData& evdata )
{
// Load data at header/notoskip position from crate data buffer
typedef const UInt_t rawdata_t;
Int_t roclen = evdata.GetRocLength(crate);
if( roclen < ntoskip+1 ) return;
rawdata_t* cratebuf = evdata.GetRawDataBuffer(crate), *endp = cratebuf+roclen;
assert(cratebuf); // Must exist if roclen > 0
// Accelerated search for the header word. Coded explicitly because there
// is no "memstr" in the standard library.
//FIXME: Can this be made faster because each header is followed by the offset
// to the next header?
// Get the first byte of the header, regardless of byte order
int h = ((UChar_t*)&header)[0];
rawdata_t* p = cratebuf;
while( (p = (rawdata_t*)memchr(p,h,sizeof(rawdata_t)*(endp-p-1)+1)) &&
p <= endp-ntoskip-1 ) {
// The header must be aligned at a word boundary
int off = (p-cratebuf) & (sizeof(rawdata_t)-1); // same as % sizeof()
if( off != 0 ) {
p += sizeof(rawdata_t)-off;
continue;
}
// Compare all 4 bytes of the header word
if( memcmp(p,&header,sizeof(rawdata_t)) == 0 ) {
// Fetch the requested word (as UInt_t, i.e. 4 bytes)
// BTW, notoskip == 0 makes no sense since it would fetch the header itself
data = *(p+ntoskip);
break;
}
p += sizeof(rawdata_t);
}
}
int main(int argc, char* argv[])
{
if (argc < 2) {
cout << "You made a mistake... \n" << endl;
cout << "Usage: epicsd filename" << endl;
cout << " where 'filename' is the CODA file"<<endl;
cout << "\n... exiting." << endl;
exit(0);
}
TString filename = argv[1];
THaCodaFile datafile;
if (datafile.codaOpen(filename) != S_SUCCESS) {
cout << "ERROR: Cannot open CODA data" << endl;
cout << "Perhaps you mistyped it" << endl;
cout << "... exiting." << endl;
exit(0);
}
THaEvData *evdata = new THaCodaDecoder();
// Loop over a finite number of events
int NUMEVT=1000000;
for (int i=0; i<NUMEVT; i++) {
int status = datafile.codaRead();
if ( status != S_SUCCESS ) {
if ( status == EOF) {
cout << "This is end of file !" << endl;
cout << "... exiting " << endl;
exit(1);
} else {
cout << hex << "ERROR: codaRread status = " << status << endl;
exit(0);
}
}
evdata->LoadEvent( datafile.getEvBuffer() );
if(evdata->IsEpicsEvent()) {
cout << "Some epics data --> "<<endl;
cout << "hac_bcm_average "<<
evdata->GetEpicsData("hac_bcm_average")<<endl;
cout << "IPM1H04A.XPOS "<<
evdata->GetEpicsData("IPM1H04A.XPOS")<<endl;
cout << "IPM1H04A.YPOS "<<
evdata->GetEpicsData("IPM1H04A.YPOS")<<endl;
}
} // end of event loop
}
//_____________________________________________________________________________
Int_t THaVDC::Decode( const THaEvData& evdata )
{
// Decode data from VDC planes
#ifdef WITH_DEBUG
// Save current event number for diagnostics
fEvNum = evdata.GetEvNum();
if( fDebug>1 ) {
cout << "=========================================\n";
cout << "Event: " << fEvNum << endl;
}
#endif
fLower->Decode(evdata);
fUpper->Decode(evdata);
return 0;
}
int main(int argc, char* argv[])
{
int debug=0;
if (argc > 1) debug=1;
// CODA file "snippet.dat" is a disk file of CODA data.
THaCodaFile datafile; // We could also open the data using a
// different constructor:
// THaCodaFile datafile("snippet.dat");
TString filename("snippet.dat");
if (datafile.codaOpen(filename) != S_SUCCESS) {
cout << "ERROR: Cannot open CODA data" << endl;
exit(0);
}
THaEvData *evdata = new THaCodaDecoder();
// Loop over events
int NUMEVT=100;
int ievent;
for (ievent=0; ievent<NUMEVT; ievent++) {
int status = datafile.codaRead();
if ( status != S_SUCCESS ) {
if ( status == EOF) {
cout << "This is normal end of file. Goodbye !" << endl;
} else {
cout << hex << "ERROR: codaRread status = " << status << endl;
}
goto Finish;
}
// load_evbuffer() must be called each event before you access evdata contents.
// If you use the version of load_evbuffer() shown here,
// evdata uses its private crate map (recommended).
// Alternatively you could use load_evbuffer(int* evbuffer, haCrateMap& map)
evdata->LoadEvent( datafile.getEvBuffer() );
cout << "\nEvent type " << dec << evdata->GetEvType() << endl;
cout << "Event number " << evdata->GetEvNum() << endl;
cout << "Event length " << evdata->GetEvLength() << endl;
if (evdata->IsPhysicsTrigger() ) { // triggers 1-14
cout << "Physics trigger " << endl;
}
if(evdata->IsScalerEvent()) cout << "Scaler `event' " << endl;
// Now we want data from a particular crate and slot.
// E.g. crates are 1,2,3,13,14,15 (roc numbers), Slots are 1,2,3...
// This is like what one might do in a detector decode() routine.
int crate = 1; // for example
int slot = 24;
// Here are raw 32-bit CODA words for this crate and slot
cout << "Raw Data Dump for crate "<<dec<<crate<<" slot "<<slot<<endl;
int hit;
for(hit=0; hit<evdata->GetNumRaw(crate,slot); hit++) {
cout<<dec<<"raw["<<hit<<"] = ";
cout<<hex<<evdata->GetRawData(crate,slot,hit)<<endl;
}
// You can alternatively let evdata print out the contents of a crate and slot:
evdata->PrintSlotData(crate,slot);
if (evdata->IsPhysicsTrigger()) {
// Below are interpreted data, device types are ADC, TDC, or scaler.
// One needs to know the channel number within the device
int channel = 7; // for example
cout << "Device type = ";
cout << evdata->DevType(crate,slot) << endl;
for (hit=0; hit<evdata->GetNumHits(crate,slot,channel); hit++) {
cout << "Channel " <<dec<<channel<<" hit # "<<hit<<" ";
cout << "data = " << evdata->GetData(crate,slot,channel,hit)<<endl;
}
// Helicity data
cout << "Helicity on left spectrometer "<<evdata->GetHelicity("left")<<endl;
cout << "Helicity on right spectrometer "<<evdata->GetHelicity("right")<<endl;
cout << "Helicity "<<evdata->GetHelicity()<<endl;
}
// Scalers: Although the getData methods works if you happen
// to know what crate & slot contain scaler data, here is
// another way to get scalers directly from evdata
for (slot=0; slot<5; slot++) {
cout << "\n scaler slot -> " << dec << slot << endl;;
for (int chan=0; chan<16; chan++) {
cout << "Scaler chan " << chan << " ";
cout << evdata->GetScaler("left",slot,chan);
cout << " " << evdata->GetScaler(7,slot,chan) << endl;
}
}
} // end of event loop
Finish:
cout<<"\nAll done; processed "<<dec<<ievent<<" events"<<endl;
}
//_____________________________________________________________________________
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;
}
//____________________________________________________________________
Int_t THaQWEAKHelicityReader::ReadData( const THaEvData& evdata )
{
// Obtain the present data from the event for QWEAK helicity mode.
static const char* here = "THaQWEAKHelicityReader::ReadData";
// std::cout<<" kHel, kTime, kRing="<< kHel<<" "<<kTime<<" "<<kRing<<endl;
// for (int jk=0; jk<3; jk++)
// {
// std::cout<<" which="<<jk
// <<" roc="<<fROCinfo[jk].roc
// <<" header="<<fROCinfo[jk].header
// <<" index="<<fROCinfo[jk].index
// <<endl;
// }
// std::cout<<" fHaveROCs="<<fHaveROCs<<endl;
if( !fHaveROCs ) {
::Error( here, "ROC data (detector map) not properly set up." );
return -1;
}
Int_t hroc = fROCinfo[kHel].roc;
Int_t len = evdata.GetRocLength(hroc);
if (len <= 4)
return -1;
Int_t ihel = FindWord( evdata, fROCinfo[kHel] );
if (ihel < 0) {
::Error( here , "Cannot find helicity" );
return -1;
}
Int_t data = evdata.GetRawData( hroc, ihel );
fPatternTir =(data & 0x20)>>5;
fHelicityTir=(data & 0x10)>>4;
fTSettleTir =(data & 0x40)>>6;
hroc=fROCinfo[kTime].roc;
len = evdata.GetRocLength(hroc);
if (len <= 4)
{
::Error( here, "length of roc event not matching expection ");
return -1;
}
Int_t itime = FindWord (evdata, fROCinfo[kTime] );
if (itime < 0) {
::Error( here, "Cannot find timestamp" );
return -1;
}
fTimeStampTir=static_cast<UInt_t> (evdata.GetRawData( hroc, itime ));
// Invert the gate polarity if requested
// if( fNegGate )
// fGate = !fGate;
hroc=fROCinfo[kRing].roc;
len = evdata.GetRocLength(hroc);
if (len <= 4)
{
::Error( here, "length of roc event not matching expection (message 2)");
// std::cout<<" len ="<<len<<endl;
// std::cout<<"kRING="<<kRing<<" hroc="<<hroc<<endl;
return -1;
}
Int_t index=0;
while (index < len && fIRing == 0)
{
Int_t header=evdata.GetRawData(hroc,index++);
if ((header & 0xffff0000) == 0xfb1b0000)
{
fIRing = header & 0x3ff;
}
}
// std::cout<<" fIRing ="<<fIRing<<" index="<<index<<endl;
if(fIRing>kHelRingDepth)
{
::Error( here, "Ring depth to large ");
return -1;
}
for(int i=0;i<fIRing; i++)
{
fTimeStampRing[i]=evdata.GetRawData(hroc,index++);
data=evdata.GetRawData(hroc,index++);
fHelicityRing[i]=(data & 0x1);
fPatternRing[i]= (data & 0x10)>>4;
fT3Ring[i]=evdata.GetRawData(hroc,index++);
fU3Ring[i]=evdata.GetRawData(hroc,index++);
fT5Ring[i]=evdata.GetRawData(hroc,index++);
fT10Ring[i]=evdata.GetRawData(hroc,index++);
}
// Print();
FillHisto();
return 0;
}
//_____________________________________________________________________________
void RoclenLoc::Load( const THaEvData& evdata )
{
// Get event length for this crate
data = evdata.GetRocLength(crate);
}
//_____________________________________________________________________________
void THaDebugModule::PrintEvNum( const THaEvData& evdata ) const
{
// Print current event number
cout << "======>>>>>> Event " << (UInt_t)evdata.GetEvNum() << endl;
}
int main(int argc, char* argv[]) {
int i,iev,evnum,trig,iskip,status;
Int_t clkp, clkm, lastclkp, lastclkm;
Float_t sum,asy;
TString filename = "run.dat";
char bank[100] = "EvLeft"; // Event stream, Left HRS
cout << "Analyzing CODA file "<<filename<<endl;
cout << "Bank = "<<bank<<endl<<flush;
evnum = 10000000;
if (argc > 1) evnum = atoi(argv[1]);
THaScaler *scaler = new THaScaler(bank);
if (scaler->Init("1-10-2004") == -1) {
cout << "Error initializing scaler "<<endl;
return 1;
}
THaCodaData *coda = new THaCodaFile(filename);
THaEvData *evdata = new THaCodaDecoder();
// Pedestals. Left, Right Arms. u1,u3,u10,d1,d3,d10
Float_t bcmpedL[NBCM] = { 188.2, 146.2, 271.6, 37.8, 94.2, 260.2 };
Float_t bcmpedR[NBCM] = { 53.0, 41.8, 104.1, 0., 101.6, 254.6 };
Float_t bcmped[NBCM];
if (strcmp(bank,"EvLeft") == 0) {
cout << "Using Left Arm BCM pedestals"<<endl;
for (i = 0; i < NBCM; i++) {
bcmped[i] = bcmpedL[i];
}
} else {
cout << "Using Right Arm BCM pedestals"<<endl;
for (i = 0; i < NBCM; i++) {
bcmped[i] = bcmpedR[i];
}
}
// Initialize root and output
TROOT scalana("scalroot","Hall A scaler analysis");
TFile hfile("scaler.root","RECREATE","Scaler data in Hall A");
// Define the ntuple here
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
char rawrates[]="time:u1:u3:u10:d1:d3:d10:t1:t2:t3:t4:t5:clkp:clkm:tacc:";
// 15 16 17 18 19 20 21 22 23 24 25 26
char asymmetries[]="au1:au3:au10:ad1:ad3:ad10:at1:at2:at3:at4:at5:aclk";
int nlen = strlen(rawrates) + strlen(asymmetries);
char *string_ntup = new char[nlen+1];
strcpy(string_ntup,rawrates);
strcat(string_ntup,asymmetries);
TNtuple *ntup = new TNtuple("ascal","Scaler Rates",string_ntup);
Float_t farray_ntup[27]; // Note, dimension is same as size of string_ntup (i.e. nlen+1)
status = 0;
iev = 0;
iskip = 0;
lastclkp = 0;
lastclkm = 0;
while (status == 0) {
if(coda) status = coda->codaRead();
if (status != 0) {
cout << "coda status nonzero. assume EOF"<<endl;
goto quit;
}
evdata->LoadEvent(coda->getEvBuffer());
// Dirty trick to average over larger time intervals (depending on
// SKIPEVENT) to reduce the fluctuations due to clock.
if (evdata->GetRocLength(MYROC) > 16) iskip++;
if (SKIPEVENT != 0 && iskip < SKIPEVENT) continue;
iskip = 0;
scaler->LoadData(*evdata);
// Not every trigger has new scaler data, so skip if not new.
if ( !scaler->IsRenewed() ) {
cout << "not renewed "<<endl<<flush;
continue;
}
if (iev++ > evnum) goto quit;
// Fill the ntuple here
// Note, we must average the two helicities here to get non-helicity rates
Double_t time = (scaler->GetPulser(1,"clock") + scaler->GetPulser(-1,"clock"))/1024;
farray_ntup[0] = time;
farray_ntup[1] = 0.5*(scaler->GetBcmRate(1,"bcm_u1") + scaler->GetBcmRate(-1,"bcm_u1"));
farray_ntup[2] = 0.5*(scaler->GetBcmRate(1,"bcm_u3") + scaler->GetBcmRate(-1,"bcm_u3"));
farray_ntup[3] = 0.5*(scaler->GetBcmRate(1,"bcm_u10") + scaler->GetBcmRate(-1,"bcm_u10"));
farray_ntup[4] = 0.5*(scaler->GetBcmRate(1,"bcm_d1") + scaler->GetBcmRate(-1,"bcm_d1"));
farray_ntup[5] = 0.5*(scaler->GetBcmRate(1,"bcm_d3") + scaler->GetBcmRate(-1,"bcm_d3"));
farray_ntup[6] = 0.5*(scaler->GetBcmRate(1,"bcm_d10") + scaler->GetBcmRate(-1,"bcm_d10"));
for (trig = 1; trig <= 5; trig++) {
farray_ntup[6+trig] = 0.5*(scaler->GetTrigRate(1,trig) + scaler->GetTrigRate(-1,trig));
}
clkp = scaler->GetNormData(1,"clock");
clkm = scaler->GetNormData(-1,"clock");
farray_ntup[12] = clkp - lastclkp;
farray_ntup[13] = clkm - lastclkm;
lastclkp = clkp;
lastclkm = clkm;
farray_ntup[14] = 0.5*(scaler->GetNormRate(1,"TS-accept") +
scaler->GetNormRate(-1,"TS-accept"));
string bcms[] = {"bcm_u1", "bcm_u3", "bcm_u10", "bcm_d1", "bcm_d3", "bcm_d10"};
for (int ibcm = 0; ibcm < 6; ibcm++ ) {
sum = scaler->GetBcmRate(1,bcms[ibcm].c_str()) - bcmped[ibcm]
+ scaler->GetBcmRate(-1,bcms[ibcm].c_str()) - bcmped[ibcm];
asy = -999;
if (sum != 0) {
asy = (scaler->GetBcmRate(1,bcms[ibcm].c_str()) -
scaler->GetBcmRate(-1,bcms[ibcm].c_str())) / sum;
}
farray_ntup[15+ibcm] = asy;
}
for (trig = 1; trig <= 5; trig++) {
asy = -999;
if (scaler->GetBcmRate(1,"bcm_u3") > BCM_CUT3 &&
scaler->GetBcmRate(-1,"bcm_u3") > BCM_CUT3) {
sum = scaler->GetTrigRate(1,trig)/scaler->GetBcmRate(1,"bcm_u3")
+ scaler->GetTrigRate(-1,trig)/scaler->GetBcmRate(-1,"bcm_u3");
if (sum != 0) {
asy = (scaler->GetTrigRate(1,trig)/scaler->GetBcmRate(1,"bcm_u3")
- scaler->GetTrigRate(-1,trig)/scaler->GetBcmRate(-1,"bcm_u3")) / sum;
}
}
farray_ntup[20+trig] = asy;
}
sum = scaler->GetPulser(1,"clock") + scaler->GetPulser(-1,"clock");
asy = -999;
if (sum != 0) {
asy = (scaler->GetPulser(1,"clock") -
scaler->GetPulser(-1,"clock")) / sum;
}
farray_ntup[26] = asy;
if (DEBUG) {
cout << "event type "<<evdata->GetEvType()<< " event number "<<evdata->GetEvNum()<<endl;
scaler->Print();
if (farray_ntup[12] < 1000) cout << "Low clock"<<endl;
cout << " clock(+) "<<scaler->GetNormRate(1,"clock");
cout << " clock(-) "<<scaler->GetNormRate(-1,"clock")<<endl;
if (farray_ntup[16]>0.005||farray_ntup[16]<-0.005) cout << "Big asy"<<endl;
}
ntup->Fill(farray_ntup);
}
quit:
hfile.Write();
hfile.Close();
exit(0);
}
//____________________________________________________________________
Int_t THaADCHelicity::Decode( const THaEvData& evdata )
{
// Decode Helicity data.
// Return 1 if helicity was assigned, 0 if not, -1 if error.
// Only the first two channels defined in the detector map are used
// here, regardless of how they are defined (consecutive channels
// in same module or otherwise). ReadDatabase guarantees that two channels
// are present and warns about extra channels.
if( !fIsInit )
return -1;
Int_t ret = 0;
bool gate_high = false;
for( Int_t i = 0; i < fNchan; ++i ) {
Int_t roc = fAddr[i].roc, slot = fAddr[i].slot, chan = fAddr[i].chan;
if ( !evdata.GetNumHits( roc, slot, chan ))
continue;
Double_t data =
static_cast<Double_t>(evdata.GetData( roc, slot, chan, 0 ));
if (fDebug >= 3) {
cout << "crate "<<roc<<" slot "<<slot<<" chan "
<<chan<<" data "<<data<<" ";
if (data > fThreshold)
cout << " above cut !";
cout << endl;
}
// Assign gate and helicity bit data. The first data channel is
// the helicity bit, the second, the gate.
switch(i) {
case 0:
fADC_hdata = data;
break;
case 1:
fADC_Gate = data;
gate_high = fInvertGate ? (data < fThreshold) : (data >= fThreshold);
break;
}
}
// Logic: if gate==0 helicity remains unknown. If gate==1
// (or we are ingoring the gate) then helicity is determined by
// the helicity bit.
if( gate_high || fIgnoreGate ) {
fADC_Hel = ( fADC_hdata >= fThreshold ) ? kPlus : kMinus;
ret = 1;
}
// fHelicity may be reassigned by derived classes, so we must keep the ADC
// result separately. But within this class, the two are the same.
if( fSign >= 0 )
fHelicity = fADC_Hel;
else
fHelicity = ( fADC_Hel == kPlus ) ? kMinus : kPlus;
if (fDebug >= 3) {
cout << "ADC helicity info "<<endl
<< "Gate "<<fADC_Gate<<" helic. bit "<<fADC_hdata
<< " ADC helicity "<<fADC_Hel
<< " resulting helicity"<<fHelicity<<endl;
}
return ret;
}
int main(int argc, char* argv[])
{
// Initialize the analysis clock
clock_t t;
t = clock();
// Define the data file to be analyzed
TString filename("snippet.dat");
// Define the analysis debug output
ofstream *debugfile = new ofstream;;
debugfile->open ("tstfadc_main_debug.txt");
// Initialize the CODA decoder
THaCodaFile datafile(filename);
THaEvData *evdata = new CodaDecoder();
// Initialize the evdata debug output
evdata->SetDebug(1);
evdata->SetDebugFile(debugfile);
// Initialize root and output
TROOT fadcana("tstfadcroot", "Hall C analysis");
hfile = new TFile("tstfadc.root", "RECREATE", "fadc module data");
// Loop over events
cout << "***************************************" << endl;
cout << NUMEVENTS << " events will be processed" << endl;
cout << "***************************************" << endl;
uint32_t iievent = 1;
//for(uint32_t ievent = 0; ievent < NUMEVENTS; ievent++) {
for(uint32_t ievent = 0; ievent < iievent; ievent++) {
// Read in data file
int status = datafile.codaRead();
if (status == S_SUCCESS) {
UInt_t *data = datafile.getEvBuffer();
evdata->LoadEvent(data);
if (debugfile) *debugfile << "****************" << endl;
if (debugfile) *debugfile << "Event Number = " << evdata->GetEvNum() << endl;
if (debugfile) *debugfile << "****************\n" << endl;
// Loop over slots
for(uint32_t islot = SLOTMIN; islot < NUMSLOTS; islot++) {
//if (evdata->GetNumRaw(CRATE5, islot) != 0) {
//if (evdata->GetNumRaw(CRATE10, islot) != 0) {
if (evdata->GetNumRaw(CRATE12, islot) != 0) {
Fadc250Module *fadc = NULL;
//fadc = dynamic_cast <Fadc250Module*> (evdata->GetModule(CRATE5, islot)); // Bryan's setup
//fadc = dynamic_cast <Fadc250Module*> (evdata->GetModule(CRATE10, islot)); // Alex's setup
fadc = dynamic_cast <Fadc250Module*> (evdata->GetModule(CRATE12, islot)); // Mark's setup
if (fadc != NULL) {
//fadc->CheckDecoderStatus();
if (debugfile) *debugfile << "\n///////////////////////////////\n"
<< "Results for crate "
<< fadc->GetCrate() << ", slot "
<< fadc->GetSlot() << endl;
if (debugfile) *debugfile << hex << "fadc pointer = " << fadc << "\n" << dec
<< "///////////////////////////////\n" << endl;
// Loop over channels
for (uint32_t chan = 0; chan < NADCCHAN; chan++) {
// Initilize variables
Int_t fadc_mode, num_fadc_events, num_fadc_samples;
Bool_t raw_mode;
fadc_mode = num_fadc_events = num_fadc_samples = raw_mode = 0;
// Acquire the FADC mode
fadc_mode = fadc->GetFadcMode(); fadc_mode_const = fadc_mode;
if (debugfile) *debugfile << "Channel " << chan << " is in FADC Mode " << fadc_mode << endl;
raw_mode = ((fadc_mode == 1) || (fadc_mode == 8) || (fadc_mode == 10));
// Generate FADC plots
GeneratePlots(fadc_mode, islot, chan);
// Acquire the number of FADC events
num_fadc_events = fadc->GetNumFadcEvents(chan);
// If in raw mode, acquire the number of FADC samples
if (raw_mode) {
num_fadc_samples = 0;
num_fadc_samples = fadc->GetNumFadcSamples(chan, ievent);
}
if (num_fadc_events > 0) {
for (Int_t jevent = 0; jevent < num_fadc_events; jevent++) {
// Debug output
if ((fadc_mode == 1 || fadc_mode == 8) && num_fadc_samples > 0)
if (debugfile) *debugfile << "FADC EMULATED PI DATA = " << fadc->GetEmulatedPulseIntegralData(chan) << endl;
if (fadc_mode == 7 || fadc_mode == 8 || fadc_mode == 9 || fadc_mode == 10) {
if (fadc_mode != 8) {if (debugfile) *debugfile << "FADC PI DATA = " << fadc->GetPulseIntegralData(chan, jevent) << endl;}
if (debugfile) *debugfile << "FADC PT DATA = " << fadc->GetPulseTimeData(chan, jevent) << endl;
if (debugfile) *debugfile << "FADC PPED DATA = " << fadc->GetPulsePedestalData(chan, jevent) << endl;
if (debugfile) *debugfile << "FADC PPEAK DATA = " << fadc->GetPulsePeakData(chan, jevent) << endl;
}
// Fill histos
if ((fadc_mode == 1 || fadc_mode == 8) && num_fadc_samples > 0) h_pinteg[islot][chan]->Fill(fadc->GetEmulatedPulseIntegralData(chan));
else if (fadc_mode == 7 || fadc_mode == 8 || fadc_mode == 9 || fadc_mode == 10) {
if (fadc_mode != 8) {h_pinteg[islot][chan]->Fill(fadc->GetPulseIntegralData(chan, jevent));}
h_ptime[islot][chan]->Fill(fadc->GetPulseTimeData(chan, jevent));
h_pped[islot][chan]->Fill(fadc->GetPulsePedestalData(chan, jevent));
h_ppeak[islot][chan]->Fill(fadc->GetPulsePeakData(chan, jevent));
}
// Raw sample events
if (raw_mode && num_fadc_samples > 0) {
// Debug output
if (debugfile) *debugfile << "NUM FADC SAMPLES = " << num_fadc_samples << endl;
if (debugfile) *debugfile << "=============================" << endl;
// Populate raw sample plots
if (ievent < NUMRAWEVENTS) {
// Acquire the raw samples vector and populate graphs
raw_samples_vector[islot][chan] = fadc->GetPulseSamplesVector(chan);
for (Int_t sample_num = 0; sample_num < Int_t (raw_samples_vector[islot][chan].size()); sample_num++)
g_psamp_event[islot][chan][ievent]->SetPoint(sample_num, sample_num + 1, Int_t (raw_samples_vector[islot][chan][sample_num]));
mg_psamp[islot][chan]->Add(g_psamp_event[islot][chan][ievent], "ACP");
} // NUMRAWEVENTS condition
} // Raw mode condition
} // FADC event loop
} // Number of FADC events condition
} //FADC channel loop
} // FADC module found condition
else
if (debugfile) *debugfile << "FADC MODULE NOT FOUND!!!" << endl;
} // Number raw words condition
} // Slot loop
} // CODA file read status condition
if (iievent % 1000 == 0)
//if (iievent % 1 == 0)
cout << iievent << " events have been processed" << endl;
iievent++;
if (status == EOF) break;
} // Event loop
// Populate waveform graphs and multigraphs and write to root file
TRandom3 *rand = new TRandom3();
for(uint32_t islot = 3; islot < NUMSLOTS; islot++) {
for (uint32_t chan = 0; chan < NADCCHAN; chan++) {
for( uint32_t ievent = 0; ievent < NUMRAWEVENTS; ievent++) {
// Raw sample plots
if (g_psamp_event[islot][chan][ievent] != NULL) {
UInt_t rand_int = 1 + rand->Integer(9);
hfile->cd(Form("/mode_%d_data/slot_%d/chan_%d/raw_samples", fadc_mode_const, islot, chan));
c_psamp[islot][chan]->cd(ievent + 1);
g_psamp_event[islot][chan][ievent]->Draw("ACP");
g_psamp_event[islot][chan][ievent]->SetTitle(Form("FADC Mode %d Pulse Peak Data Slot %d Channel %d Event %d", fadc_mode_const, islot, chan, ievent));
g_psamp_event[islot][chan][ievent]->GetXaxis()->SetTitle("Sample Number");
g_psamp_event[islot][chan][ievent]->GetYaxis()->SetTitle("Sample Value");
g_psamp_event[islot][chan][ievent]->SetLineColor(rand_int);
g_psamp_event[islot][chan][ievent]->SetMarkerColor(rand_int);
g_psamp_event[islot][chan][ievent]->SetMarkerStyle(20);
g_psamp_event[islot][chan][ievent]->SetDrawOption("ACP");
} // Graph condition
} // Raw event loop
// Write the canvas to file
if (c_psamp[islot][chan] != NULL) c_psamp[islot][chan]->Write();
// Write the multigraphs to file
if (mg_psamp[islot][chan] != NULL) {
hfile->cd(Form("/mode_%d_data/slot_%d/chan_%d", fadc_mode_const, islot, chan));
mg_psamp[islot][chan]->Draw("ACP");
//mg_psamp[islot][chan]->SetTitle(Form("%d Raw Events of FADC Mode %d Pulse Peak Data Slot %d Channel %d", NUMRAWEVENTS, fadc_mode_const, islot, chan));
//mg_psamp[islot][chan]->GetXaxis()->SetTitle("Sample Number");
//mg_psamp[islot][chan]->GetYaxis()->SetTitle("Sample Value");
mg_psamp[islot][chan]->Write();
} // Mulitgraph condition
} // Channel loop
} // Slot loop
cout << "***************************************" << endl;
cout << iievent - 1 << " events were processed" << endl;
cout << "***************************************" << endl;
// Write and clode the data file
hfile->Write();
hfile->Close();
// Calculate the analysis rate
t = clock() - t;
printf ("The analysis took %.1f seconds \n", ((float) t) / CLOCKS_PER_SEC);
printf ("The analysis event rate is %.1f Hz \n", (iievent - 1) / (((float) t) / CLOCKS_PER_SEC));
} // main()
//_____________________________________________________________________________
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 main(int argc, char* argv[])
{
if (argc < 2) {
cout << "You made a mistake... \n" << endl;
cout << "Usage: prfact filename" << endl;
cout << " where 'filename' is the CODA file"<<endl;
cout << "\n... exiting." << endl;
exit(0);
}
TString filename = argv[1];
THaCodaFile datafile;
if (datafile.codaOpen(filename) != S_SUCCESS) {
cout << "ERROR: Cannot open CODA data" << endl;
cout << "Perhaps you mistyped it" << endl;
cout << "... exiting." << endl;
exit(0);
}
THaEvData *evdata = new THaCodaDecoder();
// Can tell evdata whether to use evtype
// 133 or 120 for prescale data. Default is 120.
evdata->SetOrigPS(133); // args are 120 or 133
cout << "Origin of PS data "<<evdata->GetOrigPS()<<endl;
// Loop over a finite number of events
int NUMEVT=100000;
for (int i=0; i<NUMEVT; i++) {
int status = datafile.codaRead();
if ( status != S_SUCCESS ) {
if ( status == EOF) {
cout << "This is end of file !" << endl;
cout << "... exiting " << endl;
exit(1);
} else {
cout << hex << "ERROR: codaRread status = " << status << endl;
exit(0);
}
}
evdata->LoadEvent( datafile.getEvBuffer() );
if(evdata->IsPrescaleEvent()) {
cout <<"\n Prescale factors from CODA file = " << filename << endl;
cout <<"\n Trigger Prescale Factor"<< endl;
for (int trig=1; trig<=8; trig++) {
cout <<" "<<dec<<trig<<" ";
int ps = evdata->GetPrescaleFactor(trig);
int psmax;
if (trig <= 4) psmax = 16777216; // 2^24
if (trig >= 5) psmax = 65536; // 2^16
ps = ps % psmax;
if (ps == 0) ps = psmax;
cout << ps << endl;
}
cout << "\nReminder: A 'zero' was interpreted as maximum."<<endl;
cout << "Max for trig 1-4 = 2^24, for trig 5-8 = 2^16 \n"<<endl;
exit(0);
}
} // end of event loop
cout << "ERROR: prescale factors not found in the first ";
cout << dec << NUMEVT << " events " << endl;
}
int main(int argc, char* argv[]) {
int helicity, qrt, gate, timestamp;
int len, data, status, nscaler, header;
int numread, badread, i, found, index;
int ring_clock, ring_qrt, ring_helicity;
int ring_trig, ring_bcm, ring_l1a, ring_v2fh;
int sum_clock, sum_trig, sum_bcm, sum_l1a;
int inquad, nrread, q1_helicity;
int ring_data[MAXRING], rloc;
if (argc < 2) {
cout << "You made a mistake... bye bye !\n" << endl;
cout << "Usage: 'tscalroc" << MYROC << " filename'" << endl;
cout << " where 'filename' is the CODA file."<<endl;
exit(0);
}
// Setup
// Pedestals. Left, Right Arms. u1,u3,u10,d1,d3,d10
Float_t bcmpedL[NBCM] = { 188.2, 146.2, 271.6, 37.8, 94.2, 260.2 };
Float_t bcmpedR[NBCM] = { 53.0, 41.8, 104.1, 0., 101.6, 254.6 };
Float_t bcmped[NBCM];
if (MYROC == 11) {
cout << "Using Left Arm BCM pedestals"<<endl;
for (i = 0; i < NBCM; i++) {
bcmped[i] = bcmpedL[i];
}
} else {
cout << "Using Right Arm BCM pedestals"<<endl;
for (i = 0; i < NBCM; i++) {
bcmped[i] = bcmpedR[i];
}
}
// Initialize root and output.
TROOT scalana("scalroot","Hall A scaler analysis");
TFile hfile("scaler.root","RECREATE","Scaler data in Hall A");
// Define the ntuple here
// 0 1 2 3 4 5 6
char rawrates[]="evt:clk:trig:bcm:l1a:mhel:phel:";
// Asymmetries delayed various amounts, using RING BUFFER
// 7 8 9 10 11 12 13 14 15 16
char asydelay[]="a3d1:a3d2:a3d3:a3d4:a3d5:a3d6:a3d7:a3d8:a3d9:a3d10";
int nlen = strlen(rawrates) + strlen(asydelay);
char *string_ntup = new char[nlen+1];
strcpy(string_ntup,rawrates);
strcat(string_ntup,asydelay);
TNtuple *ntup = new TNtuple("ascal","Scaler Rates",string_ntup);
Float_t farray_ntup[17]; // Dimension = size of string_ntup (i.e. nlen+1)
THaCodaFile *coda = new THaCodaFile(TString(argv[1]));
THaEvData *evdata = new THaCodaDecoder();
inquad = 0;
q1_helicity = 0;
rloc = 0;
status = 0;
sum_clock = 0; sum_trig = 0; sum_bcm = 0; sum_l1a = 0;
nrread = 0;
memset(ring_data, 0, MAXRING*sizeof(int));
while (status == 0) {
status = coda->codaRead();
if (status != 0) break;
evdata->LoadEvent(coda->getEvBuffer());
len = evdata->GetRocLength(MYROC);
if (len <= 4) continue;
data = evdata->GetRawData(MYROC,3);
helicity = (data & 0x10) >> 4;
qrt = (data & 0x20) >> 5;
gate = (data & 0x40) >> 6;
timestamp = evdata->GetRawData(MYROC,4);
found = 0;
index = 5;
while ( !found ) {
data = evdata->GetRawData(MYROC,index++);
if ( (data & 0xffff0000) == 0xfb0b0000) found = 1;
if (index >= len) break;
}
if (!found) break;
nscaler = data & 0x7;
if (PRINTOUT) {
cout << hex << "helicity " << helicity << " qrt " << qrt;
cout << " gate " << gate << " time stamp " << timestamp << endl;
cout << "nscaler in this event " << nscaler << endl;
}
if (nscaler <= 0) continue;
if (nscaler > 2) nscaler = 2; // shouldn't be necessary
// 32 channels of scaler data for two helicities.
if (PRINTOUT) cout << "Synch event ----> " << endl;
for (int ihel = 0; ihel < nscaler; ihel++) {
header = evdata->GetRawData(MYROC,index++);
if (PRINTOUT) {
cout << "Scaler for helicity = " << dec << ihel;
cout << " unique header = " << hex << header << endl;
}
for (int ichan = 0; ichan < 32; ichan++) {
data = evdata->GetRawData(MYROC,index++);
if (PRINTOUT) {
cout << "channel # " << dec << ichan+1;
cout << " (hex) data = " << hex << data << endl;
}
}
}
numread = evdata->GetRawData(MYROC,index++);
badread = evdata->GetRawData(MYROC,index++);
if (PRINTOUT) cout << "FIFO num of last good read " << dec << numread << endl;
if (badread != 0) {
cout << "DISASTER: There are bad readings " << endl;
cout << "FIFO num of last bad read " << endl;
}
// Subset of scaler channels stored in a 30 Hz ring buffer.
int nring = 0;
while (index < len && nring == 0) {
header = evdata->GetRawData(MYROC,index++);
if ((header & 0xffff0000) == 0xfb1b0000) {
nring = header & 0x3ff;
}
}
if (PRINTOUT) cout << "Num in ring buffer = " << dec << nring << endl;
// The following assumes three are 6 pieces of data per 'iring'
// This was true after Jan 10, 2003.
for (int iring = 0; iring < nring; iring++) {
ring_clock = evdata->GetRawData(MYROC,index++);
data = evdata->GetRawData(MYROC,index++);
ring_qrt = (data & 0x10) >> 4;
ring_helicity = (data & 0x1);
present_reading = ring_helicity;
if (ring_qrt) {
inquad = 1;
if (loadHelicity()) {
if (present_reading != predicted_reading) {
cout << "DISASTER: The helicity is wrong !!"<<endl;
recovery_flag = 1; // ask for recovery
}
q1_helicity = present_helicity;
}
} else {
inquad++;
}
ring_trig = evdata->GetRawData(MYROC,index++);
ring_bcm = evdata->GetRawData(MYROC,index++);
ring_l1a = evdata->GetRawData(MYROC,index++);
ring_v2fh = evdata->GetRawData(MYROC,index++);
sum_clock = sum_clock + ring_clock;
sum_trig = sum_trig + ring_trig;
sum_bcm = sum_bcm + ring_bcm;
sum_l1a = sum_l1a + ring_l1a;
ring_data[rloc%MAXRING] = ring_bcm;
if (inquad == 1 && nrread++ > 12) {
farray_ntup[0] = (float)nrread;
farray_ntup[1] = ring_clock;
farray_ntup[2] = ring_trig;
farray_ntup[3] = ring_bcm;
farray_ntup[4] = ring_l1a;
farray_ntup[5] = (float)present_reading;
farray_ntup[6] = (float)present_helicity;
for (int ishift = 3; ishift <= 12; ishift++) {
Float_t pdat = ring_data[(rloc-ishift)%MAXRING];
Float_t mdat = ring_data[(rloc-ishift+1)%MAXRING];
Float_t sum = pdat + mdat;
Float_t asy = 99999;
if (sum != 0) {
if (present_reading == 1) {
asy = (pdat - mdat)/sum;
} else {
asy = (mdat - pdat)/sum;
}
}
farray_ntup[4+ishift] = asy;
}
ntup->Fill(farray_ntup);
}
rloc++;
if (PRINTOUT) {
cout << "buff [" << dec << iring << "] ";
cout << " clock " << ring_clock << " qrt " << ring_qrt;
cout << " helicity " << ring_helicity;
cout << " trigger " << ring_trig << " bcm " << ring_bcm;
cout << " L1a "<<ring_l1a<<endl;
cout << " ring_v2fh (helicity in v2f) "<<ring_v2fh<<endl;
cout << " inquad "<<inquad<<endl;
cout << " sums: "<<endl;
cout << " clock "<<sum_clock<<" trig "<<sum_trig<<endl;
cout << " bcm "<<sum_bcm<<" l1a "<<sum_l1a<<endl;
}
}
}
cout << "All done"<<endl;
hfile.Write();
hfile.Close();
return 0;
}
//_____________________________________________________________________________
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 main(int argc, char* argv[]) {
int myroc, iev, nevents;
int trig, clkp, clkm, lastclkp, lastclkm;
Float_t time, sum, asy;
int found,index;
int len, data, status, nscaler, header;
int numread0, numread1, badread, i, jstat;
int ring_clock, ring_qrt, ring_helicity;
int ring_t3, ring_bcm, ring_l1a, ring_t1;
int prev_clock, prev_trig, prev_bcm, prev_l1a, prev_hel2;
int sum_clock, sum_t3, sum_bcm, sum_l1a;
int latest_clock, latest_trig, latest_bcm, latest_l1a;
int inquad, nrread, q1_helicity, helicity_now;
int ring_data[MAXRING], rloc;
string filename, bank, mybank;
if (argc < 2) {
cout << "Usage: " << argv[0]<<" file [nevents]" << endl;
cout << "where file = CODA file to analyze " << endl;
cout << "and nevents is the number of events you want (optional)"<<endl;
cout << "(default nevents = all of them)"<<endl;
return 1;
}
filename = argv[1];
mybank = "evgen";
myroc = 23;
nevents = 0;
if (argc >= 3) nevents = atoi(argv[3]);
cout << "bank "<<mybank<<" num events "<<nevents<<endl;
// Pedestals. Left, Right Arms. u1,u3,u10,d1,d3,d10
Float_t bcmpedL[NBCM] = { 188.2, 146.2, 271.6, 37.8, 94.2, 260.2 };
Float_t bcmpedR[NBCM] = { 53.0, 41.8, 104.1, 0., 101.6, 254.6 };
Float_t bcmped[NBCM];
// Pedestals for Ring buffer analysis
// L-arm tuned from run e01012_20288, R-arm from e01012_1288
Float_t ringpedL[2] = { 112.2, 112.2 };
Float_t ringpedR[2] = { 112.2, 112.2 };
Float_t ringped[2];
if (myroc == 23) {
cout << "Using Left Arm BCM pedestals (for now) "<<endl;
for (i = 0; i < NBCM; i++) {
bcmped[i] = bcmpedL[i];
}
for (i = 0; i < 2; i++) ringped[i] = ringpedL[i];
} else {
cout << "Using Right Arm BCM pedestals"<<endl;
for (i = 0; i < NBCM; i++) {
bcmped[i] = bcmpedR[i];
}
for (i = 0; i < 2; i++) ringped[i] = ringpedR[i];
}
// Scaler object to extract data using scaler.map.
// WARNING: bank = "Left" goes with event type 140 data,
// while "EvLeft" goes with ROC11 data. Similarly "Right", "EvRight".
THaScaler *scaler = new THaScaler(mybank.c_str());
if (scaler->Init("3-1-2006") == -1) {
cout << "Error initializing scaler object. "<<endl;
return 1;
}
// Initialize root and output.
TROOT scalana("scalroot","Hall A scaler analysis");
TFile hfile("scaler.root","RECREATE","Scaler data in Hall A");
// Define the ntuple here. Part of the ntuple is filled from scaler
// object (scal_obj) and part is from event data (evdata).
// If you add a variable, I suggest you keep track of the indices the same way.
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
char scal_obj_rawrates[]="time:u1:u3:u10:d1:d3:d10:t1:t2:t3:t4:t5:clkp:clkm:tacc:";
// 15 16 17 18 19 20 21 22 23 24 25 26
char scal_obj_asymmetries[]="au1:au3:au10:ad1:ad3:ad10:at1:at2:at3:at4:at5:aclk:";
// 27 28 29 30 31 32 33
char evdata_rawrates[]="evt:evclk:evtrig:evbcm:evl1a:evmhel:evphel:";
// Asymmetries delayed various amounts, using RING BUFFER. The correct
// one is presumably the one delayed by NDELAY quads, but we need to check.
// 34 35 36 37 38 39 40 41 42 43
char asydelay[]="a3d1:a3d2:a3d3:a3d4:a3d5:a3d6:a3d7:a3d8:a3d9:a3d10";
int nlen = strlen(scal_obj_rawrates) + strlen(scal_obj_asymmetries) + strlen(evdata_rawrates) + strlen(asydelay);
char *string_ntup = new char[nlen+1];
strcpy(string_ntup, scal_obj_rawrates);
strcat(string_ntup, scal_obj_asymmetries);
strcat(string_ntup, evdata_rawrates);
strcat(string_ntup,asydelay);
TNtuple *ntup = new TNtuple("ascal","Scaler Rates",string_ntup);
Float_t* farray_ntup = new Float_t[nlen+1];
// 2nd ntuple for 1-sec averaged ring buffer
// 0 1 2 3 4 5 6 7 8 9 10 11
char ring_rates[]="evt:clkp:clkm:clk:bcmp:bcmm:bcm:trig:l1a:nump:numm:num:aclk:abcm:atrig:al1a";
//12 13 14 15
TNtuple *rnt = new TNtuple("aring","Ring values", ring_rates);
Float_t *farray2 = new Float_t[16];
THaCodaFile *coda = new THaCodaFile(TString(filename.c_str()));
THaEvData *evdata = new THaCodaDecoder();
inquad = 0;
q1_helicity = 0;
rloc = 0;
status = 0;
sum_clock = 0; sum_t3 = 0; sum_bcm = 0; sum_l1a = 0;
prev_clock = 0; prev_trig = 0; prev_bcm = 0; prev_l1a = 0; prev_hel2 = 0;
lastclkp = 0; lastclkm = 0;
nrread = 0;
iev = 0;
resetSums();
while (status == 0) {
status = coda->codaRead();
if (status != 0) break;
evdata->LoadEvent(coda->getEvBuffer());
len = evdata->GetRocLength(myroc);
if (nevents > 0 && iev++ > nevents) goto finish;
if (len <= 4) continue;
if (evdata->GetEvType() == 140) continue;
scaler->LoadData(*evdata);
if ( !scaler->IsRenewed() ) continue;
memset(farray_ntup, 0, (nlen+1)*sizeof(Float_t));
// Having loaded the scaler object, we pull out what we can from it.
// Note, we must average the two helicities to get non-helicity rates because ROC23
// data only have helicity scalers. (In contrast, event type 140 has all scalers.)
time = (scaler->GetPulser(1,"clock") + scaler->GetPulser(-1,"clock"))/1024;
latest_clock = (scaler->GetPulser(1,"clock") + scaler->GetPulser(-1,"clock"));
latest_trig = (scaler->GetTrig(1,3) + scaler->GetTrig(-1,3));
latest_bcm = (scaler->GetBcm(1,"bcm_u3") + scaler->GetBcm(-1,"bcm_u3"));
latest_l1a = (scaler->GetNormData(1,"TS-accept") + scaler->GetNormData(-1,"TS-accept"));
if (PRINTOUT) cout << dec << "latest data "<<latest_clock<<" "<<latest_trig<<" "<<latest_bcm<<" "<<latest_l1a<<endl;
farray_ntup[0] = time;
farray_ntup[1] = 0.5*(scaler->GetBcmRate(1,"bcm_u1") + scaler->GetBcmRate(-1,"bcm_u1"));
farray_ntup[2] = 0.5*(scaler->GetBcmRate(1,"bcm_u3") + scaler->GetBcmRate(-1,"bcm_u3"));
farray_ntup[3] = 0.5*(scaler->GetBcmRate(1,"bcm_u10") + scaler->GetBcmRate(-1,"bcm_u10"));
farray_ntup[4] = 0.5*(scaler->GetBcmRate(1,"bcm_d1") + scaler->GetBcmRate(-1,"bcm_d1"));
farray_ntup[5] = 0.5*(scaler->GetBcmRate(1,"bcm_d3") + scaler->GetBcmRate(-1,"bcm_d3"));
farray_ntup[6] = 0.5*(scaler->GetBcmRate(1,"bcm_d10") + scaler->GetBcmRate(-1,"bcm_d10"));
for (trig = 1; trig <= 5; trig++) {
farray_ntup[6+trig] = 0.5*(scaler->GetTrigRate(1,trig) + scaler->GetTrigRate(-1,trig));
}
if (PRINTOUT == 1 && len >= 16) {
scaler->Print();
for (i = 0; i < 6; i++) cout << " bcm -> "<<farray_ntup[i];
cout << endl << endl;
for (i = 0; i < 5; i++) cout << " trig -> "<<farray_ntup[i+7];
cout << endl << endl;
}
clkp = scaler->GetNormData(1,"clock");
clkm = scaler->GetNormData(-1,"clock");
farray_ntup[12] = clkp - lastclkp;
farray_ntup[13] = clkm - lastclkm;
lastclkp = clkp;
lastclkm = clkm;
farray_ntup[14] = 0.5*(scaler->GetNormRate(1,"TS-accept") +
scaler->GetNormRate(-1,"TS-accept"));
string bcms[] = {"bcm_u1", "bcm_u3", "bcm_u10", "bcm_d1", "bcm_d3", "bcm_d10"};
//
// Next we construct the helicity correlated asymmetries.
//
for (int ibcm = 0; ibcm < 6; ibcm++ ) {
sum = scaler->GetBcmRate(1,bcms[ibcm].c_str()) - bcmped[ibcm]
+ scaler->GetBcmRate(-1,bcms[ibcm].c_str()) - bcmped[ibcm];
asy = -999;
if (sum != 0) {
asy = (scaler->GetBcmRate(1,bcms[ibcm].c_str()) -
scaler->GetBcmRate(-1,bcms[ibcm].c_str())) / sum;
}
farray_ntup[15+ibcm] = asy;
}
for (trig = 1; trig <= 5; trig++) {
asy = -999;
if (scaler->GetBcmRate(1,"bcm_u3") > BCM_CUT3 &&
scaler->GetBcmRate(-1,"bcm_u3") > BCM_CUT3) {
sum = scaler->GetTrigRate(1,trig)/scaler->GetBcmRate(1,"bcm_u3")
+ scaler->GetTrigRate(-1,trig)/scaler->GetBcmRate(-1,"bcm_u3");
if (sum != 0) {
asy = (scaler->GetTrigRate(1,trig)/scaler->GetBcmRate(1,"bcm_u3")
- scaler->GetTrigRate(-1,trig)/scaler->GetBcmRate(-1,"bcm_u3")) / sum;
}
}
farray_ntup[20+trig] = asy;
}
sum = scaler->GetPulser(1,"clock") + scaler->GetPulser(-1,"clock");
asy = -999;
if (sum != 0) {
asy = (scaler->GetPulser(1,"clock") -
scaler->GetPulser(-1,"clock")) / sum;
}
farray_ntup[26] = asy;
//
// Next we ignore the scaler object and obtain data directly from the event.
//
found = 0;
index = 0;
while ( !found ) {
data = evdata->GetRawData(myroc,index++);
if ( (data & 0xffff0000) == 0xfb0b0000) found = 1;
if (PRINTOUT) cout << "evbuffer["<<index-1<<"] = 0x"<<hex<<data<<" = (dec) "<<dec<<data<<endl;
if (index >= len) break;
}
if (!found) continue;
nscaler = data & 0x7;
// if (evdata->GetEvType() == 9) cout << "Ev 9 qrt "<<qrt<<" helicity "<<helicity<<" gate "<<gate<<" timestamp "<<timestamp<<endl;
if (PRINTOUT) {
cout << "nscaler in this event " << nscaler << endl;
}
if (nscaler <= 0) continue;
if (nscaler > 2) nscaler = 2; // shouldn't be necessary
// 32 channels of scaler data for two helicities.
if (PRINTOUT) cout << "Scaler data in event ----> " << endl;
for (int ihel = 0; ihel < nscaler; ihel++) {
header = evdata->GetRawData(myroc,index++);
if (PRINTOUT) {
cout << "Scaler for helicity = " << dec << ihel;
cout << " unique header = " << hex << header << endl;
}
for (int ichan = 0; ichan < 32; ichan++) {
data = evdata->GetRawData(myroc,index++);
if (PRINTOUT) {
cout << "channel # " << dec << ichan+1;
cout << " data = 0x" << hex << data;
cout << " = (dec) "<< dec << data << endl;
}
}
}
numread0 = evdata->GetRawData(myroc,index++);
numread1 = evdata->GetRawData(myroc,index++);
badread = evdata->GetRawData(myroc,index++);
if (PRINTOUT)
cout << "FIFO num of last good read " << dec << numread0 << numread1 << endl;
if (badread != 0) {
cout << "DISASTER: There are bad readings " << endl;
cout << "FIFO num of last bad read " << endl;
}
// Ring buffer analysis: analyze subset of scaler channels in 30 Hz ring buffer.
int nring = 0;
while (index < len && nring == 0) {
header = evdata->GetRawData(myroc,index++);
if ((header & 0xffff0000) == 0xfb1b0000) {
nring = header & 0x3ff;
}
}
if (PRINTOUT) cout << "Num in ring buffer = " << dec << nring << endl;
// The following assumes three are (now 6) pieces of data per 'iring'
for (int iring = 0; iring < nring; iring++) {
ring_clock = evdata->GetRawData(myroc,index++);
data = evdata->GetRawData(myroc,index++);
ring_qrt = (data & 0x10) >> 4;
ring_helicity = (data & 0x1);
present_reading = ring_helicity;
if (ring_qrt) {
inquad = 1;
if (loadHelicity()) {
// cout << "CHECK HEL "<<present_reading<<" "
// << predicted_reading << endl;
if (present_reading != predicted_reading) {
cout << "DISASTER: The helicity is wrong !!"<<endl;
recovery_flag = 1; // ask for recovery
}
q1_helicity = present_helicity;
}
} else {
inquad++;
}
if (inquad == 1 || inquad == 4) {
helicity_now = q1_helicity;
} else {
helicity_now = 1 - q1_helicity;
}
ring_t3 = evdata->GetRawData(myroc,index++);
ring_bcm = evdata->GetRawData(myroc,index++);
ring_l1a = evdata->GetRawData(myroc,index++);
#ifdef READ6
ring_t1 = evdata->GetRawData(myroc,index++);
#else
ring_t1 = -99;
#endif
sum_clock = sum_clock + ring_clock;
sum_t3 = sum_t3 + ring_t3;
sum_bcm = sum_bcm + ring_bcm;
sum_l1a = sum_l1a + ring_l1a;
// We know the helicity bits come one window later, so we adjust
// for that here.
jstat = incrementSums(helicity_now, prev_clock, prev_trig,
prev_bcm, prev_l1a);
if (jstat == 1) {
farray2[0] = (Float_t) evdata->GetEvNum();
farray2[1] = rsum_clk[0];
farray2[2] = rsum_clk[1];
farray2[3] = rsum_clk[0] + rsum_clk[1];
corr_bcm0 = rsum_bcm[0] - ringped[0]; // the 2 peds had better
corr_bcm1 = rsum_bcm[1] - ringped[1]; // be the same (but we check)
farray2[4] = rsum_bcm[0];
farray2[5] = rsum_bcm[1];
farray2[6] = corr_bcm0 + corr_bcm1;
farray2[7] = rsum_t3[0] + rsum_t3[1];
farray2[8] = rsum_l1a[0] + rsum_l1a[1];
farray2[9] = rsum_num[0];
farray2[10] = rsum_num[1];
farray2[11] = rsum_num[0] + rsum_num[1];
sum = rsum_clk[0] + rsum_clk[1];
asy = -999;
if (sum != 0) asy = (rsum_clk[0] - rsum_clk[1])/sum;
farray2[12] = asy;
// Charge asymmetry. Don't forget to normalize to clock.
asy = -999;
sum = corr_bcm0 + corr_bcm1;
if (sum != 0) asy = (corr_bcm0 - corr_bcm1)/sum;
farray2[13] = asy;
asy = -999;
if (corr_bcm0 != 0 && corr_bcm1 != 0) {
Float_t trig0 = rsum_t3[0] / corr_bcm0;
Float_t trig1 = rsum_t3[1] / corr_bcm1;
sum = trig0 + trig1;
if (sum != 0) {
asy = (trig0 - trig1) / sum;
}
}
farray2[14] = asy;
asy = -999;
if (corr_bcm0 != 0 && corr_bcm1 != 0) {
Float_t l1a0 = rsum_l1a[0] / corr_bcm0;
Float_t l1a1 = rsum_l1a[1] / corr_bcm1;
sum = l1a0 + l1a1;
if (sum != 0) {
asy = (l1a0 - l1a1) / sum;
}
}
farray2[15] = asy;
rnt->Fill(farray2);
resetSums();
}
prev_clock = ring_clock;
prev_trig = ring_t3;
prev_bcm = ring_bcm;
prev_l1a = ring_l1a;
// Empirical check of delayed helicity scheme.
ring_data[rloc%MAXRING] = ring_bcm;
if (inquad == 1 && nrread++ > 12) {
farray_ntup[27] = (float)nrread; // need to cut that this is >0 in analysis
farray_ntup[28] = ring_clock;
farray_ntup[29] = ring_t3;
farray_ntup[30] = ring_bcm;
farray_ntup[31] = ring_l1a;
farray_ntup[32] = (float)present_reading;
farray_ntup[33] = (float)present_helicity;
for (int ishift = 3; ishift <= 12; ishift++) {
Float_t pdat = ring_data[(rloc-ishift)%MAXRING];
Float_t mdat = ring_data[(rloc-ishift+1)%MAXRING];
Float_t sum = pdat + mdat;
Float_t asy = 99999;
if (sum != 0) {
if (present_reading == 1) {
asy = (pdat - mdat)/sum;
} else {
asy = (mdat - pdat)/sum;
}
}
// ishift = 9 is the correct one. (should be 8, but the helicity
// bits are one cycle out of phase w.r.t. data)
farray_ntup[31+ishift] = asy;
if (PRINTOUT) cout << "shift "<<ishift<<" "<<asy<<endl;
}
}
ntup->Fill(farray_ntup);
rloc++;
if (PRINTOUT) {
cout << "buff [" << dec << iring << "] ";
cout << " clock " << ring_clock << " qrt " << ring_qrt;
cout << " helicity " << ring_helicity<<" T1 "<<ring_t1<<endl;
cout << " T3 " << ring_t3 << " bcm " << ring_bcm;
cout << " L1a "<<ring_l1a<<endl;
cout << " inquad "<<inquad<<endl;
cout << " sums: "<<endl;
cout << " clock "<<sum_clock<<" trig "<<sum_t3;
cout << " bcm "<<sum_bcm<<" l1a "<<sum_l1a<<endl;
cout << " update from online sums: "<<endl;
cout << " clock "<<latest_clock<<" trig "<<latest_trig;
cout << " bcm "<<latest_bcm<<" l1a "<<latest_l1a<<endl;
}
}
}
finish:
cout << "All done"<<endl<<flush;
cout << "Sums from ring buffer: "<<dec<<endl;
cout << " Clock "<<sum_clock<<" trigger "<<sum_t3;
cout << " BCM "<<sum_bcm<<" L1a "<<sum_l1a<<endl;
cout << "Latest data from online sums: "<<endl;
cout << " Clock "<<latest_clock<<" trigger "<<latest_trig;
cout << " BCM "<<latest_bcm<<" L1a "<<latest_l1a<<endl;
hfile.Write();
hfile.Close();
exit(0);
}
int main(int argc, char* argv[])
{
TString filename("snippet.dat");
ofstream *debugfile = 0;
#ifdef DEBUG
debugfile = new ofstream;
debugfile->open ("oodecoder1.txt");
*debugfile << "Debug of OO decoder\n\n";
#endif
THaCodaFile datafile(filename);
THaEvData *evdata = new CodaDecoder();
evdata->SetDebug(1);
evdata->SetDebugFile(debugfile);
// Initialize root and output
TROOT fadcana("fadcroot","Hall A FADC analysis, 1st version");
TFile hfile("fadc.root","RECREATE","FADC data");
h1 = new TH1F("h1","snapshot 1",1020,-5,505);
h2 = new TH1F("h2","snapshot 2",1020,-5,505);
h3 = new TH1F("h3","snapshot 3",1020,-5,505);
h4 = new TH1F("h4","snapshot 4",1020,-5,505);
h5 = new TH1F("h5","snapshot 5",1020,-5,505);
hinteg = new TH1F("hinteg","Integral of ADC",1000,50000,120000);
// Loop over events
int NUMEVT=22;
Int_t jnum=1;
for (int iev=0; iev<NUMEVT; iev++) {
int status = datafile.codaRead();
if (status != S_SUCCESS) {
if ( status == EOF) {
if (debugfile) *debugfile << "Normal end of file. Bye bye." << endl;
} else {
if (debugfile) *debugfile << hex << "ERROR: codaRread status = " << status << endl;
}
exit(1);
} else {
UInt_t *data = datafile.getEvBuffer();
dump(data, debugfile);
if (debugfile) *debugfile << "\nAbout to Load Event "<<endl;
evdata->LoadEvent( data );
if (debugfile) *debugfile << "\nFinished with Load Event "<<endl;
if (evdata->GetEvType() == MYTYPE) {
process (jnum, evdata, debugfile);
jnum++;
}
}
}
hfile.Write();
hfile.Close();
}
