LMU/musrfit
LMU/musrfit
5
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases 3 Activity

Merged the TLemRunHeader-lib into the musrfit tree and extended the Makefiles to work on further platforms - still some tests on non-Linux systems are missing...

Browse Source
This commit is contained in:
Bastian M. Wojek 2009-06-10 14:45:39 +00:00
parent 4fdedbefad
commit eb131cddbb
6 changed files with 720 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

389
src/external/TLemRunHeader/TLemRunHeader.cxx vendored Normal file
View File

@ -0,0 +1,389 @@
// TLemRunHeader.C
//
// T. Prokscha
// 18/06/2006
//
// $Id: TLemRunHeader.cxx 3897 2009-05-01 22:06:11Z l_wojek $
//
#include "TLemRunHeader.h"
ClassImp(TLemRunHeader)
//----------------------------------------------------------
TLemRunHeader::TLemRunHeader(){
fRunTitle.SetString("");
fLemSetup.SetString("");
fStartTimeString.SetString("");
fStopTimeString.SetString("");
fRunNumber = 0; // -1 not possible since UInt_t
fRunNumberString.SetString("");
fStartTime = 0; // -1 not possible since UInt_t
fStopTime = 0; // -1 not possible since UInt_t
fModeratorHV = -999.0;
fModeratorHVError = -999.0;
fModeratorHVString.SetString("");
fSampleHV = -999.0;
fSampleHVError = -999.0;
fSampleHVString.SetString("");
fImpEnergy = -999.0;
fImpEnergyString.SetString("");
fSampleTemperature = -999.0;
fSampleTemperatureError = -999.0;
fSampleTemperatureString.SetString("");
fSampleBField = -999.0;
fSampleBFieldError = -999.0;
fSampleBFieldString.SetString("");
fTimeResolution = -999.0;
fTimeResolutionString.SetString("");
fNChannels = -1;
fNChannelsString.SetString("");
fNHist = -1;
fNHistString.SetString("");
fCuts.SetString("");
fModerator.SetString("");
for (int i=0; i<NHIST; i++)
fTimeZero[i] = -1.;
fTimeZeroString.SetString("");
}
//----------------------------------------------------------
TLemRunHeader::~TLemRunHeader(){
//fTimeZero.clear();
}
//----------------------------------------------------------
void TLemRunHeader::SetRunTitle(const Char_t *title){
TString str;
str = "00 Title: ";
str += title;
fRunTitle.SetString(str);
}
//----------------------------------------------------------
void TLemRunHeader::SetLemSetup(const Char_t *setup){
TString str;
str = "01 Setup: ";
str += setup;
fLemSetup.SetString(str);
}
//----------------------------------------------------------
void TLemRunHeader::SetRunNumber(UInt_t runNo){
TString str;
fRunNumber = runNo;
str = "02 Run Number: ";
str += runNo;
fRunNumberString.SetString(str);
}
//----------------------------------------------------------
void TLemRunHeader::SetStartTimeString(const Char_t *start){
TString str;
str = "03 Run Start Time: ";
str += start;
fStartTimeString.SetString(str);
}
//----------------------------------------------------------
void TLemRunHeader::SetStopTimeString(const Char_t *stop){
TString str;
str = "04 Run Stop Time: ";
str += stop;
fStopTimeString.SetString(str);
}
//----------------------------------------------------------
void TLemRunHeader::SetModeratorHV(Float_t modHV, Float_t error){
TString str;
char s[80];
sprintf(s, "05 Moderator HV: %8.2f(%5.2f)", modHV, error);
str = s;
fModeratorHVString.SetString(str);
fModeratorHV = modHV;
fModeratorHVError = error;
}
//----------------------------------------------------------
void TLemRunHeader::SetSampleHV(Float_t value, Float_t error){
TString str;
char s[80];
sprintf(s,"06 Sample HV: %8.2f(%5.2f)", value, error);
str = s;
fSampleHVString.SetString(str);
fSampleHV = value;
fSampleHVError = error;
}
//----------------------------------------------------------
void TLemRunHeader::SetImpEnergy(Float_t value){
TString str;
char s[80];
sprintf(s,"07 Impl. Energy: %8.2f", value);
str = s;
fImpEnergyString.SetString(str);
fImpEnergy = value;
}
//----------------------------------------------------------
void TLemRunHeader::SetSampleTemperature(Float_t value, Float_t error){
TString str;
char s[80];
sprintf(s,"08 Sample T: %8.2f(%5.2f)", value, error);
str = s;
fSampleTemperatureString.SetString(str);
fSampleTemperature = value;
fSampleTemperatureError = error;
}
//----------------------------------------------------------
void TLemRunHeader::SetSampleBField(Float_t value, Float_t error){
TString str;
char s[80];
sprintf(s,"09 Sample B: %8.2f(%5.2f)", value, error);
str = s;
fSampleBFieldString.SetString(str);
fSampleBField = value;
fSampleBFieldError = error;
}
//----------------------------------------------------------
void TLemRunHeader::SetTimeResolution(Float_t value){
TString str;
char s[80];
sprintf(s,"10 Time Res.: %10.7f", value);
str = s;
fTimeResolutionString.SetString(str);
fTimeResolution = value;
}
//----------------------------------------------------------
void TLemRunHeader::SetNChannels(Int_t value){
TString str;
char s[80];
sprintf(s,"11 N Channels: %8d", value);
str = s;
fNChannelsString.SetString(str);
fNChannels = value;
}
//----------------------------------------------------------
void TLemRunHeader::SetNHist(Int_t value){
TString str;
char s[80];
sprintf(s,"12 N Histograms: %6d", value);
str = s;
fNHistString.SetString(str);
fNHist = value;
SetNPosDetectors(fNHist);
}
//----------------------------------------------------------
void TLemRunHeader::SetCuts(const Char_t *cuts){
TString str;
str = "13 Cuts: ";
str += cuts;
fCuts.SetString(str);
}
//----------------------------------------------------------
void TLemRunHeader::SetModerator(const Char_t *moderator){
TString str;
str = "14 Moderator: ";
str += moderator;
fModerator.SetString(str);
}
//----------------------------------------------------------
void TLemRunHeader::SetTimeZero(const Double_t *value){
TString str;
str = "15 t0: ";
for (Int_t i = 0; i < fNHist; i++){
//fTimeZero.push_back(value[i]);
fTimeZero[i] = value[i];
str += value[i];
str += " ";
}
fTimeZeroString.SetString(str);
}
//----------------------------------------------------------
TObjString TLemRunHeader::GetRunTitle() const {
TObjString ostr;
TString str;
Int_t delIndex;
str = fRunTitle.GetString();
delIndex = str.First(":") + 2;
str.Remove(0, delIndex);
ostr.SetString(str);
return ostr;
}
//----------------------------------------------------------
TObjString TLemRunHeader::GetLemSetup() const {
TObjString ostr;
TString str;
Int_t delIndex;
str = fLemSetup.GetString();
delIndex = str.First(":") + 2;
str.Remove(0, delIndex);
ostr.SetString(str);
return ostr;
}
//----------------------------------------------------------
//Int_t TLemRunHeader::GetRunNumber() const {
// TString str;
// Int_t delIndex;
//
// str = fRunNumberString.GetString();
// delIndex = str.First(":") + 1;
// str.Remove(0, delIndex);
// return str.Atoi();
//}
//----------------------------------------------------------
TObjString TLemRunHeader::GetStartTimeString() const {
TObjString ostr;
TString str;
Int_t delIndex;
str = fStartTimeString.GetString();
delIndex = str.First(":") + 2;
str.Remove(0, delIndex);
ostr.SetString(str);
return ostr;
}
//----------------------------------------------------------
TObjString TLemRunHeader::GetStopTimeString() const {
TObjString ostr;
TString str;
Int_t delIndex;
str = fStopTimeString.GetString();
delIndex = str.First(":") + 2;
str.Remove(0, delIndex);
ostr.SetString(str);
return ostr;
}
//----------------------------------------------------------
TObjString TLemRunHeader::GetCuts() const {
TObjString ostr;
TString str;
Int_t delIndex;
str = fCuts.GetString();
delIndex = str.First(":") + 2;
str.Remove(0, delIndex);
ostr.SetString(str);
return ostr;
}
//----------------------------------------------------------
TObjString TLemRunHeader::GetModerator() const {
TObjString ostr;
TString str;
Int_t delIndex;
str = fModerator.GetString();
delIndex = str.First(":") + 2;
str.Remove(0, delIndex);
ostr.SetString(str);
return ostr;
}
//----------------------------------------------------------
void TLemRunHeader::DumpHeader() const {
TObjString oTitle, oSetup, oStart, oStop, oCuts, oMod;
const char *title, *setup, *runStart, *runStop, *cuts, *mod;
oTitle = GetRunTitle();
title = oTitle.GetName();
oSetup = GetLemSetup();
setup = oSetup.GetName();
oStart = GetStartTimeString();
runStart = oStart.GetName();
oStop = GetStopTimeString();
runStop = oStop.GetName();
oCuts = GetCuts();
cuts = oCuts.GetName();
oMod = GetModerator();
mod = oMod.GetName();
printf("Title: %s\n",title);
printf("Setup: %s\n",setup);
printf("Run Number: %04d\n", GetRunNumber());
printf("Start Time: %s\n", runStart);
printf("Stop Time: %s\n", runStop);
printf("Moderator HV: %10.2f kV\n", fModeratorHV);
printf("Sample HV: %10.2f kV\n", fSampleHV);
printf("Impl. Energy: %10.2f keV\n", fImpEnergy);
printf("Sample T: %10.2f K\n", fSampleTemperature);
printf("Sample B: %10.2f G\n", fSampleBField);
printf("Time Res.: %10.7f ns\n", fTimeResolution);
printf("N Channels: %10d\n", fNChannels);
printf("N Histograms: %10d\n", fNHist);
printf("Cuts: %s\n", cuts);
printf("Moderator: %s\n", mod);
printf("t0: ");
for (Int_t i=0; i<fNHist; i++)
printf(" %7.2f ", fTimeZero[i]);
printf("\n");
}
//----------------------------------------------------------
//void TLemRunHeader::Browse(TBrowser *b){
void TLemRunHeader::DrawHeader() const {
TPaveText *pt;
TText *text;
TCanvas *ca;
Char_t str[256], helpstr[256];
TObjString oTitle, oSetup, oStart, oStop, oCuts, oMod;
const char *title, *setup, *runStart, *runStop, *cuts, *mod;
oTitle = GetRunTitle();
title = oTitle.GetName();
oSetup = GetLemSetup();
setup = oSetup.GetName();
oStart = GetStartTimeString();
runStart = oStart.GetName();
oStop = GetStopTimeString();
runStop = oStop.GetName();
oCuts = GetCuts();
cuts = oCuts.GetName();
oMod = GetModerator();
mod = oMod.GetName();
ca = new TCanvas("LEM RunHeader","LEM RunHeader", 147,37,699,527);
ca->Range(0., 0., 100., 100.);
pt = new TPaveText(10.,10.,90.,90.,"br");
pt->SetFillColor(19);
pt->SetTextAlign(12);
strcpy(str, "Title: ");
strcat(str, title);
text = pt->AddText(str);
strcpy(str, "Setup: ");
strcat(str, setup);
text = pt->AddText(str);
strcpy(str, "Run Start: ");
strcat(str, runStart);
text = pt->AddText(str);
strcpy(str, "Run Stop: ");
strcat(str, runStop);
text = pt->AddText(str);
sprintf(str, "Run Number: %10d", GetRunNumber());
text = pt->AddText(str);
sprintf(str, "Moderator HV: %10.2f kV", fModeratorHV);
text = pt->AddText(str);
sprintf(str, "Sample HV: %10.2f kV", fSampleHV);
text = pt->AddText(str);
sprintf(str, "Impl. Energy: %10.2f keV", fImpEnergy);
text = pt->AddText(str);
sprintf(str, "Sample T: %10.2f K", fSampleTemperature);
text = pt->AddText(str);
sprintf(str, "Sample B: %10.2f G", fSampleBField);
text = pt->AddText(str);
sprintf(str, "Time Res.: %10.7f ns", fTimeResolution);
text = pt->AddText(str);
sprintf(str, "N Channels: %10d", fNChannels);
text = pt->AddText(str);
sprintf(str, "N Histograms: %10d", fNHist);
text = pt->AddText(str);
strcpy(str, "Cuts: ");
strcat(str, cuts);
text = pt->AddText(str);
strcpy(str, "Moderator: ");
strcat(str, mod);
text = pt->AddText(str);
strcpy(str,"t0: ");
for (Int_t i=0; i<fNHist; i++){
sprintf(helpstr, " %7.2f ", fTimeZero[i]);
strcat(str, helpstr);
}
text = pt->AddText(str);
pt->Draw();
ca->Modified(kTRUE);
}
//----------------------------------------------------------

