void RawDataSanity(const char* filename)
{
AliRawReader* reader = AliRawReader::Create(filename);
if (!reader) return;
int nevent(0);
Double_t meanEventSize(0);
while (reader->NextEvent())// && nevent < 1)
{
++nevent;
cout << Form("EVENT %d",nevent) << endl;
AliRawVEvent* event = const_cast<AliRawVEvent*>(reader->GetEvent());
Double_t eventSize = 0;
for ( int i = 0; i < event->GetNSubEvents(); ++i )
{
AliRawVEvent* sub = event->GetSubEvent(i);
for ( int j = 0; j < sub->GetNEquipments(); ++j )
{
AliRawVEquipment* eq = sub->GetEquipment(j);
AliRawEquipmentHeader* equipmentHeader = eq->GetEquipmentHeader();
UInt_t uid = equipmentHeader->GetId();
int index;
TString det(AliDAQ::DetectorNameFromDdlID(uid,index));
if (det=="MUONTRK")
{
cout << Form("%d %s %d",uid,det.Data(),equipmentHeader->GetEquipmentSize()) << endl;
eventSize += equipmentHeader->GetEquipmentSize();
}
}
}
meanEventSize = meanEventSize*(1.0 - 1.0/nevent) + eventSize/nevent;
}
delete reader;
cout << Form("Mean event size is %5.2f KB",meanEventSize/1024.0) << endl;
}
void Test(const char* filename)
{
AliRawReader* reader = AliRawReader::Create(filename);
if (!reader) return;
int nevent(0);
while (reader->NextEvent())
{
cout << Form("event %5d detector pattern %p",nevent,reader->GetDetectorPattern()) << endl;
++nevent;
}
}
void vzero_raw()
{
printf("*** RAW VZero ***");
gStyle->SetPalette(1, 0);
AliRawReader *reader = AliEveEventManager::AssertRawReader();
reader->Reset();
gEve->DisableRedraw();
AliEveVZEROModule* rawA = new AliEveVZEROModule("VZERO_RAW_A", kTRUE);
rawA->LoadRaw(reader);
AliEveVZEROModule* rawC = new AliEveVZEROModule("VZERO_RAW_C", kFALSE);
rawC->LoadRaw(reader);
gEve->EnableRedraw();
}
// read TPC Clusters compressed by HLT from a raw filename
TTree* readHLTClusters(AliRawReader *fRawReader)
{
/*************************
* Raw IO Stuff
**************************/
cout<<"reader:"<<fRawReader<<endl;
AliRawReader* rawReader = AliRawHLTManager::CreateRawReaderHLT(fRawReader, "TPC");
cout<<"rawReader:"<<rawReader<<endl;
rawReader->Select("TPC");
/*************************
* HLT IO Stuff
**************************/
AliHLTSystem* hltSystem=AliHLTPluginBase::GetInstance();
cout<<"hltSystem:"<<hltSystem<<endl;
AliHLTOUT* hltOut = AliHLTOUT::New(rawReader);
cout<<"hltOut:"<<hltOut<<endl;
hltOut->Init();
hltSystem->InitHLTOUT(hltOut);
/*************************
* GRP Stuff
**************************/
AliGRPManager *manGRP = new AliGRPManager();
cout<<"manGRP:"<<manGRP<<endl;
AliRecoParam* recoParam = InitRecoParam();
cout<<"recoParam:"<<recoParam<<endl;
if(!recoParam){
cout<<"No reco param"<<endl;
}
AliEveEventManager* curEventMan = (AliEveEventManager*)gEve->GetCurrentEvent();
cout<<"a"<<endl;
const AliRunInfo* runInfo = manGRP->GetRunInfo();
cout<<"a.1:"<<runInfo<<endl;
const THashTable* cosmicTriggers = manGRP->GetCosmicTriggers();
cout<<"a.2:"<<cosmicTriggers<<endl;
const AliEventInfo *eventinfo = GetEventInfo();
if(!eventinfo){
cout<<"Event info couldn't be retrived."<<endl;
return 0;
}
recoParam->SetEventSpecie(runInfo,*eventinfo,cosmicTriggers);
cout<<"aaa"<<endl;
AliTPCRecoParam *tpcRecoParam = (AliTPCRecoParam*)recoParam->GetDetRecoParam(1); // TPC has index 1
tpcRecoParam->SetUseHLTClusters(3); // reconstruct only HLT clusters
cout<<"aaaa"<<endl;
/**************************
* Reconstruction of Clusters
**************************/
TTree* outputClustersTree = new TTree();
cout<<"a1"<<endl;
AliTPCReconstructor *reconstructor = new AliTPCReconstructor();
cout<<"a1.1"<<endl;
reconstructor->SetOption("useHLT");
cout<<"a1.2"<<endl;
reconstructor->CreateTracker(); // this will set the option to reconstruct for only HLT clusters
cout<<"a2"<<endl;
reconstructor->SetRecoParam(tpcRecoParam);
reconstructor->SetRunInfo((AliRunInfo*)runInfo);
reconstructor->SetEventInfo((AliEventInfo*)eventinfo);
cout<<"a3"<<endl;
if(!rawReader){
cout<<"No raw reader"<<endl;
}
reconstructor->Reconstruct(rawReader, outputClustersTree);
if(reconstructor){
// delete reconstructor;
reconstructor=0;
}
cout<<"aaaaa"<<endl;
hltSystem->ReleaseHLTOUT(hltOut);
cout<<"aaaaaa"<<endl;
return outputClustersTree;
}
void tpc_raw(Int_t mode = 3)
{
printf("*** RAW TPC ***");
gStyle->SetPalette(1, 0);
cout<<"1"<<endl;
// AliCDBManager::Instance()->SetSpecificStorage("GRP/CTP/Config","local:///local/cdb/");
// AliCDBManager::Instance()->SetSpecificStorage("GRP/GRP/Data","local:///local/cdb/");
AliEveEventManager *eventManager = AliEveEventManager::Instance();
cout<<"2"<<endl;
eventManager->AssertGeometry();
cout<<"3"<<endl;
AliEveEventManager::AssertMagField();
cout<<"4"<<endl;
AliRawReader *reader = eventManager->GetRawReader();
if(!reader){
cout<"tpc_raw -- no raw reader"<<endl;
return;
}
cout<<"5"<<endl;
reader->Reset();
AliTPCRawStreamV3 input(reader);
reader->Select("TPC"); // ("TPC", firstRCU, lastRCU);
AliEveTPCData *x = new AliEveTPCData;
// x->SetLoadPedestal(5);
x->SetLoadThreshold(5);
x->SetAutoPedestal(kTRUE);
x->LoadRaw(input, kTRUE, kTRUE);
gEve->DisableRedraw();
TEveElementList* sec2d = new TEveElementList("TPC 2D");
gEve->AddElement(sec2d);
TEveElementList* sec3d = new TEveElementList("TPC 3D");
gEve->AddElement(sec3d);
AliEveTPCSector2D *s;
AliEveTPCSector3D *t;
for (Int_t i=0; i<=35; ++i) {
if (mode & 1) {
s = new AliEveTPCSector2D(Form("2D sector %d",i));
s->SetSectorID(i);
s->SetAutoTrans(kTRUE); // place on proper 3D coordinates
s->SetDataSource(x);
s->SetFrameColor(36);
sec2d->AddElement(s);
s->IncRTS();
}
if (mode & 2) {
t = new AliEveTPCSector3D(Form("3D sector %d",i));
t->SetSectorID(i);
t->SetAutoTrans(kTRUE);
t->SetDataSource(x);
sec3d->AddElement(t);
t->IncRTS();
}
}
cout<<"Reading HLT clusters"<<endl;
// Display TPC clusters compressed by HLT
TTree* hltClustersTree = readHLTClusters(reader); // read HLT compressed clusters from TPC from raw reader and output them in hltClustersTree
if(!hltClustersTree){
cout<<"HLT clusters tree couldn't be created"<<endl;
return;
}
cout<<"HLT clusters read"<<endl;
if(hltClustersTree) renderHLTClusters(hltClustersTree);
cout<<"HLT clusters rendered"<<endl;
gEve->EnableRedraw();
gEve->Redraw3D();
}
void ITSSDDQAMaker(char *iFile, Int_t MaxEvts=1000000, Int_t FirstEvt=0) {
//To have Baseline Histos uncomment parts with " // BL!!! " comment
cout << "SDD Quality Assurance Prototype Macro" << endl;
const Int_t nSDDmodules= 260;
const Int_t imodoffset = 240;
const Int_t modtotSDD = nSDDmodules*2;
const Int_t anode = 256;
Float_t xi = -0.5;
Float_t xf = xi + nSDDmodules;
TH1F *hModulePattern = new TH1F("hModulePattern","Modules pattern",nSDDmodules,xi,xf);
xf = xi + modtotSDD;
TH1F *hModuleSidePattern = new TH1F("hModuleSidePattern","Modules/Side pattern",modtotSDD,xi,xf);
TH2F *hModuleChargeMap[modtotSDD]; //260 dx e 260 sx with A, T, Q
TH2F *hModuleCountsMap[modtotSDD]; //260 dx e 260 sx with A, T, Ncounts
TH2I *hModuleCarlos = new TH2I("hModuleCarlos","hModuleCarlos",modtotSDD,xi,xf,101,-0.5,100.5);
/*
TH1F *hModuleSideBL[modtotSDD][anode]; // BL!!!
*/
//-------histograms definition
Char_t *hisnam = new Char_t[50];
Char_t *histit = new Char_t[50];
Char_t *hisnam2 = new Char_t[50];
Char_t *histit2 = new Char_t[50];
Char_t *hisnam3 = new Char_t[50];
for(Int_t imod=0; imod<nSDDmodules;imod++){
for(Int_t isid=0;isid<2;isid++){
Int_t index=2*imod+isid; //260*2 position
sprintf(hisnam,"chargeMap%d",index);
sprintf(histit,"Total Charge, module number %d",index);
hModuleChargeMap[index]=new TH2F(hisnam,histit,256,-0.5,255.5,256,-0.5,255.5);
sprintf(hisnam2,"countsMap%d",index);
sprintf(histit2,"Number of Counts, module number %d",index);
hModuleCountsMap[index] = new TH2F(hisnam2,histit2,256,-0.5,255.5,256,-0.5,255.5);
/*
for(Int_t ianode=0; ianode<anode; ianode++){ // BL!!!
sprintf(hisnam3,"BL_module_%d_%d",index,ianode);
//cout<<hisnam3 <<endl;
hModuleSideBL[index][ianode] = new TH1F(hisnam3,hisnam3,256,0.,1024.);
}
*/
}
}
TString strFile = iFile;
strFile += "?EventType=7";
AliRawReader *rd = new AliRawReaderDate(strFile.Data(),FirstEvt); // open run
Int_t evCounter = 0;
do{ // start loop on events
if(++evCounter > MaxEvts) { cout << MaxEvts << " events read, stop" << endl; evCounter--; break; }
cout << "Read Event: " << evCounter+FirstEvt-1 << endl;
rd->RequireHeader(kFALSE);
rd->Reset(); // reset the current position to the beginning of the event
Int_t nSkip = 0; // number of skipped signals
AliITSRawStreamSDD s(rd); //This class provides access to ITS SDD digits in raw data.
Int_t iddl;
Int_t isddmod;
Int_t moduleSDD;
gStyle->SetPalette(1);
while(s.Next()){ //read the next raw digit; returns kFALSE if there is no digit left
if(s.IsCompletedModule()) continue;
if(s.IsCompletedDDL()) continue;
iddl=rd->GetDDLID()-2; // -2 is temporary for test raw data
isddmod=s.GetModuleNumber(iddl,s.GetCarlosId()); //this is the FEE Carlos
//cout<<"DDLID= "<<iddl <<"; Module number= " <<isddmod <<endl;
if(isddmod >= imodoffset) {
hModulePattern->Fill(isddmod-imodoffset); // 0 to 259 so 240 to 499
moduleSDD=2*(isddmod-imodoffset)+s.GetChannel();
hModuleSidePattern->Fill(moduleSDD); // 0 to 519
hModuleCarlos->Fill(isddmod-imodoffset,s.GetCarlosId());
//cout << "anode " << s.GetCoord1() << ", time bin: " << s.GetCoord2() << ", charge: " << s.GetSignal() << endl;
Int_t coord1 = s.GetCoord1();
Int_t coord2 = s.GetCoord2();
Int_t signal = s.GetSignal();
hModuleChargeMap[moduleSDD]->Fill(coord2, coord1,signal);
hModuleCountsMap[moduleSDD]->Fill(coord2, coord1 );
//hModuleSideBL[moduleSDD][coord1]->Fill(signal); // BL !!!
} else {
nSkip++;
}
}
cout << "End of Event " << evCounter+FirstEvt-1 << ", " << nSkip << " wrong module numbers" << endl;
} while(rd->NextEvent()); // end loop on events
delete rd;
cout << "end after " << evCounter << " events" << endl;
/*
TNtuple *Baseline = new TNtuple("Baseline","Baseline","HalfModule:Anode:Mean:RMS"); // BL!!!
Float_t meanBL;
Float_t rmsBL;
*/
for(Int_t i=0; i<modtotSDD; i++){
if(hModuleSidePattern->GetBinContent(i+1)){ //check if they're not empty
hModuleChargeMap[i]->GetXaxis()->SetTitle("Time Bin");
hModuleChargeMap[i]->GetYaxis()->SetTitle("Anode");
hModuleCountsMap[i]->GetXaxis()->SetTitle("Time Bin");
hModuleCountsMap[i]->GetYaxis()->SetTitle("Anode");
/*
for(Int_t ianode=0; ianode<anode; ianode++ ){ // BL!!!
hModuleSideBL[i][ianode]->GetXaxis()->SetTitle("ADC counts");
hModuleSideBL[i][ianode]->GetYaxis()->SetTitle("#");
meanBL = hModuleSideBL[i][ianode]->GetMean();
rmsBL = hModuleSideBL[i][ianode]->GetRMS();
gaussfitBL = hModuleSideBL[i][ianode]->Fit("gaus");
Baseline->Fill(i,ianode,meanBL,rmsBL);
}
*/
}
}
hModuleSidePattern->GetXaxis()->SetTitle("2*(Module Number-1)+Side");
hModuleSidePattern->GetYaxis()->SetTitle("Counts");
hModulePattern->GetXaxis()->SetTitle("Module Number");
hModulePattern->GetYaxis()->SetTitle("Counts");
//-------store Histograms
cout << "Store Histograms" << endl;
TString oFileName(iFile);
oFileName.Append(".root");
TFile *oFile = TFile::Open(oFileName,"recreate");
hModulePattern->Write();
hModuleSidePattern->Write();
hModuleCarlos->Write();
for(Int_t i=0; i<modtotSDD; i++){
if(hModuleSidePattern->GetBinContent(i+1)){ //check if they're not empty
hModuleChargeMap[i]->Write();
hModuleCountsMap[i]->Write();
/*
for(Int_t ianode=0; ianode<anode; ianode++ ){ // BL!!!
hModuleSideBL[i][ianode]->Write();
Baseline->Write();
}
*/
}
}
oFile->Close();
cout << "Clear memory" << endl;
for(Int_t imod=0; imod<nSDDmodules;imod++){
for(Int_t isid=0;isid<2;isid++){
Int_t index=2*imod+isid; //260*2 position
delete hModuleChargeMap[index];
delete hModuleCountsMap[index];
/*
for(Int_t ianode=0; ianode<anode; ianode++ ){ // BL!!!
delete hModuleSideBL[index][ianode];
delete Baseline;
}
*/
}
}
delete hModulePattern;
delete hModuleSidePattern;
delete hModuleCarlos;
}
// main method
void LEDRef_evtdis(const int runno = 615,
const int gainv = 0, /*0=low, 1=high*/
const int evtnum= -10,
int ymax=1023, // set the scale of plots
const int delay = 1) // -1=no delay, wait for input, X>=0 => sleep aprox. X sec. after making plot
{
// set ranges to plot
const int strip_f = 0; // first
const int strip_l = NSTRIPS - 1;
const int nsamples = 65; // number of ADC time samples per channel and event
const int saveplot = 0;
const int numbering = 1; // 0: no numbering, 1: nubering on each plot
const int dofit = 0; // 0: no fit, 1: try to fit the spectra
const int debug = 0;
const float gammaN = 2;
// end of setup
// Assume we are just interested in the 1st segment, _0.root below for fname*
Char_t fname[256];
sprintf(fname, "/local/data/Run_%09d.Seq_1A.Stream_0.root",runno);
cout << "TOTCHAN " << TOTCHAN << endl;
// set up a raw reader of the data
AliRawReader *rawReader = NULL;
rawReader = new AliRawReaderRoot(fname);
AliCaloRawStream *in = NULL;
in = new AliCaloRawStream(rawReader,"EMCAL");
// set up histograms
TH1F *hfit[TOTCHAN];
TF1 *f1[TOTCHAN];
char ch_label[TOTCHAN][100];
char buff1[100];
char name[80];
for(int i=0; i<TOTCHAN; i++) {
sprintf(buff1,"hfit_%d",i);
hfit[i] = new TH1F(buff1,"hfit", nsamples , -0.5, nsamples - 0.5);
hfit[i]->SetDirectory(0);
sprintf(name,"f1_%d",i);
f1[i] = new TF1(name,fitfun,0,70,5);
f1[i]->SetLineWidth(2);
f1[i]->SetLineColor(2);
// int idx = istrip + NSTRIPS * gain; // encoding used later
int gain = i / (NSTRIPS);
int istrip = i % NSTRIPS;
sprintf(ch_label[i], "Strip%02d", istrip);
}
TCanvas *cc1 = new TCanvas("cc1","3 columns of 8 strips each",600,800);
int numcol = NSETS;
int numrow = NSTRIPS_IN_SET;
cc1->Divide(numcol, numrow);
TText *t = new TText;
t->SetTextSize(0.17);
int clr[2] = {4,2}; // colors
// figure out which events we should look at
int firstevent = evtnum;
int lastevent = evtnum;
if (evtnum < 0) { // get a bunch of events
firstevent = 0;
lastevent = - evtnum;
}
if (evtnum == 0) { // get all events
firstevent = 0;
lastevent = 1000000;
}
Int_t iev =0;
AliRawEventHeaderBase *aliHeader=NULL;
while ( rawReader->NextEvent() && iev < firstevent) {
aliHeader = (AliRawEventHeaderBase*) rawReader->GetEventHeader();
iev++;
}
// loop over selected events
while ( rawReader->NextEvent() && iev <= lastevent) {
aliHeader = (AliRawEventHeaderBase*) rawReader->GetEventHeader();
int runNumber = aliHeader->Get("RunNb");
cout << "Found run number " << runNumber << endl;
// reset histograms
for(int i=0; i<TOTCHAN; i++) {
hfit[i]->Reset();
}
// get events (the "1" ensures that we actually select all events for now)
if ( 1 || aliHeader->Get("Type") == AliRawEventHeaderBase::kPhysicsEvent ) {
const UInt_t * evtId = aliHeader->GetP("Id");
int evno_raw = (int) evtId[0];
int timestamp = aliHeader->Get("Timestamp");
cout << " evno " << evno_raw
<< " size " << aliHeader->GetEventSize()
<< " type " << aliHeader->Get("Type")
<< " type name " << aliHeader->GetTypeName()
<< " timestamp " << timestamp
<< endl;
/// process_event stream
while ( in->Next() ) {
int strip = in->GetColumn();
int gain = in->GetRow();
if (in->IsLEDMonData()) {
int idx = strip + NSTRIPS*gain;
//cout << "hist idx " << idx << endl;
if (idx < 0 || idx > TOTCHAN) {
cout << "Hist idx out of range: " << idx << endl;
}
else { // reasonable range of idx
hfit[idx]->SetBinContent(in->GetTime(), in->GetSignal());
}
} // LED Ref data only
} // Raw data read
// Next: let's actually plot the data..
for (Int_t strip = strip_f; strip <= strip_l; strip++) {
int idx = strip + NSTRIPS*gainv;
// which set/column does the strip belong in
int iset = strip / NSTRIPS_IN_SET;
int within_set = strip % NSTRIPS_IN_SET;
// on which pad should we plot it?
int pad_id = (NSTRIPS_IN_SET-1-within_set)*NSETS + iset + 1;
cout << "strip " << strip
<< ". set="<< iset << ", within_set=" << within_set
<< ", pad=" << pad_id << endl;
cc1->cd(pad_id);
hfit[idx]->SetTitle("");
hfit[idx]->SetFillColor(5);
hfit[idx]->SetMaximum(ymax);
hfit[idx]->SetMinimum(0);
// we may or may not decide to fit the data
if (dofit) {
f1[i]->SetParameter(0, 0); // initial guess; zero amplitude :=)
hfit[idx]->Fit(f1[i]);
}
hfit[idx]->Draw();
if( numbering ) {
t->SetTextColor(clr[gainv]);
t->DrawTextNDC(0.65,0.65,ch_label[idx]);
}
}
// add some extra text on the canvas
// print a box showing run #, evt #, and timestamp
cc1->cd();
// first draw transparent pad
TPad *trans = new TPad("trans","",0,0,1,1);
trans->SetFillStyle(4000);
trans->Draw();
trans->cd();
// then draw text
TPaveText *label = new TPaveText(.2,.11,.8,.14,"NDC");
// label->Clear();
label->SetBorderSize(1);
label->SetFillColor(0);
label->SetLineColor(clr[gainv]);
label->SetTextColor(clr[gainv]);
//label->SetFillStyle(0);
TDatime d;
d.Set(timestamp);
sprintf(name,"Run %d, Event %d, Hist Max %d, %s",runno,iev,ymax,d.AsString());
label->AddText(name);
label->Draw();
cc1->Update();
cout << "Done" << endl;
// some shenanigans to hold the plotting, if requested
if (firstevent != lastevent) {
if (delay == -1) {
// wait for character input before proceeding
cout << " enter y to proceed " << endl;
char dummy[2];
cin >> dummy;
cout << " read " << dummy << endl;
if (strcmp(dummy, "y")==0) {
cout << " ok, continuing with event " << iev+1 << endl;
}
else {
cout << " ok, exiting " << endl;
//exit(1);
}
}
else {
cout << "Sleeping for " << delay * 500 << endl;
gSystem->Sleep(delay * 500);
}
}
// save plot, if setup/requested to do so
char plotname[100];
if (saveplot==1) {
sprintf(plotname,"Run_%d_LEDRef_Ev%d_Gain%d_MaxHist%d.gif",
runno,iev,gainv,ymax);
cout <<"SAVING plot:"<< plotname << endl;
cc1->SaveAs(plotname);
}
} // event selection
//_________________________________________________________________________________________________
void OccupancyInTimeBins(const char* input, const char* output)
{
timeResolutions.push_back(1);
timeResolutions.push_back(10);
timeResolutions.push_back(100);
AliRawReader* rawReader = AliRawReader::Create(input);
AliMUONRawStreamTrackerHP stream(rawReader);
stream.DisableWarnings();
stream.TryRecover(kTRUE);
int numberOfUsedEvents(0);
int numberOfBadEvents(0);
int numberOfEvents(0);
int numberOfPhysicsEvent(0);
int numberOfCalibrationEvent(0);
int numberOfEventsWithMCH(0);
int numberOfEventsWithoutCDH(0);
int runNumber(-1);
time_t runStart, runEnd;
AliMergeableCollection* hc(0x0);
AliCDBManager* cdbm = AliCDBManager::Instance();
if (!cdbm->IsDefaultStorageSet())
{
cdbm->SetDefaultStorage("local:///cvmfs/alice-ocdb.cern.ch/calibration/data/2015/OCDB");
}
cdbm->SetRun(0);
AliMpCDB::LoadAll();
while (rawReader->NextEvent() ) //&& numberOfEvents < 1000 )
{
rawReader->Reset();
++numberOfEvents;
if ( !rawReader->GetDataHeader() )
{
++numberOfEventsWithoutCDH;
}
if (rawReader->GetType() != AliRawEventHeaderBase::kPhysicsEvent)
{
if ( rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent )
{
++numberOfCalibrationEvent;
}
continue;
}
if (runNumber<0)
{
runNumber = rawReader->GetRunNumber();
GetTimeRange(runNumber,runStart,runEnd);
hc = new AliMergeableCollection("occ");
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
FillCollection(*hc,runStart,runEnd,timeResolutions[is]);
}
FillNumberOfPads(*hc);
}
++numberOfPhysicsEvent;
if ( numberOfPhysicsEvent % 5000 == 0 )
cout << Form("%12d events processed : %12d physics %d used ones %d bad ones [ %d with MCH information ]",
numberOfEvents,numberOfPhysicsEvent,numberOfUsedEvents,numberOfBadEvents,numberOfEventsWithMCH) << endl;
Bool_t mchThere(kFALSE);
for ( int iDDL = 0; iDDL < AliDAQ::NumberOfDdls("MUONTRK") && !mchThere; ++iDDL )
{
rawReader->Reset();
rawReader->Select("MUONTRK",iDDL,iDDL);
if (rawReader->ReadHeader() )
{
if (rawReader->GetEquipmentSize() ) mchThere = kTRUE;
}
}
if ( mchThere)
{
++numberOfEventsWithMCH;
}
else
{
continue;
}
Int_t buspatchId;
UShort_t manuId;
UChar_t manuChannel;
UShort_t adc;
stream.First();
std::map<int,int> bpValues;
while ( stream.Next(buspatchId,manuId,manuChannel,adc,kTRUE) )
{
bpValues[buspatchId]++;
}
for ( std::map<int,int>::const_iterator it = bpValues.begin(); it != bpValues.end(); ++it )
{
const int& buspatchId = it->first;
const int& bpvalue = it->second;
TString bpName = Form("BP%04d",buspatchId);
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
TH1* h = hc->Histo(Form("/BUSPATCH/HITS/%ds/%s",timeResolutions[is],bpName.Data()));
if (!h)
{
cout << "histogram not found" << endl;
continue;
}
h->Fill(rawReader->GetTimestamp(),bpvalue);
}
}
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
TH1* h = hc->Histo(Form("Nevents%ds",timeResolutions[is]));
if (!h)
{
cout << "histogram not found" << endl;
continue;
}
h->Fill(rawReader->GetTimestamp());
}
}
// Group BP histograms per DE then DDL then Chamber then Station
for ( std::vector<int>::size_type is = 0; is < timeResolutions.size(); ++is )
{
GroupByDE(*hc,timeResolutions[is]);
GroupByDDL(*hc,timeResolutions[is]);
GroupByChamber(*hc,timeResolutions[is]);
GroupByStation(*hc,timeResolutions[is]);
}
// make normalized versions of the histograms
Normalize(*hc);
TFile* fout = new TFile(output,"RECREATE");
hc->Write("occ");
delete fout;
}
/**
* Dumps the AliHLTGlobalTriggerDecision objects found in HLT output data.
*
* \param dataSource This is the path to the raw data or the ROOT/DATE file
* contining the raw data. (default is the current directory).
* \param firstEvent The event number of the first event to process. (default = 0)
* \param lastEvent The event number of the last event to process. If this is
* less than firstEvent then it is set to maximum events available
* automatically. (default = -1)
* \param output Specifies the name of a ROOT output file. This file will be
* generated and the objects written to it. If the value is NULL then
* no output is written to file. (default = NULL)
* \param debug Specifies if full debug messages should be printed.
*/
void DumpGlobalTrigger(
const char* dataSource = "./",
Int_t firstEvent = 0,
Int_t lastEvent = -1,
const char* output = NULL,
bool debug = false
)
{
if (debug)
{
AliLog::SetModuleDebugLevel("HLT", AliLog::kMaxType);
AliHLTSystem* sys = AliHLTPluginBase::GetInstance();
sys->SetGlobalLoggingLevel(kHLTLogAll);
}
gSystem->Load("libHLTrec");
TFile* file = NULL;
if (output != NULL)
{
file = new TFile(output, "RECREATE");
if (file == NULL)
{
cerr << "ERROR: Could not create file '" << output << "'." << endl;
return;
}
}
// Setup the raw reader and HLTOUT handler.
AliRawReader* rawReader = AliRawReader::Create(dataSource);
if (rawReader == NULL)
{
cerr << "ERROR: Could not create raw reader for '" << dataSource << "'." << endl;
if (file != NULL) delete file;
return;
}
if (! rawReader->IsRawReaderValid())
{
cerr << "ERROR: Raw reader is not valid for '" << dataSource << "'." << endl;
delete rawReader;
if (file != NULL) delete file;
return;
}
AliHLTOUT* hltout = AliHLTOUT::New(rawReader);
if (hltout == NULL)
{
cerr << "ERROR: Could not create an AliHLTOUT object for '" << dataSource << "'." << endl;
delete rawReader;
if (file != NULL) delete file;
return;
}
// Make sure that the lastEvent is greater than firstEvent.
if (lastEvent < firstEvent) lastEvent = rawReader->GetNumberOfEvents();
if (lastEvent < firstEvent) lastEvent = firstEvent;
// Need to call NextEvent once here or we will start at the wrong event.
if (! rawReader->NextEvent())
{
cout << "No events found in '" << dataSource << "'." << endl;
AliHLTOUT::Delete(hltout);
delete rawReader;
if (file != NULL) delete file;
return;
}
// Now step through the events.
for (int i = 0; i < firstEvent; i++) rawReader->NextEvent();
for (int i = firstEvent; i <= lastEvent; i++)
{
int result = hltout->Init();
if (result != 0)
{
cerr << "ERROR: could not initialise HLTOUT." << endl;
hltout->Reset();
continue;
}
cout << "#################### Event " << i << " in " << dataSource
<< " has event ID = " << hltout->EventId()
<< " (0x" << hex << hltout->EventId() << dec << ")"
<< " ####################" << endl;
for (result = hltout->SelectFirstDataBlock();
result >= 0;
result = hltout->SelectNextDataBlock()
)
{
AliHLTComponentDataType dt;
AliHLTUInt32_t spec = 0;
hltout->GetDataBlockDescription(dt, spec);
TObject* obj = hltout->GetDataObject();
if (obj == NULL) continue;
if (obj->IsA()->GetBaseClass("AliHLTGlobalTriggerDecision") != NULL)
{
if (dt != kAliHLTDataTypeGlobalTrigger)
{
cerr << "WARNING: Found an AliHLTGlobalTriggerDecision object in a data block of type '"
<< AliHLTComponent::DataType2Text(dt).c_str()
<< "' but expected '"
<< AliHLTComponent::DataType2Text(kAliHLTDataTypeGlobalTrigger).c_str()
<< "'." << endl;
}
if (file != NULL)
{
obj->Write(
Form("HLTGlobalDecision_event_0x%llX", hltout->EventId()),
TObject::kOverwrite
);
}
obj->Print();
}
hltout->ReleaseDataObject(obj);
}
result = hltout->Reset();
if (result != 0)
{
cerr << "ERROR: could not reset HLTOUT." << endl;
hltout->Reset();
continue;
}
rawReader->NextEvent();
}
AliHLTOUT::Delete(hltout);
delete rawReader;
if (file != NULL) delete file;
}
void DisplaySDDRawData(TString filename, Int_t firstEv=0, Int_t lastEv=5){
Bool_t writtenoutput=kFALSE;
AliITSDDLModuleMapSDD* ddlmap=new AliITSDDLModuleMapSDD();
ddlmap->SetJun09Map();
TH2F* hzphi3=new TH2F("hzphi3","Layer 3",1536,-0.5,1535.5,3584,-0.5,3584.5);
TH2F* hzphi4=new TH2F("hzphi4","Layer 4",2048,-0.5,2047.5,5632,-0.5,5631.5);
TLine** lA3=new TLine*[5];
for(Int_t ilin=0;ilin<5;ilin++){
lA3[ilin]=new TLine((ilin+1)*256,0,(ilin+1)*256,3584.5);
lA3[ilin]->SetLineColor(kGray);
lA3[ilin]->SetLineStyle(2);
}
TLine** lT3=new TLine*[13];
for(Int_t ilin=0;ilin<13;ilin++){
lT3[ilin]=new TLine(0,(ilin+1)*256,1535.5,(ilin+1)*256);
lT3[ilin]->SetLineColor(kGray);
lT3[ilin]->SetLineStyle(2);
}
TLine** lA4=new TLine*[7];
for(Int_t ilin=0;ilin<7;ilin++){
lA4[ilin]=new TLine((ilin+1)*256,0,(ilin+1)*256,5631.5);
lA4[ilin]->SetLineColor(kGray);
lA4[ilin]->SetLineStyle(2);
}
TLine** lT4=new TLine*[21];
for(Int_t ilin=0;ilin<21;ilin++){
lT4[ilin]=new TLine(0,(ilin+1)*256,2047.5,(ilin+1)*256);
lT4[ilin]->SetLineColor(kGray);
lT4[ilin]->SetLineStyle(2);
}
hzphi3->SetStats(0);
hzphi4->SetStats(0);
Int_t iev=firstEv;
AliRawReader *rd;
if(filename.Contains(".root")){
rd=new AliRawReaderRoot(filename.Data(),iev);
}else{
rd=new AliRawReaderDate(filename.Data(),iev);
}
TStopwatch *evtime=new TStopwatch();
TCanvas* c0 = new TCanvas("cd0","c0",800,800);
gStyle->SetPalette(1);
do{
c0->Clear();
c0->Divide(1,2,0.001,0.001);
evtime->Start();
printf("Event # %d\n",iev);
rd->Reset();
hzphi3->Reset();
hzphi4->Reset();
UChar_t cdhAttr=AliITSRawStreamSDD::ReadBlockAttributes(rd);
UInt_t amSamplFreq=AliITSRawStreamSDD::ReadAMSamplFreqFromCDH(cdhAttr);
AliITSRawStream* s=AliITSRawStreamSDD::CreateRawStreamSDD(rd,cdhAttr);
if(!writtenoutput){
printf("Use %s raw stream, sampling frequency %d MHz\n",s->ClassName(),amSamplFreq);
writtenoutput=kTRUE;
}
while(s->Next()){
if(s->IsCompletedModule()==kFALSE && s->IsCompletedDDL()==kFALSE){
Int_t lay,lad,det;
Int_t modID=ddlmap->GetModuleNumber(rd->GetDDLID(),s->GetCarlosId());
AliITSgeomTGeo::GetModuleId(modID,lay,lad,det);
Int_t iz=s->GetCoord1()+256*(det-1);
Int_t iphi=s->GetCoord2()+256*(lad-1)+128*s->GetChannel();
if(lay==3){
hzphi3->SetBinContent(iz+1,iphi+1,s->GetSignal());
}else if(lay==4){
hzphi4->SetBinContent(iz+1,iphi+1,s->GetSignal());
}
}
}
evtime->Stop();
printf("**** Event=%d \n",iev);
evtime->Print("u");
evtime->Reset();
iev++;
c0->cd(1);
hzphi3->Draw("colz");
for(Int_t ilin=0;ilin<5;ilin++) lA3[ilin]->Draw("same");
for(Int_t ilin=0;ilin<13;ilin++) lT3[ilin]->Draw("same");
hzphi3->GetXaxis()->SetTitle("Z (anode)");
hzphi3->GetYaxis()->SetTitle("PHI (time bin)");
c0->cd(2);
hzphi4->Draw("colz");
for(Int_t ilin=0;ilin<7;ilin++) lA4[ilin]->Draw("same");
for(Int_t ilin=0;ilin<21;ilin++) lT4[ilin]->Draw("same");
hzphi4->GetXaxis()->SetTitle("Z (anode)");
hzphi4->GetYaxis()->SetTitle("PHI (time bin)");
c0->Update();
}while(rd->NextEvent()&&iev<=lastEv);
}
void raw2treeGrid_collection()
{
// reading RAW data from test LCS
// filling histograms
// fillinf tree
// gROOT->LoadMacro("loadlibs.C");
// loadlibs();
Int_t allData[220][5];
TGrid::Connect("alien://");
TTree *fT0OutTree=new TTree("t0tree","None here");
TAlienCollection *collnum = TAlienCollection::Open("wn.xml");
Int_t numrun;
collnum->Reset();
collnum->Next();
TString buf_runnum;
TString buf_path = collnum->GetTURL() ;
for(int i=0; i<buf_path.Length();i++) {
if(buf_path(i,4)=="/raw") {
buf_runnum = buf_path(i-6,6);
numrun = buf_runnum.Atoi();
break;
}
}
TString names[220];
Int_t chvalue[220], meanchvalue[220];
AliT0LookUpKey* lookkey= new AliT0LookUpKey();
AliT0LookUpValue* lookvalue= new AliT0LookUpValue();
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage("raw://");
man->SetRun(numrun);
AliT0Parameters *fParam = AliT0Parameters::Instance();
fParam->Init();
TMap *lookup = fParam->GetMapLookup();
TMapIter *iter = new TMapIter(lookup);
for( Int_t iline=0; iline<212; iline++)
{
lookvalue = ( AliT0LookUpValue*) iter->Next();
lookkey = (AliT0LookUpKey*) lookup->GetValue((TObject*)lookvalue);
if(lookkey){
Int_t key=lookkey->GetKey();
names[key]=lookkey->GetChannelName();
fT0OutTree->Branch(Form("%s",names[key].Data()), &chvalue[key]);
}
else
{printf(" no such value %i \n", iline);}
}
Float_t meanCFD[24], meanQT1[24];
for (int ich=0; ich<24; ich++) {
meanCFD[ich] = fParam->GetCFD(ich);
meanQT1[ich] = fParam->GetQT1(ich);
}
Float_t meanOrA = fParam->GetMeanOrA();
Float_t meanOrC = fParam->GetMeanOrC();
Float_t meanTVDC = fParam->GetMeanVertex();
//new QTC
Float_t qt01mean[28] = {18712.5, 18487.5, 18487.5, 18537.5,
18562.5, 18462.5, 18537.5, 18537.5,
18537.5, 18587.5, 18587.5, 18512.5,
18512.5, 18512.5, 18487.5, 18562.5,
18537.5, 18512.5, 18537.5, 18537.5,
18512.5, 18587.5, 18562.5, 18512.5,
18358, 18350, 18374, 18362};
Float_t qt11mean[28] = {18705, 18495, 18465, 18555,
18555, 18435, 18525, 18525,
18525, 18585, 18585, 18495,
18495, 18525, 18465, 18555,
18525, 18495, 18555, 18495,
18495, 18585, 18585, 18495,
18358, 18350, 18374, 18362};
Int_t ind[26];
for (int iii=0; iii<12; iii++) ind[iii]=25;
for (int iii=12; iii<24; iii++) ind[iii]=57;
UInt_t event;
fT0OutTree->Branch("event", &event);
ULong64_t triggerMask;
fT0OutTree->Branch("triggers", &triggerMask);
TAlienCollection *coll = TAlienCollection::Open("wn.xml");
coll->Reset();
AliRawReader *reader;
while (coll->Next()) {
TString fFileName=coll->GetTURL();
//READ DATA
// TString fFileName=Form("alien:///alice/data/2015/LHC15i/000%i/raw/15000%i028.%i.root", numrun, numrun, chunk);
reader = new AliRawReaderRoot(fFileName);
if(!reader) continue;
reader = new AliRawReaderRoot(fFileName);
if(!reader) continue;
// reader->LoadEquipmentIdsMap("T0map.txt");
reader->RequireHeader(kTRUE);
for (Int_t i0=0; i0<220; i0++) {
chvalue[i0] = 0;
for (Int_t j0=0; j0<5; j0++) allData[i0][j0]=0;
}
AliT0RawReader *start = new AliT0RawReader(reader);
while (reader->NextEvent()) {
start->Next();
for (Int_t ii=0; ii<211; ii++) {
chvalue[ii] = 0;
for (Int_t iHit=0; iHit<5; iHit++)
{
allData[ii][iHit]= start->GetData(ii,iHit);
// if(allData[ii][iHit]>0) cout<<ii<<" "<<allData[ii][iHit]<<endl;
}
}
const UInt_t type =reader->GetType();
if(type != 7) continue;
triggerMask = reader->GetClassMask();
for (Int_t iHit=0; iHit<5; iHit++) {
if( allData[50][iHit]>meanTVDC-800 && allData[50][iHit]<meanTVDC+800) {
chvalue[50]=allData[50][iHit];
break;
}
}
for (Int_t in=0; in<24; in++)
{
for (Int_t iHit=0; iHit<5; iHit++) //old QTC C side
{
if (allData[2*in+ind[in]+1][iHit] > meanQT1[in]-800 &&
allData[2*in+ind[in]+1][iHit] < meanQT1[in]+800 ) {
chvalue[2*in+ind[in]+1] = allData[2*in+ind[in]+1][iHit];
break;
}
}
for (Int_t iHit=0; iHit<5; iHit++) //old QTC A side
{
if( (allData[2*in+ind[in]][iHit] > chvalue[2*in+ind[in]+1]) &&
chvalue[2*in+ind[in]+1]>0)
{
chvalue[2*in+ind[in]] = allData[2*in+ind[in]][iHit];
// printf("index %i pmt %i QTC old start %i stop %i \n",
// 2*in+ind[in], in,
// chvalue[2*in+ind[in]+1], chvalue[2*in+ind[in]]);
break;
}
}
}
for (Int_t in=0; in<12; in++)
{
chvalue[in+68+1] = allData[in+68+1][0] ;
chvalue[in+12+1] = allData[in+12+1][0] ;
for (Int_t iHit=0; iHit<5; iHit++) //CFD C side
{
if(allData[in+1][iHit] > meanCFD[in]-800 &&
allData[in+1][iHit] < meanCFD[in]+800)
{
chvalue[in+1] = allData[in+1][iHit] ;
break;
}
}
for (Int_t iHit=0; iHit<5; iHit++) //CFD A side
{
if(allData[in+1+56][iHit]>0)
if(allData[in+1+56][iHit] > meanCFD[in+12]-800 &&
allData[in+1+56][iHit] < meanCFD[in+12]+800)
{
chvalue[in+1+56] = allData[in+56+1][iHit] ;
break;
}
}
}
// new QTC
Int_t pmt;
for (Int_t ik=0; ik<106; ik+=4) {
if (ik<48) pmt=ik/4;
if (ik>47 && ik<52) pmt= 24;
if (ik>51 && ik<56) pmt= 25;
if(ik>55) pmt=(ik-8)/4;
for(Int_t iHt = 0; iHt<5; iHt++) {
if(allData[107+ik+1][iHt] > (qt01mean[pmt]-800) &&
allData[107+ik+1][iHt] < (qt01mean[pmt]+800) ) {
chvalue[107+ik+1] = allData[107+ik+1][iHt];
// printf("start newQTC 00 ik %i iHt %i pmt %i QT00 %i QT01 %i \n", ik, iHt, pmt, allData[107+ik][iHt], allData[107+ik+1][iHt]);
break;
}
}
for(Int_t iHt = 0; iHt<5; iHt++) {
if(allData[107+ik][iHt]>chvalue[107+ik+1] &&
chvalue[107+ik+1]>0) {
chvalue[107+ik]=allData[107+ik][iHt] ;
// printf("stop newQTC 00 ik %i iHt %i pmt %i QT00 %i QT01 %i \n", ik, iHt, pmt, allData[107+ik][iHt], allData[107+ik+1][iHt]);
break;
}
}
for(Int_t iHt = 0; iHt<5; iHt++) {
if( allData[107+ik+3][iHt] > (qt11mean[pmt]-800) &&
allData[107+ik+3][iHt] < (qt11mean[pmt]+800) ) {
chvalue[107+ik+3] = allData[107+ik+3][iHt];
break;
}
}
for(Int_t iHt = 0; iHt<5; iHt++) {
if( allData[107+ik+2][iHt] > chvalue[107+ik+3]&&
chvalue[107+ik+3]>0 ) {
chvalue[107+ik+2] = allData[107+ik+2][iHt];
// printf(" newQTC 11 ik %i iHt %i pmt %i QT10 %i QT11 %i \n", ik, iHt, pmt, allData[107+ik+2][iHt], allData[107+ik+3][iHt]);
break;
}
}
} //end new QTC
// Or
for(Int_t iHt = 0; iHt<5; iHt++) {
if(allData[51][iHt]>meanOrA-800 && allData[51][iHt]<meanOrA+800) {
chvalue[51]=allData[51][iHt];
break;
}
}
for(Int_t iHt = 0; iHt<5; iHt++) {
if(allData[52][iHt]>meanOrC-800 && allData[52][iHt]<meanOrC+800) {
chvalue[52]=allData[52][iHt];
break;
}
}
event++;
if(chvalue[50]>0) fT0OutTree->Fill();
} //event
start->Delete();
}
reader->Delete();
TFile *hist = new TFile("T0RAWtree.root","RECREATE");
hist->cd();
fT0OutTree ->Write();
}
