ROOT logo
#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();
  
  // creating acquisition timer
  timing=new TStopwatch();
  mAquisTimer = new TTimer();
  mAquisTimer->Stop();
  mAquisTimer->SetObject(this);
  
  // creating GUI update timer
  mUpdateTimer = new TTimer(1000,kTRUE);
  mUpdateTimer->Start(1000);
  mUpdateTimer->SetObject(this);
  
  mTimeStart = new TDatime();
  mTimeStop = new TDatime();
  
  // creating CamacIO object
	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)
{
  //cout <<"msg = "<<msg<<"  parm1 = "<<parm1<<"  parm2 = "<<parm2<<endl;
  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(); // start button
      if(parm1==kCmdStop)  stopRun(1); // stop button
      if(parm1==kCmdPause) pauseRun(); // pause button
      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()
{
  
  // update kSPLIT mode
  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); 
  }
  
  // update when running
  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[kFIL]->EnableEntry(kCmdFilMode3);
      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;
  
  // deleting histogram entries from menu...
  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)
{
  // mode = 0 means normal data taking
  // mode = 1 means that run is stopped and we are flushing the buffers
  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;
}












 SPMRoot.cxx:1
 SPMRoot.cxx:2
 SPMRoot.cxx:3
 SPMRoot.cxx:4
 SPMRoot.cxx:5
 SPMRoot.cxx:6
 SPMRoot.cxx:7
 SPMRoot.cxx:8
 SPMRoot.cxx:9
 SPMRoot.cxx:10
 SPMRoot.cxx:11
 SPMRoot.cxx:12
 SPMRoot.cxx:13
 SPMRoot.cxx:14
 SPMRoot.cxx:15
 SPMRoot.cxx:16
 SPMRoot.cxx:17
 SPMRoot.cxx:18
 SPMRoot.cxx:19
 SPMRoot.cxx:20
 SPMRoot.cxx:21
 SPMRoot.cxx:22
 SPMRoot.cxx:23
 SPMRoot.cxx:24
 SPMRoot.cxx:25
 SPMRoot.cxx:26
 SPMRoot.cxx:27
 SPMRoot.cxx:28
 SPMRoot.cxx:29
 SPMRoot.cxx:30
 SPMRoot.cxx:31
 SPMRoot.cxx:32
 SPMRoot.cxx:33
 SPMRoot.cxx:34
 SPMRoot.cxx:35
 SPMRoot.cxx:36
 SPMRoot.cxx:37
 SPMRoot.cxx:38
 SPMRoot.cxx:39
 SPMRoot.cxx:40
 SPMRoot.cxx:41
 SPMRoot.cxx:42
 SPMRoot.cxx:43
 SPMRoot.cxx:44
 SPMRoot.cxx:45
 SPMRoot.cxx:46
 SPMRoot.cxx:47
 SPMRoot.cxx:48
 SPMRoot.cxx:49
 SPMRoot.cxx:50
 SPMRoot.cxx:51
 SPMRoot.cxx:52
 SPMRoot.cxx:53
 SPMRoot.cxx:54
 SPMRoot.cxx:55
 SPMRoot.cxx:56
 SPMRoot.cxx:57
 SPMRoot.cxx:58
 SPMRoot.cxx:59
 SPMRoot.cxx:60
 SPMRoot.cxx:61
 SPMRoot.cxx:62
 SPMRoot.cxx:63
 SPMRoot.cxx:64
 SPMRoot.cxx:65
 SPMRoot.cxx:66
 SPMRoot.cxx:67
 SPMRoot.cxx:68
 SPMRoot.cxx:69
 SPMRoot.cxx:70
 SPMRoot.cxx:71
 SPMRoot.cxx:72
 SPMRoot.cxx:73
 SPMRoot.cxx:74
 SPMRoot.cxx:75
 SPMRoot.cxx:76
 SPMRoot.cxx:77
 SPMRoot.cxx:78
 SPMRoot.cxx:79
 SPMRoot.cxx:80
 SPMRoot.cxx:81
 SPMRoot.cxx:82
 SPMRoot.cxx:83
 SPMRoot.cxx:84
 SPMRoot.cxx:85
 SPMRoot.cxx:86
 SPMRoot.cxx:87
 SPMRoot.cxx:88
 SPMRoot.cxx:89
 SPMRoot.cxx:90
 SPMRoot.cxx:91
 SPMRoot.cxx:92
 SPMRoot.cxx:93
 SPMRoot.cxx:94
 SPMRoot.cxx:95
 SPMRoot.cxx:96
 SPMRoot.cxx:97
 SPMRoot.cxx:98
 SPMRoot.cxx:99
 SPMRoot.cxx:100
 SPMRoot.cxx:101
 SPMRoot.cxx:102
 SPMRoot.cxx:103
 SPMRoot.cxx:104
 SPMRoot.cxx:105
 SPMRoot.cxx:106
 SPMRoot.cxx:107
 SPMRoot.cxx:108
 SPMRoot.cxx:109
 SPMRoot.cxx:110
 SPMRoot.cxx:111
 SPMRoot.cxx:112
 SPMRoot.cxx:113
 SPMRoot.cxx:114
 SPMRoot.cxx:115
 SPMRoot.cxx:116
 SPMRoot.cxx:117
 SPMRoot.cxx:118
 SPMRoot.cxx:119
 SPMRoot.cxx:120
 SPMRoot.cxx:121
 SPMRoot.cxx:122
 SPMRoot.cxx:123
 SPMRoot.cxx:124
 SPMRoot.cxx:125
 SPMRoot.cxx:126
 SPMRoot.cxx:127
 SPMRoot.cxx:128
 SPMRoot.cxx:129
 SPMRoot.cxx:130
 SPMRoot.cxx:131
 SPMRoot.cxx:132
 SPMRoot.cxx:133
 SPMRoot.cxx:134
 SPMRoot.cxx:135
 SPMRoot.cxx:136
 SPMRoot.cxx:137
 SPMRoot.cxx:138
 SPMRoot.cxx:139
 SPMRoot.cxx:140
 SPMRoot.cxx:141
 SPMRoot.cxx:142
 SPMRoot.cxx:143
 SPMRoot.cxx:144
 SPMRoot.cxx:145
 SPMRoot.cxx:146
 SPMRoot.cxx:147
 SPMRoot.cxx:148
 SPMRoot.cxx:149
 SPMRoot.cxx:150
 SPMRoot.cxx:151
 SPMRoot.cxx:152
 SPMRoot.cxx:153
 SPMRoot.cxx:154
 SPMRoot.cxx:155
 SPMRoot.cxx:156
 SPMRoot.cxx:157
 SPMRoot.cxx:158
 SPMRoot.cxx:159
 SPMRoot.cxx:160
 SPMRoot.cxx:161
 SPMRoot.cxx:162
 SPMRoot.cxx:163
 SPMRoot.cxx:164
 SPMRoot.cxx:165
 SPMRoot.cxx:166
 SPMRoot.cxx:167
 SPMRoot.cxx:168
 SPMRoot.cxx:169
 SPMRoot.cxx:170
 SPMRoot.cxx:171
 SPMRoot.cxx:172
 SPMRoot.cxx:173
 SPMRoot.cxx:174
 SPMRoot.cxx:175
 SPMRoot.cxx:176
 SPMRoot.cxx:177
 SPMRoot.cxx:178
 SPMRoot.cxx:179
 SPMRoot.cxx:180
 SPMRoot.cxx:181
 SPMRoot.cxx:182
 SPMRoot.cxx:183
 SPMRoot.cxx:184
 SPMRoot.cxx:185
 SPMRoot.cxx:186
 SPMRoot.cxx:187
 SPMRoot.cxx:188
 SPMRoot.cxx:189
 SPMRoot.cxx:190
 SPMRoot.cxx:191
 SPMRoot.cxx:192
 SPMRoot.cxx:193
 SPMRoot.cxx:194
 SPMRoot.cxx:195
 SPMRoot.cxx:196
 SPMRoot.cxx:197
 SPMRoot.cxx:198
 SPMRoot.cxx:199
 SPMRoot.cxx:200
 SPMRoot.cxx:201
 SPMRoot.cxx:202
 SPMRoot.cxx:203
 SPMRoot.cxx:204
 SPMRoot.cxx:205
 SPMRoot.cxx:206
 SPMRoot.cxx:207
 SPMRoot.cxx:208
 SPMRoot.cxx:209
 SPMRoot.cxx:210
 SPMRoot.cxx:211
 SPMRoot.cxx:212
 SPMRoot.cxx:213
 SPMRoot.cxx:214
 SPMRoot.cxx:215
 SPMRoot.cxx:216
 SPMRoot.cxx:217
 SPMRoot.cxx:218
 SPMRoot.cxx:219
 SPMRoot.cxx:220
 SPMRoot.cxx:221
 SPMRoot.cxx:222
 SPMRoot.cxx:223
 SPMRoot.cxx:224
 SPMRoot.cxx:225
 SPMRoot.cxx:226
 SPMRoot.cxx:227
 SPMRoot.cxx:228
 SPMRoot.cxx:229
 SPMRoot.cxx:230
 SPMRoot.cxx:231
 SPMRoot.cxx:232
 SPMRoot.cxx:233
 SPMRoot.cxx:234
 SPMRoot.cxx:235
 SPMRoot.cxx:236
 SPMRoot.cxx:237
 SPMRoot.cxx:238
 SPMRoot.cxx:239
 SPMRoot.cxx:240
 SPMRoot.cxx:241
 SPMRoot.cxx:242
 SPMRoot.cxx:243
 SPMRoot.cxx:244
 SPMRoot.cxx:245
 SPMRoot.cxx:246
 SPMRoot.cxx:247
 SPMRoot.cxx:248
 SPMRoot.cxx:249
 SPMRoot.cxx:250
 SPMRoot.cxx:251
 SPMRoot.cxx:252
 SPMRoot.cxx:253
 SPMRoot.cxx:254
 SPMRoot.cxx:255
 SPMRoot.cxx:256
 SPMRoot.cxx:257
 SPMRoot.cxx:258
 SPMRoot.cxx:259
 SPMRoot.cxx:260
 SPMRoot.cxx:261
 SPMRoot.cxx:262
 SPMRoot.cxx:263
 SPMRoot.cxx:264
 SPMRoot.cxx:265
 SPMRoot.cxx:266
 SPMRoot.cxx:267
 SPMRoot.cxx:268
 SPMRoot.cxx:269
 SPMRoot.cxx:270
 SPMRoot.cxx:271
 SPMRoot.cxx:272
 SPMRoot.cxx:273
 SPMRoot.cxx:274
 SPMRoot.cxx:275
 SPMRoot.cxx:276
 SPMRoot.cxx:277
 SPMRoot.cxx:278
 SPMRoot.cxx:279
 SPMRoot.cxx:280
 SPMRoot.cxx:281
 SPMRoot.cxx:282
 SPMRoot.cxx:283
 SPMRoot.cxx:284
 SPMRoot.cxx:285
 SPMRoot.cxx:286
 SPMRoot.cxx:287
 SPMRoot.cxx:288
 SPMRoot.cxx:289
 SPMRoot.cxx:290
 SPMRoot.cxx:291
 SPMRoot.cxx:292
 SPMRoot.cxx:293
 SPMRoot.cxx:294
 SPMRoot.cxx:295
 SPMRoot.cxx:296
 SPMRoot.cxx:297
 SPMRoot.cxx:298
 SPMRoot.cxx:299
 SPMRoot.cxx:300
 SPMRoot.cxx:301
 SPMRoot.cxx:302
 SPMRoot.cxx:303
 SPMRoot.cxx:304
 SPMRoot.cxx:305
 SPMRoot.cxx:306
 SPMRoot.cxx:307
 SPMRoot.cxx:308
 SPMRoot.cxx:309
 SPMRoot.cxx:310
 SPMRoot.cxx:311
 SPMRoot.cxx:312
 SPMRoot.cxx:313
 SPMRoot.cxx:314
 SPMRoot.cxx:315
 SPMRoot.cxx:316
 SPMRoot.cxx:317
 SPMRoot.cxx:318
 SPMRoot.cxx:319
 SPMRoot.cxx:320
 SPMRoot.cxx:321
 SPMRoot.cxx:322
 SPMRoot.cxx:323
 SPMRoot.cxx:324
 SPMRoot.cxx:325
 SPMRoot.cxx:326
 SPMRoot.cxx:327
 SPMRoot.cxx:328
 SPMRoot.cxx:329
 SPMRoot.cxx:330
 SPMRoot.cxx:331
 SPMRoot.cxx:332
 SPMRoot.cxx:333
 SPMRoot.cxx:334
 SPMRoot.cxx:335
 SPMRoot.cxx:336
 SPMRoot.cxx:337
 SPMRoot.cxx:338
 SPMRoot.cxx:339
 SPMRoot.cxx:340
 SPMRoot.cxx:341
 SPMRoot.cxx:342
 SPMRoot.cxx:343
 SPMRoot.cxx:344
 SPMRoot.cxx:345
 SPMRoot.cxx:346
 SPMRoot.cxx:347
 SPMRoot.cxx:348
 SPMRoot.cxx:349
 SPMRoot.cxx:350
 SPMRoot.cxx:351
 SPMRoot.cxx:352
 SPMRoot.cxx:353
 SPMRoot.cxx:354
 SPMRoot.cxx:355
 SPMRoot.cxx:356
 SPMRoot.cxx:357
 SPMRoot.cxx:358
 SPMRoot.cxx:359
 SPMRoot.cxx:360
 SPMRoot.cxx:361
 SPMRoot.cxx:362
 SPMRoot.cxx:363
 SPMRoot.cxx:364
 SPMRoot.cxx:365
 SPMRoot.cxx:366
 SPMRoot.cxx:367
 SPMRoot.cxx:368
 SPMRoot.cxx:369
 SPMRoot.cxx:370
 SPMRoot.cxx:371
 SPMRoot.cxx:372
 SPMRoot.cxx:373
 SPMRoot.cxx:374
 SPMRoot.cxx:375
 SPMRoot.cxx:376
 SPMRoot.cxx:377
 SPMRoot.cxx:378
 SPMRoot.cxx:379
 SPMRoot.cxx:380
 SPMRoot.cxx:381
 SPMRoot.cxx:382
 SPMRoot.cxx:383
 SPMRoot.cxx:384
 SPMRoot.cxx:385
 SPMRoot.cxx:386
 SPMRoot.cxx:387
 SPMRoot.cxx:388
 SPMRoot.cxx:389
 SPMRoot.cxx:390
 SPMRoot.cxx:391
 SPMRoot.cxx:392
 SPMRoot.cxx:393
 SPMRoot.cxx:394
 SPMRoot.cxx:395
 SPMRoot.cxx:396
 SPMRoot.cxx:397
 SPMRoot.cxx:398
 SPMRoot.cxx:399
 SPMRoot.cxx:400
 SPMRoot.cxx:401
 SPMRoot.cxx:402
 SPMRoot.cxx:403
 SPMRoot.cxx:404
 SPMRoot.cxx:405
 SPMRoot.cxx:406
 SPMRoot.cxx:407
 SPMRoot.cxx:408
 SPMRoot.cxx:409
 SPMRoot.cxx:410
 SPMRoot.cxx:411
 SPMRoot.cxx:412
 SPMRoot.cxx:413
 SPMRoot.cxx:414
 SPMRoot.cxx:415
 SPMRoot.cxx:416
 SPMRoot.cxx:417
 SPMRoot.cxx:418
 SPMRoot.cxx:419
 SPMRoot.cxx:420
 SPMRoot.cxx:421
 SPMRoot.cxx:422
 SPMRoot.cxx:423
 SPMRoot.cxx:424
 SPMRoot.cxx:425
 SPMRoot.cxx:426
 SPMRoot.cxx:427
 SPMRoot.cxx:428
 SPMRoot.cxx:429
 SPMRoot.cxx:430
 SPMRoot.cxx:431
 SPMRoot.cxx:432
 SPMRoot.cxx:433
 SPMRoot.cxx:434
 SPMRoot.cxx:435
 SPMRoot.cxx:436
 SPMRoot.cxx:437
 SPMRoot.cxx:438
 SPMRoot.cxx:439
 SPMRoot.cxx:440
 SPMRoot.cxx:441
 SPMRoot.cxx:442
 SPMRoot.cxx:443
 SPMRoot.cxx:444
 SPMRoot.cxx:445
 SPMRoot.cxx:446
 SPMRoot.cxx:447
 SPMRoot.cxx:448
 SPMRoot.cxx:449
 SPMRoot.cxx:450
 SPMRoot.cxx:451
 SPMRoot.cxx:452
 SPMRoot.cxx:453
 SPMRoot.cxx:454
 SPMRoot.cxx:455
 SPMRoot.cxx:456
 SPMRoot.cxx:457
 SPMRoot.cxx:458
 SPMRoot.cxx:459
 SPMRoot.cxx:460
 SPMRoot.cxx:461
 SPMRoot.cxx:462
 SPMRoot.cxx:463
 SPMRoot.cxx:464
 SPMRoot.cxx:465
 SPMRoot.cxx:466
 SPMRoot.cxx:467
 SPMRoot.cxx:468
 SPMRoot.cxx:469
 SPMRoot.cxx:470
 SPMRoot.cxx:471
 SPMRoot.cxx:472
 SPMRoot.cxx:473
 SPMRoot.cxx:474
 SPMRoot.cxx:475
 SPMRoot.cxx:476
 SPMRoot.cxx:477
 SPMRoot.cxx:478
 SPMRoot.cxx:479
 SPMRoot.cxx:480
 SPMRoot.cxx:481
 SPMRoot.cxx:482
 SPMRoot.cxx:483
 SPMRoot.cxx:484
 SPMRoot.cxx:485
 SPMRoot.cxx:486
 SPMRoot.cxx:487
 SPMRoot.cxx:488
 SPMRoot.cxx:489
 SPMRoot.cxx:490
 SPMRoot.cxx:491
 SPMRoot.cxx:492
 SPMRoot.cxx:493
 SPMRoot.cxx:494
 SPMRoot.cxx:495
 SPMRoot.cxx:496
 SPMRoot.cxx:497
 SPMRoot.cxx:498
 SPMRoot.cxx:499
 SPMRoot.cxx:500
 SPMRoot.cxx:501
 SPMRoot.cxx:502
 SPMRoot.cxx:503
 SPMRoot.cxx:504
 SPMRoot.cxx:505
 SPMRoot.cxx:506
 SPMRoot.cxx:507
 SPMRoot.cxx:508
 SPMRoot.cxx:509
 SPMRoot.cxx:510
 SPMRoot.cxx:511
 SPMRoot.cxx:512
 SPMRoot.cxx:513
 SPMRoot.cxx:514
 SPMRoot.cxx:515
 SPMRoot.cxx:516
 SPMRoot.cxx:517
 SPMRoot.cxx:518
 SPMRoot.cxx:519
 SPMRoot.cxx:520
 SPMRoot.cxx:521
 SPMRoot.cxx:522
 SPMRoot.cxx:523
 SPMRoot.cxx:524
 SPMRoot.cxx:525
 SPMRoot.cxx:526
 SPMRoot.cxx:527
 SPMRoot.cxx:528
 SPMRoot.cxx:529
 SPMRoot.cxx:530
 SPMRoot.cxx:531
 SPMRoot.cxx:532
 SPMRoot.cxx:533
 SPMRoot.cxx:534
 SPMRoot.cxx:535
 SPMRoot.cxx:536
 SPMRoot.cxx:537
 SPMRoot.cxx:538
 SPMRoot.cxx:539
 SPMRoot.cxx:540
 SPMRoot.cxx:541
 SPMRoot.cxx:542
 SPMRoot.cxx:543
 SPMRoot.cxx:544
 SPMRoot.cxx:545
 SPMRoot.cxx:546
 SPMRoot.cxx:547
 SPMRoot.cxx:548
 SPMRoot.cxx:549
 SPMRoot.cxx:550
 SPMRoot.cxx:551
 SPMRoot.cxx:552
 SPMRoot.cxx:553
 SPMRoot.cxx:554
 SPMRoot.cxx:555
 SPMRoot.cxx:556
 SPMRoot.cxx:557
 SPMRoot.cxx:558
 SPMRoot.cxx:559
 SPMRoot.cxx:560
 SPMRoot.cxx:561
 SPMRoot.cxx:562
 SPMRoot.cxx:563
 SPMRoot.cxx:564
 SPMRoot.cxx:565
 SPMRoot.cxx:566
 SPMRoot.cxx:567
 SPMRoot.cxx:568
 SPMRoot.cxx:569
 SPMRoot.cxx:570
 SPMRoot.cxx:571
 SPMRoot.cxx:572
 SPMRoot.cxx:573
 SPMRoot.cxx:574
 SPMRoot.cxx:575
 SPMRoot.cxx:576
 SPMRoot.cxx:577
 SPMRoot.cxx:578
 SPMRoot.cxx:579
 SPMRoot.cxx:580
 SPMRoot.cxx:581
 SPMRoot.cxx:582
 SPMRoot.cxx:583
 SPMRoot.cxx:584
 SPMRoot.cxx:585
 SPMRoot.cxx:586
 SPMRoot.cxx:587
 SPMRoot.cxx:588
 SPMRoot.cxx:589
 SPMRoot.cxx:590
 SPMRoot.cxx:591
 SPMRoot.cxx:592
 SPMRoot.cxx:593
 SPMRoot.cxx:594
 SPMRoot.cxx:595
 SPMRoot.cxx:596
 SPMRoot.cxx:597
 SPMRoot.cxx:598
 SPMRoot.cxx:599
 SPMRoot.cxx:600
 SPMRoot.cxx:601
 SPMRoot.cxx:602
 SPMRoot.cxx:603
 SPMRoot.cxx:604
 SPMRoot.cxx:605
 SPMRoot.cxx:606
 SPMRoot.cxx:607
 SPMRoot.cxx:608
 SPMRoot.cxx:609
 SPMRoot.cxx:610
 SPMRoot.cxx:611
 SPMRoot.cxx:612
 SPMRoot.cxx:613
 SPMRoot.cxx:614
 SPMRoot.cxx:615
 SPMRoot.cxx:616
 SPMRoot.cxx:617
 SPMRoot.cxx:618
 SPMRoot.cxx:619
 SPMRoot.cxx:620
 SPMRoot.cxx:621
 SPMRoot.cxx:622
 SPMRoot.cxx:623
 SPMRoot.cxx:624
 SPMRoot.cxx:625
 SPMRoot.cxx:626
 SPMRoot.cxx:627
 SPMRoot.cxx:628
 SPMRoot.cxx:629
 SPMRoot.cxx:630
 SPMRoot.cxx:631
 SPMRoot.cxx:632
 SPMRoot.cxx:633
 SPMRoot.cxx:634
 SPMRoot.cxx:635
 SPMRoot.cxx:636
 SPMRoot.cxx:637
 SPMRoot.cxx:638
 SPMRoot.cxx:639
 SPMRoot.cxx:640
 SPMRoot.cxx:641
 SPMRoot.cxx:642
 SPMRoot.cxx:643
 SPMRoot.cxx:644
 SPMRoot.cxx:645
 SPMRoot.cxx:646
 SPMRoot.cxx:647
 SPMRoot.cxx:648
 SPMRoot.cxx:649
 SPMRoot.cxx:650
 SPMRoot.cxx:651
 SPMRoot.cxx:652
 SPMRoot.cxx:653
 SPMRoot.cxx:654
 SPMRoot.cxx:655
 SPMRoot.cxx:656
 SPMRoot.cxx:657
 SPMRoot.cxx:658
 SPMRoot.cxx:659
 SPMRoot.cxx:660
 SPMRoot.cxx:661
 SPMRoot.cxx:662
 SPMRoot.cxx:663
 SPMRoot.cxx:664
 SPMRoot.cxx:665
 SPMRoot.cxx:666
 SPMRoot.cxx:667
 SPMRoot.cxx:668
 SPMRoot.cxx:669
 SPMRoot.cxx:670
 SPMRoot.cxx:671
 SPMRoot.cxx:672
 SPMRoot.cxx:673
 SPMRoot.cxx:674
 SPMRoot.cxx:675
 SPMRoot.cxx:676
 SPMRoot.cxx:677
 SPMRoot.cxx:678
 SPMRoot.cxx:679
 SPMRoot.cxx:680
 SPMRoot.cxx:681
 SPMRoot.cxx:682
 SPMRoot.cxx:683
 SPMRoot.cxx:684
 SPMRoot.cxx:685
 SPMRoot.cxx:686
 SPMRoot.cxx:687
 SPMRoot.cxx:688
 SPMRoot.cxx:689
 SPMRoot.cxx:690
 SPMRoot.cxx:691
 SPMRoot.cxx:692
 SPMRoot.cxx:693
 SPMRoot.cxx:694
 SPMRoot.cxx:695
 SPMRoot.cxx:696
 SPMRoot.cxx:697
 SPMRoot.cxx:698
 SPMRoot.cxx:699
 SPMRoot.cxx:700
 SPMRoot.cxx:701
 SPMRoot.cxx:702
 SPMRoot.cxx:703
 SPMRoot.cxx:704
 SPMRoot.cxx:705
 SPMRoot.cxx:706
 SPMRoot.cxx:707
 SPMRoot.cxx:708
 SPMRoot.cxx:709
 SPMRoot.cxx:710
 SPMRoot.cxx:711
 SPMRoot.cxx:712
 SPMRoot.cxx:713
 SPMRoot.cxx:714
 SPMRoot.cxx:715
 SPMRoot.cxx:716
 SPMRoot.cxx:717
 SPMRoot.cxx:718
 SPMRoot.cxx:719
 SPMRoot.cxx:720
 SPMRoot.cxx:721
 SPMRoot.cxx:722
 SPMRoot.cxx:723
 SPMRoot.cxx:724
 SPMRoot.cxx:725
 SPMRoot.cxx:726
 SPMRoot.cxx:727
 SPMRoot.cxx:728
 SPMRoot.cxx:729
 SPMRoot.cxx:730
 SPMRoot.cxx:731
 SPMRoot.cxx:732
 SPMRoot.cxx:733
 SPMRoot.cxx:734
 SPMRoot.cxx:735
 SPMRoot.cxx:736
 SPMRoot.cxx:737
 SPMRoot.cxx:738
 SPMRoot.cxx:739
 SPMRoot.cxx:740
 SPMRoot.cxx:741
 SPMRoot.cxx:742
 SPMRoot.cxx:743
 SPMRoot.cxx:744
 SPMRoot.cxx:745
 SPMRoot.cxx:746
 SPMRoot.cxx:747
 SPMRoot.cxx:748
 SPMRoot.cxx:749
 SPMRoot.cxx:750
 SPMRoot.cxx:751
 SPMRoot.cxx:752
 SPMRoot.cxx:753
 SPMRoot.cxx:754
 SPMRoot.cxx:755
 SPMRoot.cxx:756
 SPMRoot.cxx:757
 SPMRoot.cxx:758
 SPMRoot.cxx:759
 SPMRoot.cxx:760
 SPMRoot.cxx:761
 SPMRoot.cxx:762
 SPMRoot.cxx:763
 SPMRoot.cxx:764
 SPMRoot.cxx:765
 SPMRoot.cxx:766
 SPMRoot.cxx:767
 SPMRoot.cxx:768
 SPMRoot.cxx:769
 SPMRoot.cxx:770
 SPMRoot.cxx:771
 SPMRoot.cxx:772
 SPMRoot.cxx:773
 SPMRoot.cxx:774
 SPMRoot.cxx:775
 SPMRoot.cxx:776
 SPMRoot.cxx:777
 SPMRoot.cxx:778
 SPMRoot.cxx:779
 SPMRoot.cxx:780
 SPMRoot.cxx:781
 SPMRoot.cxx:782
 SPMRoot.cxx:783
 SPMRoot.cxx:784
 SPMRoot.cxx:785
 SPMRoot.cxx:786
 SPMRoot.cxx:787
 SPMRoot.cxx:788
 SPMRoot.cxx:789
 SPMRoot.cxx:790
 SPMRoot.cxx:791
 SPMRoot.cxx:792
 SPMRoot.cxx:793
 SPMRoot.cxx:794
 SPMRoot.cxx:795
 SPMRoot.cxx:796
 SPMRoot.cxx:797
 SPMRoot.cxx:798
 SPMRoot.cxx:799
 SPMRoot.cxx:800
 SPMRoot.cxx:801
 SPMRoot.cxx:802
 SPMRoot.cxx:803
 SPMRoot.cxx:804
 SPMRoot.cxx:805
 SPMRoot.cxx:806
 SPMRoot.cxx:807
 SPMRoot.cxx:808
 SPMRoot.cxx:809
 SPMRoot.cxx:810
 SPMRoot.cxx:811
 SPMRoot.cxx:812
 SPMRoot.cxx:813
 SPMRoot.cxx:814
 SPMRoot.cxx:815
 SPMRoot.cxx:816
 SPMRoot.cxx:817
 SPMRoot.cxx:818
 SPMRoot.cxx:819
 SPMRoot.cxx:820
 SPMRoot.cxx:821
 SPMRoot.cxx:822
 SPMRoot.cxx:823
 SPMRoot.cxx:824
 SPMRoot.cxx:825
 SPMRoot.cxx:826
 SPMRoot.cxx:827
 SPMRoot.cxx:828
 SPMRoot.cxx:829
 SPMRoot.cxx:830
 SPMRoot.cxx:831
 SPMRoot.cxx:832
 SPMRoot.cxx:833
 SPMRoot.cxx:834
 SPMRoot.cxx:835
 SPMRoot.cxx:836
 SPMRoot.cxx:837
 SPMRoot.cxx:838
 SPMRoot.cxx:839
 SPMRoot.cxx:840
 SPMRoot.cxx:841
 SPMRoot.cxx:842
 SPMRoot.cxx:843
 SPMRoot.cxx:844
 SPMRoot.cxx:845
 SPMRoot.cxx:846
 SPMRoot.cxx:847
 SPMRoot.cxx:848
 SPMRoot.cxx:849
 SPMRoot.cxx:850
 SPMRoot.cxx:851
 SPMRoot.cxx:852
 SPMRoot.cxx:853
 SPMRoot.cxx:854
 SPMRoot.cxx:855
 SPMRoot.cxx:856
 SPMRoot.cxx:857
 SPMRoot.cxx:858
 SPMRoot.cxx:859
 SPMRoot.cxx:860
 SPMRoot.cxx:861
 SPMRoot.cxx:862
 SPMRoot.cxx:863
 SPMRoot.cxx:864
 SPMRoot.cxx:865
 SPMRoot.cxx:866
 SPMRoot.cxx:867
 SPMRoot.cxx:868
 SPMRoot.cxx:869
 SPMRoot.cxx:870
 SPMRoot.cxx:871
 SPMRoot.cxx:872
 SPMRoot.cxx:873
 SPMRoot.cxx:874
 SPMRoot.cxx:875
 SPMRoot.cxx:876
 SPMRoot.cxx:877
 SPMRoot.cxx:878
 SPMRoot.cxx:879
 SPMRoot.cxx:880
 SPMRoot.cxx:881
 SPMRoot.cxx:882
 SPMRoot.cxx:883
 SPMRoot.cxx:884
 SPMRoot.cxx:885
 SPMRoot.cxx:886
 SPMRoot.cxx:887
 SPMRoot.cxx:888
 SPMRoot.cxx:889
 SPMRoot.cxx:890
 SPMRoot.cxx:891
 SPMRoot.cxx:892
 SPMRoot.cxx:893
 SPMRoot.cxx:894
 SPMRoot.cxx:895
 SPMRoot.cxx:896
 SPMRoot.cxx:897
 SPMRoot.cxx:898
 SPMRoot.cxx:899
 SPMRoot.cxx:900
 SPMRoot.cxx:901
 SPMRoot.cxx:902
 SPMRoot.cxx:903
 SPMRoot.cxx:904
 SPMRoot.cxx:905
 SPMRoot.cxx:906
 SPMRoot.cxx:907
 SPMRoot.cxx:908
 SPMRoot.cxx:909
 SPMRoot.cxx:910
 SPMRoot.cxx:911
 SPMRoot.cxx:912
 SPMRoot.cxx:913
 SPMRoot.cxx:914
 SPMRoot.cxx:915
 SPMRoot.cxx:916
 SPMRoot.cxx:917
 SPMRoot.cxx:918
 SPMRoot.cxx:919
 SPMRoot.cxx:920
 SPMRoot.cxx:921
 SPMRoot.cxx:922
 SPMRoot.cxx:923
 SPMRoot.cxx:924
 SPMRoot.cxx:925
 SPMRoot.cxx:926
 SPMRoot.cxx:927
 SPMRoot.cxx:928
 SPMRoot.cxx:929
 SPMRoot.cxx:930
 SPMRoot.cxx:931
 SPMRoot.cxx:932
 SPMRoot.cxx:933
 SPMRoot.cxx:934
 SPMRoot.cxx:935
 SPMRoot.cxx:936
 SPMRoot.cxx:937
 SPMRoot.cxx:938
 SPMRoot.cxx:939
 SPMRoot.cxx:940
 SPMRoot.cxx:941
 SPMRoot.cxx:942
 SPMRoot.cxx:943
 SPMRoot.cxx:944
 SPMRoot.cxx:945
 SPMRoot.cxx:946
 SPMRoot.cxx:947
 SPMRoot.cxx:948
 SPMRoot.cxx:949
 SPMRoot.cxx:950
 SPMRoot.cxx:951
 SPMRoot.cxx:952
 SPMRoot.cxx:953
 SPMRoot.cxx:954
 SPMRoot.cxx:955
 SPMRoot.cxx:956
 SPMRoot.cxx:957
 SPMRoot.cxx:958
 SPMRoot.cxx:959
 SPMRoot.cxx:960
 SPMRoot.cxx:961
 SPMRoot.cxx:962
 SPMRoot.cxx:963
 SPMRoot.cxx:964
 SPMRoot.cxx:965
 SPMRoot.cxx:966
 SPMRoot.cxx:967
 SPMRoot.cxx:968
 SPMRoot.cxx:969
 SPMRoot.cxx:970
 SPMRoot.cxx:971
 SPMRoot.cxx:972
 SPMRoot.cxx:973
 SPMRoot.cxx:974
 SPMRoot.cxx:975
 SPMRoot.cxx:976
 SPMRoot.cxx:977
 SPMRoot.cxx:978
 SPMRoot.cxx:979
 SPMRoot.cxx:980
 SPMRoot.cxx:981
 SPMRoot.cxx:982
 SPMRoot.cxx:983
 SPMRoot.cxx:984
 SPMRoot.cxx:985
 SPMRoot.cxx:986
 SPMRoot.cxx:987
 SPMRoot.cxx:988
 SPMRoot.cxx:989
 SPMRoot.cxx:990
 SPMRoot.cxx:991
 SPMRoot.cxx:992
 SPMRoot.cxx:993
 SPMRoot.cxx:994
 SPMRoot.cxx:995
 SPMRoot.cxx:996
 SPMRoot.cxx:997
 SPMRoot.cxx:998
 SPMRoot.cxx:999
 SPMRoot.cxx:1000
 SPMRoot.cxx:1001
 SPMRoot.cxx:1002
 SPMRoot.cxx:1003
 SPMRoot.cxx:1004
 SPMRoot.cxx:1005
 SPMRoot.cxx:1006
 SPMRoot.cxx:1007
 SPMRoot.cxx:1008
 SPMRoot.cxx:1009
 SPMRoot.cxx:1010
 SPMRoot.cxx:1011
 SPMRoot.cxx:1012
 SPMRoot.cxx:1013
 SPMRoot.cxx:1014
 SPMRoot.cxx:1015
 SPMRoot.cxx:1016
 SPMRoot.cxx:1017
 SPMRoot.cxx:1018
 SPMRoot.cxx:1019
 SPMRoot.cxx:1020
 SPMRoot.cxx:1021
 SPMRoot.cxx:1022
 SPMRoot.cxx:1023
 SPMRoot.cxx:1024
 SPMRoot.cxx:1025
 SPMRoot.cxx:1026
 SPMRoot.cxx:1027
 SPMRoot.cxx:1028
 SPMRoot.cxx:1029
 SPMRoot.cxx:1030
 SPMRoot.cxx:1031
 SPMRoot.cxx:1032
 SPMRoot.cxx:1033
 SPMRoot.cxx:1034
 SPMRoot.cxx:1035
 SPMRoot.cxx:1036
 SPMRoot.cxx:1037
 SPMRoot.cxx:1038
 SPMRoot.cxx:1039
 SPMRoot.cxx:1040
 SPMRoot.cxx:1041
 SPMRoot.cxx:1042
 SPMRoot.cxx:1043
 SPMRoot.cxx:1044
 SPMRoot.cxx:1045
 SPMRoot.cxx:1046
 SPMRoot.cxx:1047
 SPMRoot.cxx:1048
 SPMRoot.cxx:1049
 SPMRoot.cxx:1050
 SPMRoot.cxx:1051
 SPMRoot.cxx:1052
 SPMRoot.cxx:1053
 SPMRoot.cxx:1054
 SPMRoot.cxx:1055
 SPMRoot.cxx:1056
 SPMRoot.cxx:1057
 SPMRoot.cxx:1058
 SPMRoot.cxx:1059
 SPMRoot.cxx:1060
 SPMRoot.cxx:1061
 SPMRoot.cxx:1062
 SPMRoot.cxx:1063
 SPMRoot.cxx:1064
 SPMRoot.cxx:1065
 SPMRoot.cxx:1066
 SPMRoot.cxx:1067
 SPMRoot.cxx:1068
 SPMRoot.cxx:1069
 SPMRoot.cxx:1070
 SPMRoot.cxx:1071
 SPMRoot.cxx:1072
 SPMRoot.cxx:1073
 SPMRoot.cxx:1074
 SPMRoot.cxx:1075
 SPMRoot.cxx:1076
 SPMRoot.cxx:1077
 SPMRoot.cxx:1078
 SPMRoot.cxx:1079
 SPMRoot.cxx:1080
 SPMRoot.cxx:1081
 SPMRoot.cxx:1082
 SPMRoot.cxx:1083
 SPMRoot.cxx:1084
 SPMRoot.cxx:1085
 SPMRoot.cxx:1086
 SPMRoot.cxx:1087
 SPMRoot.cxx:1088
 SPMRoot.cxx:1089
 SPMRoot.cxx:1090
 SPMRoot.cxx:1091
 SPMRoot.cxx:1092
 SPMRoot.cxx:1093
 SPMRoot.cxx:1094
 SPMRoot.cxx:1095
 SPMRoot.cxx:1096
 SPMRoot.cxx:1097
 SPMRoot.cxx:1098
 SPMRoot.cxx:1099
 SPMRoot.cxx:1100