119
src/external/TLemRunHeader/TLemRunHeader.h vendored Normal file
View File

@ -0,0 +1,119 @@
// TLemRunHeader.h
//
// T.Prokscha, 18-June-2006
//
// Lem Run header test. It inherits now from class
// TLemStats to have important scaler data as well included.
//
// use TObjString class: this has the advantage, that
// we can "see" the header in the root browser; also, have to
// "number" the lines so that they appear in the right order
// in TBrowser.
// Anyway, this is just a test - and a final "root" header
// definition should be closer to uSR Nexus definition?
//
//
#ifndef __TLemRunHeader__
#define __TLemRunHeader__
//#include <iostream>
//#include <vector>
#include "TObjString.h"
#include "TCanvas.h"
#include "TText.h"
#include "TPaveText.h"
#include "TLemStats.h"
//#define NHIST 32
//using std::cout;
//using std::endl;
//using std::vector;
//------------------------------------------------
// now the main class definition
class TLemRunHeader : public TLemStats {
private:
TObjString fRunTitle; // LEM Run Title
TObjString fLemSetup; // LEM Setup
TObjString fStartTimeString; // Run Start time
TObjString fStopTimeString; // Run Stop time
UInt_t fRunNumber;
TObjString fRunNumberString;
UInt_t fStartTime; // ASCII of start time
UInt_t fStopTime; // ASCII of stop time
Float_t fModeratorHV, fModeratorHVError;
TObjString fModeratorHVString;
Float_t fSampleHV, fSampleHVError;
TObjString fSampleHVString;
Float_t fImpEnergy;
TObjString fImpEnergyString;
Float_t fSampleTemperature, fSampleTemperatureError;
TObjString fSampleTemperatureString;
Float_t fSampleBField, fSampleBFieldError;
TObjString fSampleBFieldString;
Float_t fTimeResolution; //time resolution in ns
TObjString fTimeResolutionString;
Int_t fNChannels; // number of channels in one histogram
TObjString fNChannelsString;
Int_t fNHist; // number of histograms
TObjString fNHistString;
TObjString fCuts;
TObjString fModerator;
// vector<Double_t> fTimeZero; // time zero's of e+ detectors
Double_t fTimeZero[NHIST]; // time zero's of e+ detectors
TObjString fTimeZeroString; //
public:
TLemRunHeader();
virtual ~TLemRunHeader();
virtual Bool_t IsFolder() const { return kTRUE; } // make object "browsable"
//virtual void Browse(TBrowser *b);
virtual void SetRunTitle(const Char_t *title);
virtual void SetLemSetup(const Char_t *setup);
virtual void SetRunNumber(UInt_t runNo);
virtual void SetStartTimeString(const Char_t *start);
virtual void SetStopTimeString(const Char_t *stop);
virtual void SetStartTime(UInt_t value) { fStartTime = value; }
virtual void SetStopTime(UInt_t value) { fStopTime = value; }
virtual void SetModeratorHV(Float_t modHV, Float_t error);
virtual void SetSampleHV(Float_t value, Float_t error);
virtual void SetImpEnergy(Float_t value);
virtual void SetSampleTemperature(Float_t value, Float_t error);
virtual void SetSampleBField(Float_t value, Float_t error);
virtual void SetTimeResolution(Float_t value);
virtual void SetNChannels(Int_t value);
virtual void SetNHist(Int_t value);
virtual void SetCuts(const Char_t *cuts);
virtual void SetModerator(const Char_t *moderator);
virtual void SetTimeZero(const Double_t *value);
TObjString GetStartTimeString() const;
TObjString GetStopTimeString() const ;
TObjString GetRunTitle() const;
TObjString GetLemSetup() const;
virtual UInt_t GetRunNumber() const { return fRunNumber; }
virtual UInt_t GetStartTime() const { return fStartTime; }
virtual UInt_t GetStopTime() const { return fStopTime; }
virtual Int_t GetNChannels() const { return fNChannels; }
virtual Int_t GetNHist() const { return fNHist; }
virtual Float_t GetModeratorHV() const { return fModeratorHV; }
virtual Float_t GetSampleHV() const { return fSampleHV; }
virtual Float_t GetModeratorHVError() const { return fModeratorHVError; }
virtual Float_t GetSampleHVError() const { return fSampleHVError; }
virtual Float_t GetImpEnergy() const { return fImpEnergy; }
virtual Float_t GetSampleTemperature() const { return fSampleTemperature; }
virtual Float_t GetSampleBField() const { return fSampleBField; }
virtual Float_t GetSampleTemperatureError() const { return fSampleTemperatureError; }
virtual Float_t GetSampleBFieldError() const { return fSampleBFieldError; }
virtual Float_t GetTimeResolution() const { return fTimeResolution; }
TObjString GetCuts() const;
TObjString GetModerator() const;
// virtual Double_t *GetTimeZero() { return &fTimeZero.front(); }
virtual Double_t *GetTimeZero() { return fTimeZero; }
virtual void DumpHeader() const;
virtual void DrawHeader() const;
// 4th version including lemStats
ClassDef(TLemRunHeader,4) // LEM Run Header
};
#endif

