#include "SPMRoot.h"
SPMRoot::SPMRoot(const TGWindow* p, int w, int h,bool debug, char* device):TGMainFrame(p, w, h)
{
int i;
gROOT->Add(this);
TGLayoutHints* Hints = new TGLayoutHints(kLHintsTop | kLHintsLeft);
TGLayoutHints* HelpHints = new TGLayoutHints(kLHintsTop | kLHintsRight);
TGLayoutHints* MenuHints = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,0, 5, 1, 1);
mMenu = new TGMenuBar(this,w,30,kHorizontalFrame);
for(i = 0;i<NMENUS;i++) mPop[i] = new TGPopupMenu(fClient->GetRoot());
mButton[kSTARTB] = new TGTextButton(this,"RUN",kCmdStart);
mButton[kSTOPB] = new TGTextButton(this,"STOP",kCmdStop);
mButton[kPAUSEB] = new TGTextButton(this,"Pause",kCmdPause);
mPop[kFILE]->AddEntry("&Load EVO/IHX",kCmdLoadEvo);
mPop[kFILE]->AddSeparator();
mPop[kFILE]->AddEntry("L&oad Histogram definitions",kCmdLoadHist);
mPop[kFILE]->AddEntry("&Save Histograms",kCmdSaveHist);
mPop[kFILE]->AddEntry("&Auto Save Histograms",kCmdAutoSave);
mPop[kFILE]->AddSeparator();
mPop[kFILE]->AddPopup("Set &FIL Mode",mPop[kFIL]);
mPop[kFILE]->AddPopup("FIL split mode (DISK only)",mPop[kSPLIT]);
mPop[kFILE]->AddSeparator();
mPop[kFILE]->AddPopup("Level&2 trigger",mPop[kLEVEL2]);
mPop[kFILE]->AddSeparator();
mPop[kFILE]->AddEntry("E&xit",kCmdExit);
mPop[kFIL]->AddEntry("Disabled",kCmdFilMode1);
mPop[kFIL]->AddEntry("Disk",kCmdFilMode2);
mPop[kFIL]->AddEntry("Tape",kCmdFilMode3);
mPop[kFIL]->DisableEntry(kCmdFilMode3);
mPop[kFIL]->CheckEntry(kCmdFilMode1);
mPop[kSPLIT]->AddEntry("None",kCmdSplitNone);
mPop[kSPLIT]->AddEntry("100 MB",kCmdSplit1);
mPop[kSPLIT]->AddEntry("200 MB",kCmdSplit2);
mPop[kSPLIT]->AddEntry("400 MB",kCmdSplit3);
mPop[kLEVEL2]->AddEntry("&Load",kCmdL2Load);
mPop[kLEVEL2]->AddEntry("&Unload",kCmdL2Unload);
mPop[kAQUIS]->AddEntry("&Start RUN",kCmdStart);
mPop[kAQUIS]->AddEntry("S&top RUN",kCmdStop);
mPop[kAQUIS]->AddEntry("&Pause RUN",kCmdPause);
mPop[kTOOLS]->AddPopup("&Zero Histogram",mPop[kZERO]);
mPop[kTOOLS]->AddEntry("Zero &All Histograms",kCmdZeroAll);
mPop[kTOOLS]->AddSeparator();
mPop[kTOOLS]->AddEntry("&Read Scalers",kCmdReadScalers);
mPop[kTOOLS]->AddEntry("Z&ero Scalers",kCmdZeroScalers);
mPop[kTOOLS]->AddEntry("Set Scalers C&rate",kCmdScalerCrate);
mPop[kTOOLS]->AddEntry("&Set Number of Scalers",kCmdSetNScalers);
mPop[kTOOLS]->AddEntry("&Configure Scalers",kCmdConfigScalers);
mPop[kTOOLS]->AddSeparator();
mPop[kTOOLS]->AddEntry("Set C&AMAC buffer size",kCmdCamacBuffer);
mPop[kTOOLS]->AddEntry("Set &max number of parameters",kCmdNPar);
mPop[kTOOLS]->AddSeparator();
mPop[kTOOLS]->AddEntry("Set current configuration as &Default",kCmdSaveConfig);
mPop[kZERO]->AddPopup("&1-D Histo",mPop[kZERO1]);
mPop[kZERO]->AddPopup("&2-D Histo",mPop[kZERO2]);
mPop[kDISPLAY]->AddEntry("new T&Canvas",kCmdCanvas);
mPop[kDISPLAY]->AddEntry("new T&Browser",kCmdBrowser);
mPop[kDISPLAY]->AddEntry("&PelTools menu",kCmdTools);
mPop[kHELP]->AddEntry("&Help",kCmdHelp);
mPop[kHELP]->AddSeparator();
mPop[kHELP]->AddEntry("&About",kCmdAbout);
for(i=0;i<NMENUS;i++) mPop[i]->Associate(this);
mMenu->AddPopup("&File",mPop[kFILE],Hints);
mMenu->AddPopup("&Acquisition",mPop[kAQUIS],Hints);
mMenu->AddPopup("&Tools",mPop[kTOOLS],Hints);
mMenu->AddPopup("&Display",mPop[kDISPLAY],Hints);
mMenu->AddPopup("&Help",mPop[kHELP],HelpHints);
AddFrame(mMenu,MenuHints);
mStatFrame = new TGGroupFrame(this," Acquisition Status ");
TString label[] = {"Run no.","Start","Elapsed","No.Events","Saved","Lost",
"EVO file", "Hist lib","Recording Mode","L2 Trigger",
"Dead (%)","Ev.rate(1/s)","Controler"};
for(i=0;i<NLABELS;i++)
{
mLabels[i] = new TGLabel(this,label[i].Data());
mText[i] = new TGTextEntry(this,"",-1);
mText[i]->SetEdited(kFALSE);
mText[i]->SetEnabled(kFALSE);
}
mButton[kSTATUSB] = new TGTextButton(this,"STOPPED",-1);
mButton[kSTATUSB]->SetBackgroundColor(STOPPEDCOLOR);
mButton[kSTATUSB]->SetState(kButtonDisabled);
mTextView = new TGTextView(this,w-20,255);
mTextView->MapSubwindows();
Resize(w+1,h);
HandleConfigureNotify(NULL);
SetWMSizeHints(w+1, h, 100000, 100000,1,1) ;
MapSubwindows();
SetWindowName("SPM-Root acquisition system");
SetIconName("SPM-Root");
MapWindow();
mFlag[kEVOLOAD] = false;
mFlag[kHISTLOAD] = false;
mFlag[kL2LOAD] = false;
mFlag[kRUNNING] = false;
mFlag[kPAUSED] = false;
mString[kHISTLIB] = "";
mString[kL2FILE] = "";
mString[kEVOFILE] = "";
mString[kHISTFILE] = "";
mString[kFILFILE] = "";
mRegister[kRUNR] = 0;
mRegister[kNEVENTSR] = 0;
mRegister[kNSAVEDR] = 0;
mRegister[kNLOSTR] = 0;
mTimeStart = 0;
mRunTime = 0;
loadConfig();
timing=new TStopwatch();
mAquisTimer = new TTimer();
mAquisTimer->Stop();
mAquisTimer->SetObject(this);
mUpdateTimer = new TTimer(1000,kTRUE);
mUpdateTimer->Start(1000);
mUpdateTimer->SetObject(this);
mTimeStart = new TDatime();
mTimeStop = new TDatime();
setCamac(device);
if( mString[kCAMAC].BeginsWith("/dev/usb"))
mIO = new UsbIO();
else
mIO = new CamacIO();
mIO->setDebug(debug);
mRegister[kEVENTLOOPR] = 1000;
if(debug) mRegister[kEVENTLOOPR] = 5;
mDebug = debug;
updateGUI();
updateSTATS();
mSCAN = new ScanRoot(new TDirectory("SPM_Histograms","SPM Histograms directory"));
gStyle->SetPalette(1,0);
setTextView(mTextView);
mTools = new PelTools();
}
SPMRoot::~SPMRoot()
{
if(mFlag[kRUNNING]) stopRun();
}
bool SPMRoot::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
{
if(GET_MSG(msg)==kC_TEXTVIEW)
{
if(GET_SUBMSG(msg)==kTXT_ISMARKED) mTextView->Copy();
}
if(GET_MSG(msg)==kC_COMMAND)
{
if(GET_SUBMSG(msg)==kCM_BUTTON)
{
if(parm1==kCmdStart) startRun();
if(parm1==kCmdStop) stopRun(1);
if(parm1==kCmdPause) pauseRun();
updateGUI();
}
if(GET_SUBMSG(msg)==kCM_MENU)
{
if(parm1==kCmdLoadEvo) loadEVO();
if(parm1==kCmdLoadHist) loadHist();
if(parm1==kCmdSaveHist) saveHist();
if(parm1==kCmdAutoSave) setAutoSaveHist();
if(parm1==kCmdFilMode1 ||
parm1==kCmdFilMode2 ||
parm1==kCmdFilMode3) setFilMode(parm1);
if(parm1==kCmdExit) CloseWindow();
if(parm1==kCmdL2Load) l2Load();
if(parm1==kCmdL2Unload) l2Unload();
if(parm1==kCmdSplitNone) mFlag[kSPLITMODE] = false;
if(parm1==kCmdSplit1) { mFlag[kSPLITMODE] = true; mSplitSize = 1E8;}
if(parm1==kCmdSplit2) { mFlag[kSPLITMODE] = true; mSplitSize = 2E8;}
if(parm1==kCmdSplit3) { mFlag[kSPLITMODE] = true; mSplitSize = 4E8;}
if(parm1==kCmdStart) startRun();
if(parm1==kCmdStop) stopRun(1);
if(parm1==kCmdPause) pauseRun();
if(parm1==kCmdZeroAll) zeroAll();
if(parm1>=ID1D) zero(parm1);
if(parm1==kCmdReadScalers) readScalers();
if(parm1==kCmdZeroScalers) zeroScalers();
if(parm1==kCmdSetNScalers) setNScalers();
if(parm1==kCmdConfigScalers) configScalers();
if(parm1==kCmdCamacBuffer) setCamacBuffer();
if(parm1==kCmdNPar) setMaxNpar();
if(parm1==kCmdScalerCrate) setScalersCrate();
if(parm1==kCmdSaveConfig) saveConfig();
if(parm1==kCmdCanvas) new TCanvas();
if(parm1==kCmdBrowser) new TBrowser();
if(parm1==kCmdTools) mTools->menu();
if(parm1==kCmdHelp) openHelp();
if(parm1==kCmdAbout) about();
updateGUI();
}
}
return true;
}
bool SPMRoot::HandleTimer(TTimer* timer)
{
if(timer==mAquisTimer) return eventLoop();
if(timer==mUpdateTimer) updateSTATS();
return true;
}
void SPMRoot::updateGUI()
{
bool split = true;
if(!mFlag[kFILENABLE]) split = false;
if(mFlag[kFILENABLE] && mFlag[kTAPEENABLE]) split = false;
if(split)
{
mPop[kSPLIT]->EnableEntry(kCmdSplitNone);
mPop[kSPLIT]->EnableEntry(kCmdSplit1);
mPop[kSPLIT]->EnableEntry(kCmdSplit2);
mPop[kSPLIT]->EnableEntry(kCmdSplit3);
}
else
{
mPop[kSPLIT]->DisableEntry(kCmdSplitNone);
mPop[kSPLIT]->DisableEntry(kCmdSplit1);
mPop[kSPLIT]->DisableEntry(kCmdSplit2);
mPop[kSPLIT]->DisableEntry(kCmdSplit3);
}
mPop[kSPLIT]->UnCheckEntry(kCmdSplitNone);
mPop[kSPLIT]->UnCheckEntry(kCmdSplit1);
mPop[kSPLIT]->UnCheckEntry(kCmdSplit2);
mPop[kSPLIT]->UnCheckEntry(kCmdSplit3);
if(!mFlag[kSPLITMODE]) mPop[kSPLIT]->CheckEntry(kCmdSplitNone);
else
{
if(mSplitSize==1E8) mPop[kSPLIT]->CheckEntry(kCmdSplit1);
if(mSplitSize==2E8) mPop[kSPLIT]->CheckEntry(kCmdSplit2);
if(mSplitSize==4E8) mPop[kSPLIT]->CheckEntry(kCmdSplit3);
}
if(mFlag[kEVOLOAD])
{
if(!mFlag[kRUNNING])
{
mPop[kAQUIS]->EnableEntry(kCmdStart);
mPop[kAQUIS]->DisableEntry(kCmdStop);
mPop[kAQUIS]->DisableEntry(kCmdPause);
mButton[kSTARTB]->SetState(kButtonUp);
mButton[kSTOPB]->SetState(kButtonDisabled);
mButton[kPAUSEB]->SetState(kButtonDisabled);
mPop[kFILE]->EnableEntry(kCmdLoadEvo);
mPop[kFILE]->EnableEntry(kCmdLoadHist);
mPop[kFILE]->EnableEntry(kCmdAutoSave);
mPop[kFIL]->EnableEntry(kCmdFilMode1);
mPop[kFIL]->EnableEntry(kCmdFilMode2);
mPop[kSPLIT]->EnableEntry(kCmdL2Load);
mPop[kSPLIT]->EnableEntry(kCmdL2Unload);
mPop[kTOOLS]->EnableEntry(kCmdReadScalers);
mPop[kTOOLS]->EnableEntry(kCmdZeroScalers);
mPop[kTOOLS]->EnableEntry(kCmdSetNScalers);
mPop[kTOOLS]->EnableEntry(kCmdConfigScalers);
mPop[kTOOLS]->EnableEntry(kCmdCamacBuffer);
mPop[kTOOLS]->EnableEntry(kCmdNPar);
if(mFlag[kPAUSED])
{
mPop[kFILE]->DisableEntry(kCmdLoadEvo);
mButton[kSTOPB]->SetState(kButtonUp);
mPop[kAQUIS]->EnableEntry(kCmdStop);
mPop[kTOOLS]->DisableEntry(kCmdCamacBuffer);
mPop[kTOOLS]->DisableEntry(kCmdNPar);
mPop[kFIL]->DisableEntry(kCmdFilMode1);
mPop[kFIL]->DisableEntry(kCmdFilMode2);
mPop[kFIL]->DisableEntry(kCmdFilMode3);
}
}
else
{
mPop[kFILE]->DisableEntry(kCmdLoadEvo);
mPop[kAQUIS]->DisableEntry(kCmdStart);
mPop[kAQUIS]->EnableEntry(kCmdStop);
mPop[kAQUIS]->EnableEntry(kCmdPause);
mButton[kSTARTB]->SetState(kButtonDisabled);
mButton[kSTOPB]->SetState(kButtonUp);
mButton[kPAUSEB]->SetState(kButtonUp);
mPop[kFILE]->DisableEntry(kCmdLoadHist);
mPop[kFILE]->DisableEntry(kCmdAutoSave);
mPop[kFIL]->DisableEntry(kCmdFilMode1);
mPop[kFIL]->DisableEntry(kCmdFilMode2);
mPop[kFIL]->DisableEntry(kCmdFilMode3);
mPop[kSPLIT]->DisableEntry(kCmdL2Load);
mPop[kSPLIT]->DisableEntry(kCmdL2Unload);
mPop[kTOOLS]->EnableEntry(kCmdReadScalers);
mPop[kTOOLS]->EnableEntry(kCmdZeroScalers);
mPop[kTOOLS]->DisableEntry(kCmdSetNScalers);
mPop[kTOOLS]->DisableEntry(kCmdConfigScalers);
mPop[kTOOLS]->DisableEntry(kCmdCamacBuffer);
mPop[kTOOLS]->DisableEntry(kCmdNPar);
mPop[kLEVEL2]->DisableEntry(kCmdSplitNone);
mPop[kLEVEL2]->DisableEntry(kCmdSplit1);
mPop[kLEVEL2]->DisableEntry(kCmdSplit2);
mPop[kLEVEL2]->DisableEntry(kCmdSplit3);
}
}
else
{
mPop[kAQUIS]->DisableEntry(kCmdStart);
mPop[kAQUIS]->DisableEntry(kCmdStop);
mPop[kAQUIS]->DisableEntry(kCmdPause);
if(mDebug)
{
mPop[kAQUIS]->EnableEntry(kCmdStart);
mPop[kAQUIS]->EnableEntry(kCmdStop);
mPop[kAQUIS]->EnableEntry(kCmdPause);
}
mButton[kSTARTB]->SetState(kButtonDisabled);
mButton[kSTOPB]->SetState(kButtonDisabled);
mButton[kPAUSEB]->SetState(kButtonDisabled);
if(mDebug)
{
mButton[kSTARTB]->SetState(kButtonUp);
mButton[kSTOPB]->SetState(kButtonUp);
mButton[kPAUSEB]->SetState(kButtonUp);
}
mPop[kTOOLS]->DisableEntry(kCmdReadScalers);
mPop[kTOOLS]->DisableEntry(kCmdZeroScalers);
mPop[kTOOLS]->EnableEntry(kCmdSetNScalers);
mPop[kTOOLS]->EnableEntry(kCmdConfigScalers);
mPop[kTOOLS]->DisableEntry(kCmdCamacBuffer);
mPop[kTOOLS]->EnableEntry(kCmdNPar);
}
if(!mFlag[kHISTLOAD])
{
mPop[kFILE]->DisableEntry(kCmdSaveHist);
mPop[kFILE]->DisableEntry(kCmdAutoSave);
}
else
{
mPop[kFILE]->EnableEntry(kCmdSaveHist);
mPop[kFILE]->EnableEntry(kCmdAutoSave);
}
}
void SPMRoot::updateSTATS()
{
char text[200];
sprintf(text,"%d",mRegister[kRUNR]);
mText[0]->SetText(text);
if(mTimeStart)
{
int hour = mTimeStart->GetHour();
int minute = mTimeStart->GetMinute();
int seconds = mTimeStart->GetSecond();
sprintf(text,"%02d:%02d:%02d",hour,minute,seconds);
mText[1]->SetText(text);
TDatime *now;
if(mFlag[kRUNNING]) now =new TDatime(); else now = mTimeStop;
int delta = now->Get()-mTimeStart->Get();
int deltaH = delta/3600;
int deltaM = (delta%3600)/60;
int deltaS = ((delta%3600)%60);
int timeNow = now->Get();
sprintf(text,"%02d:%02d:%02d",deltaH,deltaM,deltaS);
mText[2]->SetText(text);
float dead = 0;
float rate = 0;
if(mFlag[kRUNNING])
{
delete now;
if(delta>0) dead = mDeadTime/delta;
else dead = 0;
if(mRegister[kNLASTR]!=0)
{
if((timeNow-mRegister[kNLASTR])>0) rate = (mRegister[kNEVENTSR]-mRegister[kNEVENTSLASTR])/(timeNow-mRegister[kNLASTR]);
else rate = 0;
mRegister[kNLASTR] = timeNow;
mRegister[kNEVENTSLASTR] = mRegister[kNEVENTSR];
}
else
{
mRegister[kNLASTR] = timeNow;
mRegister[kNEVENTSLASTR] = mRegister[kNEVENTSR];
}
if(mRunTime>0) if((float)delta>mRunTime) stopRun(2);
}
sprintf(text,"%6.2f",dead*100);
mText[10]->SetText(text);
sprintf(text,"%8.2f",rate);
mText[11]->SetText(text);
}
else
{
mText[1]->SetText("");
mText[2]->SetText("");
}
sprintf(text,"%d",mRegister[kNEVENTSR]);
mText[3]->SetText(text);
sprintf(text,"%d",mRegister[kNSAVEDR]);
mText[4]->SetText(text);
sprintf(text,"%d",mRegister[kNLOSTR]);
mText[5]->SetText(text);
mText[6]->SetText(mString[kEVOFILE].Data());
mText[7]->SetText(mString[kHISTLIB].Data());
mText[12]->SetText(mString[kCAMAC].Data());
if(!mFlag[kFILENABLE]) sprintf(text,"DISABLED");
else
{
if(mFlag[kTAPEENABLE]) sprintf(text,"TAPE");
else sprintf(text,"DISK: %s",mString[kFILFILE].Data());
}
mText[8]->SetText(text);
if(!mFlag[kL2LOAD]) sprintf(text,"NOT LOADED");
else sprintf(text,"%s",mString[kL2FILE].Data());
mText[9]->SetText(text);
int color = STOPPEDCOLOR;
sprintf(text,"STOPPED");
if(mFlag[kRUNNING])
{
color = RUNNINGCOLOR;
sprintf(text,"RUNNING");
}
if(mFlag[kPAUSED])
{
color = PAUSEDCOLOR;
sprintf(text,"PAUSED");
}
mButton[kSTATUSB]->SetBackgroundColor(color);
mButton[kSTATUSB]->SetText(text);
}
bool SPMRoot::startRun()
{
mRegister[kNLASTR] = 0;
if(mFlag[kPAUSED])
{
mFlag[kRUNNING] = true;
mFlag[kPAUSED] = false;
mAquisTimer->Start(1);
mIO->start();
updateGUI();
log("Acquisition has resumed");
return true;
}
mRegister[kRUNR]++;
char *title = "START NEW RUN";
int stat;
int nd = 2;
if(mFlag[kFILENABLE] || mFlag[kHISTAUTOSAVE]) nd = 3;
TString label[3],output[3];
label[0] = " RUN Number ";
label[1] = " Time limit (0 = infinite)";
label[2] = " BASE File Name (RUN NUMBER is included) ";
char text[30];
sprintf(text,"%d",mRegister[kRUNR]);
output[0] = text;
sprintf(text,"%d",(int)mRunTime);
output[1] = text;
output[2] = mString[kFILFILE2];
new TDialog(title,nd,&label[0],&output[0],&stat);
if(stat==0)
{
mRegister[kRUNR]--;
return false;
}
mString[kFILFILE2] = output[2];
int runOld = mRegister[kRUNR];
mRegister[kRUNR] = atoi(output[0].Data());
if(mFlag[kFILENABLE])
{
char file[300];
sprintf(file,"%s_%05d_%03d.fil",mString[kFILFILE2].Data(),mRegister[kRUNR],mRegister[kSPLITR]);
if(fileExists(file)) if(!overwrite(file))
{
mRegister[kRUNR] = runOld;
return false;
}
}
mRunTime = convertToSeconds((char*)output[1].Data());
if(mTimeStart) {delete mTimeStart; mTimeStart = NULL;}
mTimeStart = new TDatime();
mFlag[kRUNNING] = true;
int status = mIO->start();
if(status==kWarn) log(1,"CAMAC Connection is not open");
else
{
log(10,"-----------------------------");
log("RUN NUMBER: %d",mRegister[kRUNR]);
log("Acquisition has started");
}
mSCAN->init();
mAquisTimer->Start(1);
mRegister[kNEVENTSR] = 0;
mRegister[kNSAVEDR] = 0;
mRegister[kNLOSTR] = 0;
mDeadTime = 0;
mRegister[kSPLITR] = 0;
if(mFlag[kFILENABLE])
{
log("Raw data is being saved at:");
char file[300];
sprintf(file,"%s_%05d_%03d.fil",mString[kFILFILE2].Data(),mRegister[kRUNR],mRegister[kSPLITR]);
log(10,file);
mString[kFILFILE] = file;
mIO->openOutput(file);
}
updateGUI();
mNBytesSaved = 0;
return true;
}
bool SPMRoot::stopRun(int mode)
{
if(mode==1) if(!yesno("STOP run","Are you sure?")) return true;
pauseRun();
log("Flushing CAMAC buffers");
eventLoop(1);
mSCAN->finish();
if(mFlag[kFILENABLE])
{
log("Closing FIL file");
mIO->closeOutput();
}
if(mFlag[kHISTAUTOSAVE])
{
log("Histograms are being saved at:");
char file[300];
sprintf(file,"%s.%05d.hist.root",mString[kFILFILE2].Data(),mRegister[kRUNR]);
log(10,file);
saveHist(file);
}
mFlag[kPAUSED] =false;
mFlag[kRUNNING]=false;
log("Acquisition has stopped");
log(10,"Final statistics for run number %d",mRegister[kRUNR]);
log(10,"start time: %s total time (seconds): %s fraction dead (%): %s",mText[1]->GetText(),mText[2]->GetText(),mText[10]->GetText());
log(10,"number of events taken: %s, saved = %s, lost = %s",mText[3]->GetText(),mText[4]->GetText(),mText[5]->GetText());
log(10,"EVO file = %s",mText[6]->GetText());
log(10,"HIST file = %s",mText[7]->GetText());
log(10,"L2 file = %s",mText[9]->GetText());
log(10,"Event saving mode = %s",mText[8]->GetText());
log(10," ");
updateGUI();
if(mode==2) message(1,"STOP run","The run has stopped!");
return true;
}
bool SPMRoot::pauseRun()
{
if(mTimeStop) {delete mTimeStop; mTimeStop = NULL;}
mTimeStop = new TDatime();
mFlag[kPAUSED] = true;
mFlag[kRUNNING] = false;
mIO->stop();
mAquisTimer->Stop();
updateGUI();
log("Acquisition is paused");
return true;
}
bool SPMRoot::loadEVO()
{
mIO->closeInput();
TGFileInfo fi;
new TGFileDialog(fClient->GetRoot(),this,kFDOpen,&fi);
if(fi.fFilename) mString[kEVOFILE]=fi.fFilename;
else return false;
int stat = mIO->openInput((char*)mString[kCAMAC].Data());
if(stat!=1)
{
log(2,"Error opening CAMAC connection");
message(1,"ERROR","Error opening CAMAC connection");
mFlag[kEVOLOAD] = false;
mString[kEVOFILE] = "";
return false;
}
stat = mIO->loadEVO((char*)mString[kEVOFILE].Data());
if(stat==kWarn)
{
log(2,"Problem opening EVO/IHX FILE: Incompatible file type");
message(1,"ERROR","Problem opening EVO/IHX FILE: Incompatible file type");
mFlag[kEVOLOAD] = false;
mString[kEVOFILE] = "";
return false;
}
if(stat!=1)
{
log(2,"Error loading EVO/EVP FILE");
message(1,"ERROR","Error loading EVO/EVP FILE");
mFlag[kEVOLOAD] = false;
mString[kEVOFILE] = "";
return false;
}
int tmp = mRegister[kBUFFERSIZER];
mRegister[kBUFFERSIZER] = mIO->setBufferSize(tmp);
mFlag[kEVOLOAD] = true;
updateGUI();
log("EVO FILE loaded");
return true;
}
bool SPMRoot::loadHist()
{
int stat, n,i;
int id1d=ID1D;
int id2d=ID2D;
TGFileInfo fi;
new TGFileDialog(fClient->GetRoot(),this,kFDOpen,&fi);
if(!fi.fFilename) return false;
mString[kHISTLIB]="";
mFlag[kHISTLOAD] = false;
stat = mSCAN->loadHist(fi.fFilename);
if(stat==1) log(2,"Problem Compiling histogram code");
if(stat==2) log(2,"Not a valid histogram code");
if(stat==3) log(2,"Problem finding ScanRoot pointer");
if(stat==4) log(2,"Problem booking histograms");
if(stat!=0) return false;
for(i=ID1D;i<ID1D+MAXHIST;i++)
if(mPop[kZERO1]->GetEntry(i)) mPop[kZERO1]->DeleteEntry(i);
else break;
for(i=ID2D;i<ID2D+MAXHIST;i++)
if(mPop[kZERO2]->GetEntry(i)) mPop[kZERO2]->DeleteEntry(i);
else break;
TList* l = mSCAN->getDir()->GetList();
if(l)
{
n = l->GetSize();
if(n>0)
{
for(i=0;i<n;i++)
{
TObject *o = l->At(i);
TString n = o->ClassName();
if(n.BeginsWith("TH1")) mPop[kZERO1]->AddEntry(o->GetName(),id1d++);
if(n.BeginsWith("TH2")) mPop[kZERO2]->AddEntry(o->GetName(),id2d++);
}
}
}
mFlag[kHISTLOAD] = true;
mString[kHISTLIB]=fi.fFilename;
updateGUI();
log("Histograms loaded");
return true;
}
bool SPMRoot::saveHist(char* file)
{
if(!file)
{
TGFileInfo fi;
new TGFileDialog(fClient->GetRoot(),this,kFDSave,&fi);
if(fi.fFilename) return saveHist((char*)fi.fFilename);
else return true;
}
if(fileExists(file)) if(!overwrite(file))
{
saveHist();
return true;
}
mSCAN->saveHist(file);
log("Histograms saved");
return true;
}
bool SPMRoot::setAutoSaveHist()
{
mFlag[kHISTAUTOSAVE] = !mFlag[kHISTAUTOSAVE];
if(mFlag[kHISTAUTOSAVE]) mPop[kFILE]->CheckEntry(kCmdAutoSave);
else mPop[kFILE]->UnCheckEntry(kCmdAutoSave);
return true;
}
bool SPMRoot::setFilMode(int mode)
{
if(mode==kCmdFilMode1)
{
mPop[kFIL]->CheckEntry(kCmdFilMode1);
mPop[kFIL]->UnCheckEntry(kCmdFilMode2);
mPop[kFIL]->UnCheckEntry(kCmdFilMode3);
mFlag[kFILENABLE] = false;
mFlag[kTAPEENABLE] = false;
}
if(mode==kCmdFilMode2)
{
mPop[kFIL]->UnCheckEntry(kCmdFilMode1);
mPop[kFIL]->CheckEntry(kCmdFilMode2);
mPop[kFIL]->UnCheckEntry(kCmdFilMode3);
mFlag[kFILENABLE] = true;
mFlag[kTAPEENABLE] = false;
}
if(mode==kCmdFilMode3)
{
mPop[kFIL]->UnCheckEntry(kCmdFilMode1);
mPop[kFIL]->UnCheckEntry(kCmdFilMode2);
mPop[kFIL]->CheckEntry(kCmdFilMode3);
mFlag[kFILENABLE] = true;
mFlag[kTAPEENABLE] = true;
}
return true;
}
bool SPMRoot::l2Load()
{
int stat;
TGFileInfo fi;
new TGFileDialog(fClient->GetRoot(),this,kFDOpen,&fi);
if(!fi.fFilename) return false;
mString[kL2FILE]="";
mFlag[kL2LOAD] = false;
stat = mSCAN->loadL2(fi.fFilename);
if(stat==1) log(2,"Problem Compiling L2 code");
if(stat==2) log(2,"Not a valid L2 code");
if(stat==3) log(2,"Problem finding ScanRoot pointer");
if(stat==4) log(2,"Problem initializing L2");
if(stat!=0) return false;
mFlag[kL2LOAD] = true;
updateGUI();
log("L2 trigger loaded");
return true;
}
bool SPMRoot::l2Unload()
{
mString[kL2FILE]="";
mFlag[kL2LOAD] = false;
log("L2 trigger unloaded");
return true;
}
bool SPMRoot::zeroAll()
{
if(!yesno("ZERO ALL histograms","Are you sure about this?")) return true;
mSCAN->zero();
return true;
}
bool SPMRoot::zero(int id)
{
TString n;
if(id>=ID1D && id<ID1D+MAXHIST) n = mPop[kZERO1]->GetEntry(id)->GetName();
if(id>=ID2D && id<ID2D+MAXHIST) n = mPop[kZERO2]->GetEntry(id)->GetName();
mSCAN->zero((char*)n.Data());
return true;
}
bool SPMRoot::readScalers()
{
log("Scalers on crate number %d",mRegister[kSCALERCRATER]);
log(10,"--------------------------------------------------");
for(int i=0;i<mRegister[kNSCALERSR];i++)
{
int value[16];
mIO->readScalers(mScalerId[i],value,mRegister[kSCALERCRATER]);
log(10," ");
log(10,"Scaler id %d",mScalerId[i]);
for(int j=0;j<3;j++) log(10,"|%2d = %10d |%2d = %10d |%2d = %10d |%2d = %10d|",j*4,value[j*4],j*4+1,value[j*4+1],j*4+2,value[j*4+2],j*4+3,value[j*4+3]);
log(10," ");
}
return true;
}
bool SPMRoot::zeroScalers()
{
if(!yesno("ZERO ALL scalers","Are you sure about this?")) return true;
for(int i=0;i<mRegister[kNSCALERSR];i++) mIO->clearScalers(mScalerId[i],mRegister[kSCALERCRATER]);
return true;
}
bool SPMRoot::setCamacBuffer()
{
char *title = "CAMAC buffer size";
int stat;
int nd = 1;
TString label,output;
label = " Buffer size (Bytes) ";
char text[30];
sprintf(text,"%d",mRegister[kBUFFERSIZER]);
output = text;
new TDialog(title,nd,&label,&output,&stat);
if(stat==0) return false;
if(mIO) mRegister[kBUFFERSIZER] = mIO->setBufferSize(atoi(output.Data()));
return true;
}
bool SPMRoot::setMaxNpar()
{
char *title = "MAX number of parameters";
int stat;
int nd = 1;
TString label,output;
label = " Max Number of parameters ";
char text[30];
sprintf(text,"%d",mRegister[kMAXNPARR]);
output = text;
new TDialog(title,nd,&label,&output,&stat);
if(stat==0) return false;
mRegister[kMAXNPARR] = atoi(output.Data());
if(mRegister[kMAXNPARR]>MAXPARAM) mRegister[kMAXNPARR] = MAXPARAM;
log("Number max. of parameters = %d - LIMIT = %d",mRegister[kMAXNPARR],MAXPARAM);
return true;
}
bool SPMRoot::setNScalers()
{
char *title = "Number of scalers";
int stat;
int nd = 1;
TString label,output;
label = " Number of scalers ";
char text[30];
sprintf(text,"%d",mRegister[kNSCALERSR]);
output = text;
new TDialog(title,nd,&label,&output,&stat);
if(stat==0) return false;
mRegister[kNSCALERSR] = atoi(output.Data());
if(mRegister[kNSCALERSR]>MAXSCALERS) mRegister[kNSCALERSR] = MAXSCALERS;
return true;
}
bool SPMRoot::setScalersCrate()
{
char *title = "Scalers CAMAC Crate";
int stat;
int nd = 1;
TString label,output;
label = " Scaler CAMAC crate Id ";
char text[30];
sprintf(text,"%d",mRegister[kSCALERCRATER]);
output = text;
new TDialog(title,nd,&label,&output,&stat);
if(stat==0) return false;
mRegister[kSCALERCRATER] = atoi(output.Data());
return true;
}
bool SPMRoot::configScalers()
{
char *title = "Scalers CAMAC Crate";
int stat;
int nd = mRegister[kNSCALERSR];
TString label[30],output[30];
char text[80];
for(int i=0;i<mRegister[kNSCALERSR];i++)
{
sprintf(text," Scaler number %d ",i);
label[i] = text;
sprintf(text,"%d",mScalerId[i]);
output[i] = text;
}
new TDialog(title,nd,&label[0],&output[0],&stat);
if(stat==0) return false;
for(int i=0;i<mRegister[kNSCALERSR];i++) mScalerId[i] = atoi(output[i].Data());
return true;
}
bool SPMRoot::about()
{
char m[200];
sprintf(m,"SPMRoot v. %1d.%02d (2003-%4d) \n by Alexandre Suaide",SPMROOT_VERSION,SPMROOT_REVISION,PELLIB_YEAR);
message(2,"About",m);
return true;
}
bool SPMRoot::eventLoop(int mode)
{
int nevents = 0;
int stat = 0;
bool saveEvent;
int bytes = 0;
do
{
stat = mIO->readEvent((short)mRegister[kMAXNPARR],npar,&par[0]);
if(stat==1)
{
bytes = mIO->getCurrentEventSize();
timing->Reset();
timing->Start();
nevents++;
mRegister[kNEVENTSR]++;
saveEvent = mSCAN->process(npar,&(par[0]));
if(saveEvent)
{
if(mFlag[kFILENABLE])
{
mIO->writeEvent();
mRegister[kNSAVEDR]++;
mNBytesSaved+=(long)bytes;
if(mFlag[kSPLITMODE] && mNBytesSaved>mSplitSize && !mFlag[kTAPEENABLE])
{
mNBytesSaved = 0;
mIO->closeOutput();
mRegister[kSPLITR]++;
char file[300];
log("File is larger than %d MB - Raw data is now being saved at:",(long)(mSplitSize/1.0E6));
sprintf(file,"%s_%05d_%03d.fil",mString[kFILFILE2].Data(),mRegister[kRUNR],mRegister[kSPLITR]);
log(10,file);
mString[kFILFILE] = file;
mIO->openOutput(file);
}
}
}
timing->Stop();
mDeadTime +=timing->RealTime();
}
} while(stat==1 && (nevents<mRegister[kEVENTLOOPR] || mode==1) );
mRegister[kNLOSTR] = mIO->getNEventsLost();
if(mode==0)
{
if(stat==2) mAquisTimer->Start(200);
else mAquisTimer->Start(1);
}
return true;
}
void SPMRoot::CloseWindow()
{
if(!yesno("Quit Program","Quit SPM-Root acquisition system?")) return;
if(mFlag[kRUNNING]) stopRun();
gROOT->ProcessLine(".q");
return;
}
Bool_t SPMRoot::HandleConfigureNotify(Event_t* event)
{
if(event) TGMainFrame::HandleConfigureNotify(event);
int w = GetWidth();
int h = GetHeight();
mButton[kSTARTB]->MoveResize(0,25,w/3,25);
mButton[kSTOPB]->MoveResize(w/3,25,w/3,25);
mButton[kPAUSEB]->MoveResize(2*w/3,25,w/3,25);
mStatFrame->MoveResize(4,55,w-8,h-60);
int x[] = {10,10,150,150,150,290,10,10,10,10,290,10,290};
int y[] = {80,105,105,80,130,130,155,180,205,230,105,130,80};
int xx[] = {75,75,210,210,210,350,75,75,110,110,350,75,350};
int ww[] = {70,70,75,75,75,87,w-88,w-88,w-123,w-123,87,70,87};
int hh[] = {20,20,20,20,20,20,20,20,20,20,20,20,20};
for(int i=0;i<NLABELS;i++)
{
mLabels[i]->Move(x[i],y[i]);
mText[i]->MoveResize(xx[i],y[i],ww[i],hh[i]);
}
mButton[kSTATUSB]->MoveResize(10,260,w-20,30);
mTextView->MoveResize(10,300,w-20,h-300-10);
return kTRUE;
}
void SPMRoot::loadConfig()
{
int i;
char line[200];
TString file = gSystem->Getenv("HOME");
file += "/.spmroot";
if(!fileExists((char*)file.Data()))
{
file = gSystem->Getenv("PELLETRON");
file +="/pelLib/SPMRoot/default.spmroot";
}
ifstream in((char*)file.Data());
in >> line; mString[kCAMAC] = line;
in >> line; mString[kFILFILE2] = line;
in >> mRegister[kSCALERCRATER];
in >> mRegister[kNSCALERSR];
for(i=0;i<MAXSCALERS;i++) in >> mScalerId[i];
in >> mRegister[kBUFFERSIZER];
in >> mRegister[kMAXNPARR];
in >> i;
if(i==0) mFlag[kFILENABLE] = false; else mFlag[kFILENABLE] = true;
if(i==2) mFlag[kTAPEENABLE] = true; else mFlag[kTAPEENABLE] = false;
in >> i;
if(mFlag[kTAPEENABLE]) i=0;
if(i==0) mFlag[kSPLITMODE] = false;
else
{
mFlag[kSPLITMODE] = true;
if(i==1) mSplitSize = 1E8;
if(i==2) mSplitSize = 2E8;
if(i==3) mSplitSize = 4E8;
}
in >> i;
if(i==0) mFlag[kHISTAUTOSAVE] = false; else mFlag[kHISTAUTOSAVE] = true;
if(mFlag[kHISTAUTOSAVE]) mPop[kFILE]->CheckEntry(kCmdAutoSave);
else mPop[kFILE]->UnCheckEntry(kCmdAutoSave);
in.close();
return;
}
void SPMRoot::saveConfig()
{
int i;
TString file = gSystem->Getenv("HOME");
file += "/.spmroot";
ofstream out((char*)file.Data());
out << mString[kCAMAC].Data() << endl;
out << mString[kFILFILE2].Data() << endl;
out << mRegister[kSCALERCRATER]<< endl;;
out << mRegister[kNSCALERSR]<< endl;
for(i=0;i<MAXSCALERS;i++) out<< mScalerId[i]<<endl;
out << mRegister[kBUFFERSIZER] <<endl;
out << mRegister[kMAXNPARR]<<endl;
i = 0;
if(mFlag[kFILENABLE])
{
i = 1;
if(mFlag[kTAPEENABLE]) i = 2;
}
out <<i<< endl;
i = 0;
if(mFlag[kSPLITMODE])
{
if(mSplitSize == 1E8) i=1;
if(mSplitSize == 2E8) i=2;
if(mSplitSize == 4E8) i=3;
}
out <<i<<endl;
i=0;
if(mFlag[kHISTAUTOSAVE]) i = 1;
out <<i<<endl;
out.close();
message(1,"Message","The current configuration is saved!");
return;
}