15
src/external/TLemRunHeader/TLemRunHeaderLinkDef.h vendored Normal file
View File

@ -0,0 +1,15 @@
#ifdef __CINT__
#pragma link off all globals;
#pragma link off all classes;
#pragma link off all functions;
//#pragma link C++ class TLemStartTime+;
//#pragma link C++ class TLemStopTime+;
//#pragma link C++ class TLemRunTitle+;
//#pragma link C++ class TLemSetup+;
//#pragma link C++ class TLemRunNumber+;
//#pragma link C++ class TLemStats+;
#pragma link C++ class TLemRunHeader+;
#endif

97
src/external/TLemRunHeader/TLemStats.cxx vendored Normal file
View File

@ -0,0 +1,97 @@
// TLemStats.C
//
// T. Prokscha
// 25/04/2007
//
#include "TLemStats.h"
ClassImp(TLemStats)
//----------------------------------------------------------
TLemStats::TLemStats(){
fIpSum = fScalerClockSum = fTdcClockSum = fTdSum = 1.;
fTdCleanSum = fTdGoodSum = fNevents = 1.;
for (int i=0; i<NHIST; i++)
fPosSum[i] = -1.;
}
//----------------------------------------------------------
TLemStats::~TLemStats(){
}
//----------------------------------------------------------
void TLemStats::SetIpSum(Double_t value){
TString str;
fIpSum = value;
str = "20 Sum Ip : ";
str += value;
str += " ";
if (fScalerClockSum > 0. ){
str += value/fScalerClockSum*0.1;
str += " /mAs";
}
fIpSumString.SetString(str);
//printf("String = %s\n", (const char*) str);
}
//----------------------------------------------------------
void TLemStats::SetScalerClockSum(Double_t value){
TString str;
fScalerClockSum = value;
str = "21 Sum Clock (Scaler) : ";
str += value;
fScalerClockSumString.SetString(str);
//printf("String = %s\n", (const char*) str);
}
//----------------------------------------------------------
void TLemStats::SetTdcClockSum(Double_t value){
TString str;
fTdcClockSum = value;
str = "22 Sum Clock (TDC) : ";
str += value;
fTdcClockSumString.SetString(str);
//printf("String = %s\n", (const char*) str);
}
//----------------------------------------------------------
void TLemStats::SetNevents(Double_t value){
TString str;
fNevents = value;
str = "23 Sum Slow Muon Events: ";
str += value;
fNeventsString.SetString(str);
}
//----------------------------------------------------------
void TLemStats::SetTdSum(Double_t value){
TString str;
fTdSum = value;
str = "24 Sum TD : ";
str += value;
fTdSumString.SetString(str);
}
//----------------------------------------------------------
void TLemStats::SetTdCleanSum(Double_t value){
TString str;
fTdCleanSum = value;
str = "25 Sum TD_Clean : ";
str += value;
fTdCleanSumString.SetString(str);
}
//----------------------------------------------------------
void TLemStats::SetTdGoodSum(Double_t value){
TString str;
fTdGoodSum = value;
str = "26 Sum TD_Good : ";
str += value;
fTdGoodSumString.SetString(str);
}
//----------------------------------------------------------
void TLemStats::SetPosSum(const Double_t *value){
TString str;
str = "27 Sum Positrons : ";
for (Int_t i = 0; i < fNPosDetectors; i++){
fPosSum[i] = value[i];
str += value[i];
str += " ";
}
fPosSumString.SetString(str);
}
//----------------------------------------------------------

86
src/external/TLemRunHeader/TLemStats.h vendored Normal file
View File

@ -0,0 +1,86 @@
// TLemStats.h
//
// T.Prokscha, 25-April-2007
//
// Lem Statistics for LEM Run Header. Define own class which
// appears as a subdirectory in the /RunInfo/TLemRunHeader
// directory of a root file.
//
// use TObjString class: this has the advantage, that
// we can "see" the header in the root browser; also, have to
// "number" the lines so that they appear in the right order
// in TBrowser.
// Anyway, this is just a test - and a final "root" header
// definition should be closer to uSR Nexus definition?
//
//
#ifndef __TLemStats__
#define __TLemStats__
//#include <iostream>
//#include "TSystem.h"
#include "TObject.h"
#include "TObjString.h"
//#include "TMath.h"
//#include "TApplication.h"
//#include "TCanvas.h"
//#include "TText.h"
//#include "TPaveText.h"
#define NHIST 32
//using std::cout;
//using std::endl;
//------------------------------------------------
// class for LEM statistics
class TLemStats : public TObject {
private:
TObjString fIpSumString; //sum of Ip counts in one run
Double_t fIpSum;
TObjString fScalerClockSumString; //sum of 10kHz counts in one run
Double_t fScalerClockSum; //extracted from VME scaler module
TObjString fTdcClockSumString; //sum of 10kHz counts in one run,
Double_t fTdcClockSum; //extracted from VME TDC
TObjString fNeventsString; //total number of slow muon events
Double_t fNevents;
TObjString fTdSumString; //total number of TD hits (muon start detector for LEM)
Double_t fTdSum;
TObjString fTdCleanSumString; //total number of TD hits without pre-pileup
Double_t fTdCleanSum;
TObjString fTdGoodSumString; //total number of TD hirs without pre- and post-pileup
Double_t fTdGoodSum;
TObjString fPosSumString; //total number of slow muon events
Double_t fPosSum[NHIST]; //total number of positron detector hits inLEM detectors
Int_t fNPosDetectors; //number of e+ detectors/histograms
public:
TLemStats();
virtual ~TLemStats();
virtual Bool_t IsFolder() const { return kTRUE; } // make object "browsable"
virtual void SetIpSum(Double_t value);
virtual void SetScalerClockSum(Double_t value);
virtual void SetTdcClockSum(Double_t value);
virtual void SetNevents(Double_t value);
virtual void SetTdSum(Double_t value);
virtual void SetTdCleanSum(Double_t value);
virtual void SetTdGoodSum(Double_t value);
virtual void SetPosSum(const Double_t *value);
virtual void SetNPosDetectors(Int_t n) { fNPosDetectors = n; }
virtual Double_t GetIpSum() const { return fIpSum; }
virtual Double_t GetScalerClockSum() const { return fScalerClockSum; }
virtual Double_t GetTdcClockSum() const { return fTdcClockSum; }
virtual Double_t GetNevents() const { return fNevents; }
virtual Double_t GetTdSum() const { return fTdSum; }
virtual Double_t GetTdCleanSum() const { return fTdCleanSum; }
virtual Double_t GetTdGoodSum() const { return fTdGoodSum; }
virtual Double_t *GetPosSum() { return fPosSum; }
TObjString GetIpSumString() const { return fIpSumString; }
virtual Int_t GetNPosDetectors() const { return fNPosDetectors;}
//2nd version of TLemStats
ClassDef(TLemStats,2) //LEM Statistics
};
#endif

14
src/external/TLemRunHeader/TLemStatsLinkDef.h vendored Normal file
View File

@ -0,0 +1,14 @@
#ifdef __CINT__
#pragma link off all globals;
#pragma link off all classes;
#pragma link off all functions;
//#pragma link C++ class TLemStartTime+;
//#pragma link C++ class TLemStopTime+;
//#pragma link C++ class TLemRunTitle+;
//#pragma link C++ class TLemSetup+;
//#pragma link C++ class TLemRunNumber+;
#pragma link C++ class TLemStats+;
#endif