ROOT logo
#ifndef __TMrbModule_h__
#define __TMrbModule_h__

//_________________________________________________[C++ CLASS DEFINITION FILE]
//////////////////////////////////////////////////////////////////////////////
// Name:           expconf/inc/TMrbModule.h
// Purpose:        Define experimental configuration for MARaBOU
// Class:          TMrbModule           -- base class for camac & vme modules
// Description:    Class definitions to implement a configuration front-end for MARaBOU
// Author:         R. Lutter
// Revision:       $Id: TMrbModule.h,v 1.24 2011-05-18 11:04:49 Marabou Exp $
// Date:
// Keywords:
//////////////////////////////////////////////////////////////////////////////

namespace std {} using namespace std;

#include <cstdlib>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <fstream>

#include "Rtypes.h"
#include "TSystem.h"
#include "TObject.h"
#include "TNamed.h"
#include "TString.h"
#include "TObjArray.h"

#include "TMrbNamedX.h"
#include "TMrbLofNamedX.h"
#include "TMrbTemplate.h"

#include "TMrbConfig.h"

class TMrbSubevent;
class TMrbModuleChannel;

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbModule
// Purpose:        Define methods for a camac or vme module
// Description:    Defines a camac or vme module to be used in the MARaBOU environment.
// Keywords:
//////////////////////////////////////////////////////////////////////////////

class TMrbModule : public TNamed {

	public:

		TMrbModule() {};								// default ctor

														// explicit ctor:	name, id, nofchannels, range
		TMrbModule(const Char_t * ModuleName, const Char_t * ModuleID, Int_t NofChannels, Int_t Range);

		~TMrbModule() {									// dtor
//			fChannelSpec.Delete();
			DeleteRegisters();
		};

		Bool_t Set(const Char_t * RegName, Int_t Value, Int_t Channel = -1);	// set channel register by name
		Bool_t Set(Int_t RegIndex, Int_t Value, Int_t Channel = -1); 			// ... by index
		Int_t Get(const Char_t * RegName, Int_t Channel = -1) const;  			// get channel register by name
		Int_t Get(Int_t RegIndex, Int_t Channel = -1) const;				 	// ... by index

		Bool_t Set(const Char_t * RegName, const Char_t * Value, Int_t Channel = -1);	// set channel register mnemonically
		Bool_t Set(Int_t RegIndex, const Char_t * Value, Int_t Channel = -1); 	// ... by index

		inline TMrbNamedX * FindRegister(const Char_t * RegName) const {				// find register by its name
			return(fLofRegisters.FindByName(RegName, TMrbLofNamedX::kFindUnique | TMrbLofNamedX::kFindIgnoreCase));
		};
																				// find register by index
		inline TMrbNamedX * FindRegister(Int_t RegIndex) const { return(fLofRegisters.FindByIndex(RegIndex)); };

		inline Bool_t HasRegisters() const { return(fLofRegisters.GetEntriesFast() > 0); };	// check if there are some registers

		inline Bool_t AllocateHistograms(Bool_t Flag = kTRUE) { fHistosToBeAllocated = Flag; return(kTRUE); }; // create histograms?
		inline Bool_t HistosToBeAllocated() const { return(fHistosToBeAllocated); };
		inline Bool_t ConvertToInt() const { return(kTRUE); };						// convert short to int

		inline void SetActive(Bool_t ActiveFlag = kTRUE) { fIsActive = ActiveFlag; };
		inline Bool_t IsActive() const { return(fIsActive); };						// module active?

		inline void ExcludeFromReadout(Bool_t ExcludeFlag = kTRUE) { fExcludeFromReadout = ExcludeFlag; };
		inline Bool_t ToBeExcludedFromReadout() const { return(fExcludeFromReadout); };						// module active?

		Bool_t SetBlockReadout(Bool_t Flag = kTRUE);							// turn block mode on
		inline Bool_t HasBlockReadout() const { return(fBlockReadout); }; 			// check if block mode

		inline TMrbLofNamedX * GetLofRegisters() { return(&fLofRegisters); };	// list of registers

		inline Int_t GetRange() { return(fRange); };							// get module range
		inline TMrbNamedX * GetDataType() const { return(fDataType); };				// get data type

		inline void SetBinning(Int_t ChansPerBin = 1) {						// define bin size for histograms
			fChansPerBin = ChansPerBin;
			fBinRange = (fXmax - fXmin + fChansPerBin - 1) / fChansPerBin;
		};
		inline Int_t GetBinning() const { return(fChansPerBin); };				// get bin values

		inline void SetBinRange(Int_t BinRange) { fBinRange = BinRange; };
		inline Int_t GetBinRange() const { return(fBinRange); };

		Bool_t SetXmin(Int_t Xmin = 0);											// set min / max in X
		Bool_t SetXmax(Int_t Xmax = 0);
		inline Int_t GetXmin() { return(fXmin); };
		inline Int_t GetXmax() { return(fXmax); };

		inline Int_t GetSubDevice() const { return(fSubDevice); };					// get subdevice number

		void SetType(UInt_t ModuleType, Bool_t OrFlag = kTRUE);					// set module type
		inline TMrbNamedX * GetType() { return(&fModuleType); }; 				// return type bits
		inline TMrbNamedX * GetModuleID() { return(&fModuleID); }; 				// return id

		virtual inline const Char_t * GetMnemonic() const { return("unknown"); }; 	// module mnemonic (usually 3 to 4 char code)

		inline const Char_t * GetPosition() const { return(fPosition.Data()); };

		inline Int_t GetCrate() const { return(fCrate); };							// return crate number
		inline Int_t GetSerial() const { return(fSerial); };  	 					// return unique module id

		Bool_t SetMbsBranch(Int_t MbsBranchNo, const Char_t * MbsBranchName = NULL);	// mbs branch
		inline Bool_t SetMbsBranch(TMrbNamedX * MbsBranch) { return(this->SetMbsBranch(MbsBranch->GetIndex(), MbsBranch->GetName())); };
		inline TMrbNamedX * GetMbsBranch() { return(&fMbsBranch); };
		inline Int_t GetMbsBranchNo() { return(fMbsBranch.GetIndex()); };
		inline Bool_t IsAssignedToBranch() { return (fMbsBranch.GetIndex() != -1); };
		
		inline void SetTimeOffset(Int_t TimeOffset) { fTimeOffset = TimeOffset; };	// time offset
		inline Int_t GetTimeOffset() const { return(fTimeOffset); };

		inline Bool_t CheckID(TMrbConfig::EMrbModuleID ModuleID) const { return(fModuleID.GetIndex() == ModuleID); };

		inline Int_t GetNofShortsPerChannel() const { return(fNofShortsPerChannel); };	// 16 bit words per channel
		inline Int_t GetNofShortsPerDatum() const { return(fNofShortsPerDatum); };		// 16 bit words per datum
		inline Int_t GetNofDataBits() const { return(fNofDataBits); };					// data bits

		inline Int_t GetNofChannels() const { return(fNofChannels); }; 				// max number of channels
		Int_t GetNofChannelsUsed() const; 											// calculate number of channels in use
		UInt_t GetPatternOfChannelsUsed() const; 										// pattern of channels actually used
		Bool_t CheckIfPatternIsContiguous() const;						// check if channels have been assigned contiguously
		inline TObjArray * GetLofChannels() { return(&fChannelSpec); };			// list of channels
		const Char_t * GetLofChannelsAsString(TString & LofChannels) const;

		TMrbModuleChannel * GetChannel(Int_t) const;											// get channel addr

		Bool_t LoadCodeTemplates(const Char_t * TemplateFile);					// load code templates

		virtual Bool_t MakeReadoutCode(ofstream & RdoStrm, TMrbConfig::EMrbReadoutTag TagIndex, TMrbTemplate & Template, const Char_t * Prefix = NULL) { return(kFALSE); }; // generate readout code

		virtual Bool_t MakeReadoutCode(ofstream & RdoStrm, TMrbConfig::EMrbModuleTag TagIndex) { return(kFALSE); };  	// generate code for given channel
		virtual Bool_t MakeReadoutCode(ofstream & RdoStrm, TMrbConfig::EMrbModuleTag TagIndex, TMrbModuleChannel * Channel, Int_t Value = 0) { return(kFALSE); };

		virtual Bool_t MakeAnalyzeCode(ofstream & AnaStrm, TMrbConfig::EMrbAnalyzeTag TagIndex, const Char_t * Extension);	// generate part of analyzing code

		virtual Bool_t MakeRcFile(ofstream & RcStrm, TMrbConfig::EMrbRcFileTag TagIndex, const Char_t * ResourceName) { return(kFALSE); };

		inline Bool_t IsCamac() const { return((fModuleType.GetIndex() & TMrbConfig::kModuleCamac) != 0); }; // camac or vme?
		inline Bool_t IsVME() const { return((fModuleType.GetIndex() & TMrbConfig::kModuleVME) != 0); }; 	// ...

		void PrintRegister(ostream & OutStrm, const Char_t * RegName, const Char_t * Prefix = "") const;	 // show register settings
		inline void PrintRegister(const Char_t * RegName) const { PrintRegister(cout, RegName, ""); };

		void Print(Option_t * Option) const { TObject::Print(Option); }
		void Print(ostream & OutStrm, const Char_t * Prefix = "") const {};	// show data
		inline virtual void Print() const { Print(cout, ""); };

		virtual inline Int_t GetNofSubDevices() const { return(1); }; 						// 1 subdevice per default
		virtual inline Bool_t HasRandomReadout() const { return(kTRUE); };					// modules allow random readout normally
		virtual inline Bool_t IsRaw() const { return(kFALSE); };								// not raw (user-defined) mode
		virtual inline Bool_t CheckSubeventType(TMrbSubevent * Subevent) const { return(kTRUE); }; // module may be stored in any subevent
		virtual inline Bool_t CheckProcType() { return(kTRUE); };						// module may be used with any ppc type

		virtual inline Bool_t HasPrivateCode() const { return(kFALSE); }; 					// normal code generation
		virtual inline const Char_t * GetPrivateCodeFile() const { return(NULL); };
		virtual inline const Char_t * GetCommonCodeFile() { return(NULL); };

		inline void CreateHistoArray(const Char_t * ArrayName = NULL) {		// create array of histograms and write .histlist file
			fCreateHistoArray = kTRUE;
			fHistoArrayName = ArrayName ? ArrayName : this->GetName();
		}
		inline Bool_t HistoArrayToBeCreated() { return(fCreateHistoArray); };
		inline const Char_t * GetHistoArrayName() { return(fHistoArrayName.Data()); };

		virtual inline Char_t * GetDeviceStruct() { return(NULL); };

		Bool_t SetMbsFctName(const Char_t * FctName, TMrbConfig::EMrbModuleFunction Fct);
		const Char_t * GetMbsFctName(TString & FctName, TMrbConfig::EMrbModuleFunction Fct);

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

	protected:
		virtual void DefineRegisters() {};
		void DeleteRegisters();

	protected:
		TMrbNamedX fModuleID;					// module id
		TMrbNamedX fModuleType;					// module type
		Int_t fSerial;							// unique serial number
		Bool_t UtilitiesLoaded; 				// kTRUE if some utility procedures already loaded
		Int_t fNofChannels;						// number of channels available

		Bool_t fIsActive; 						// kTRUE if module active
		Bool_t fExcludeFromReadout; 			// kTRUE if to be EXcluded from readout

		TMrbNamedX * fDataType;					// data type
		Int_t fNofShortsPerChannel; 			// number of 16 bit words per channel
		Int_t fNofShortsPerDatum;  				// number of 16 bit words per datum
		Int_t fNofDataBits; 					// length of data

		TMrbNamedX fMbsBranch;					// branch within MBS

		Int_t fCrate;							// crate number

		TString fPosition;					// crate & addr

		Int_t fRange;							// number of data points
		Int_t fXmin;							// xmin / xmax
		Int_t fXmax;
		Int_t fChansPerBin;					// channels per bin
		Int_t fBinRange;						// number of bins
		Int_t fSubDevice;						// subdevice

		Int_t fTimeOffset;						// time offset

		Bool_t fBlockReadout;					// kTRUE if block readout;

		Bool_t fHistosToBeAllocated;			// kTRUE if histograms to be allocated for each channel

		TMrbLofNamedX fLofRegisters;	 		// list of registers

		TMrbTemplate fCodeTemplates; 			// store template code

		Bool_t fCreateHistoArray;				// kTRUE if histo array / .histlist file is to be created
		TString fHistoArrayName;				// name of histo array / .histlist file

		TObjArray fChannelSpec;					// channel specifications (type TMrbModuleChannel *)

		TObjArray fLofMbsFctNames;				// define indiviual function names to be used with MBS

	ClassDef(TMrbModule, 1) 	// [Config] Base class describing a module (CAMAC or VME)
};

#endif
 TMrbModule.h:1
 TMrbModule.h:2
 TMrbModule.h:3
 TMrbModule.h:4
 TMrbModule.h:5
 TMrbModule.h:6
 TMrbModule.h:7
 TMrbModule.h:8
 TMrbModule.h:9
 TMrbModule.h:10
 TMrbModule.h:11
 TMrbModule.h:12
 TMrbModule.h:13
 TMrbModule.h:14
 TMrbModule.h:15
 TMrbModule.h:16
 TMrbModule.h:17
 TMrbModule.h:18
 TMrbModule.h:19
 TMrbModule.h:20
 TMrbModule.h:21
 TMrbModule.h:22
 TMrbModule.h:23
 TMrbModule.h:24
 TMrbModule.h:25
 TMrbModule.h:26
 TMrbModule.h:27
 TMrbModule.h:28
 TMrbModule.h:29
 TMrbModule.h:30
 TMrbModule.h:31
 TMrbModule.h:32
 TMrbModule.h:33
 TMrbModule.h:34
 TMrbModule.h:35
 TMrbModule.h:36
 TMrbModule.h:37
 TMrbModule.h:38
 TMrbModule.h:39
 TMrbModule.h:40
 TMrbModule.h:41
 TMrbModule.h:42
 TMrbModule.h:43
 TMrbModule.h:44
 TMrbModule.h:45
 TMrbModule.h:46
 TMrbModule.h:47
 TMrbModule.h:48
 TMrbModule.h:49
 TMrbModule.h:50
 TMrbModule.h:51
 TMrbModule.h:52
 TMrbModule.h:53
 TMrbModule.h:54
 TMrbModule.h:55
 TMrbModule.h:56
 TMrbModule.h:57
 TMrbModule.h:58
 TMrbModule.h:59
 TMrbModule.h:60
 TMrbModule.h:61
 TMrbModule.h:62
 TMrbModule.h:63
 TMrbModule.h:64
 TMrbModule.h:65
 TMrbModule.h:66
 TMrbModule.h:67
 TMrbModule.h:68
 TMrbModule.h:69
 TMrbModule.h:70
 TMrbModule.h:71
 TMrbModule.h:72
 TMrbModule.h:73
 TMrbModule.h:74
 TMrbModule.h:75
 TMrbModule.h:76
 TMrbModule.h:77
 TMrbModule.h:78
 TMrbModule.h:79
 TMrbModule.h:80
 TMrbModule.h:81
 TMrbModule.h:82
 TMrbModule.h:83
 TMrbModule.h:84
 TMrbModule.h:85
 TMrbModule.h:86
 TMrbModule.h:87
 TMrbModule.h:88
 TMrbModule.h:89
 TMrbModule.h:90
 TMrbModule.h:91
 TMrbModule.h:92
 TMrbModule.h:93
 TMrbModule.h:94
 TMrbModule.h:95
 TMrbModule.h:96
 TMrbModule.h:97
 TMrbModule.h:98
 TMrbModule.h:99
 TMrbModule.h:100
 TMrbModule.h:101
 TMrbModule.h:102
 TMrbModule.h:103
 TMrbModule.h:104
 TMrbModule.h:105
 TMrbModule.h:106
 TMrbModule.h:107
 TMrbModule.h:108
 TMrbModule.h:109
 TMrbModule.h:110
 TMrbModule.h:111
 TMrbModule.h:112
 TMrbModule.h:113
 TMrbModule.h:114
 TMrbModule.h:115
 TMrbModule.h:116
 TMrbModule.h:117
 TMrbModule.h:118
 TMrbModule.h:119
 TMrbModule.h:120
 TMrbModule.h:121
 TMrbModule.h:122
 TMrbModule.h:123
 TMrbModule.h:124
 TMrbModule.h:125
 TMrbModule.h:126
 TMrbModule.h:127
 TMrbModule.h:128
 TMrbModule.h:129
 TMrbModule.h:130
 TMrbModule.h:131
 TMrbModule.h:132
 TMrbModule.h:133
 TMrbModule.h:134
 TMrbModule.h:135
 TMrbModule.h:136
 TMrbModule.h:137
 TMrbModule.h:138
 TMrbModule.h:139
 TMrbModule.h:140
 TMrbModule.h:141
 TMrbModule.h:142
 TMrbModule.h:143
 TMrbModule.h:144
 TMrbModule.h:145
 TMrbModule.h:146
 TMrbModule.h:147
 TMrbModule.h:148
 TMrbModule.h:149
 TMrbModule.h:150
 TMrbModule.h:151
 TMrbModule.h:152
 TMrbModule.h:153
 TMrbModule.h:154
 TMrbModule.h:155
 TMrbModule.h:156
 TMrbModule.h:157
 TMrbModule.h:158
 TMrbModule.h:159
 TMrbModule.h:160
 TMrbModule.h:161
 TMrbModule.h:162
 TMrbModule.h:163
 TMrbModule.h:164
 TMrbModule.h:165
 TMrbModule.h:166
 TMrbModule.h:167
 TMrbModule.h:168
 TMrbModule.h:169
 TMrbModule.h:170
 TMrbModule.h:171
 TMrbModule.h:172
 TMrbModule.h:173
 TMrbModule.h:174
 TMrbModule.h:175
 TMrbModule.h:176
 TMrbModule.h:177
 TMrbModule.h:178
 TMrbModule.h:179
 TMrbModule.h:180
 TMrbModule.h:181
 TMrbModule.h:182
 TMrbModule.h:183
 TMrbModule.h:184
 TMrbModule.h:185
 TMrbModule.h:186
 TMrbModule.h:187
 TMrbModule.h:188
 TMrbModule.h:189
 TMrbModule.h:190
 TMrbModule.h:191
 TMrbModule.h:192
 TMrbModule.h:193
 TMrbModule.h:194
 TMrbModule.h:195
 TMrbModule.h:196
 TMrbModule.h:197
 TMrbModule.h:198
 TMrbModule.h:199
 TMrbModule.h:200
 TMrbModule.h:201
 TMrbModule.h:202
 TMrbModule.h:203
 TMrbModule.h:204
 TMrbModule.h:205
 TMrbModule.h:206
 TMrbModule.h:207
 TMrbModule.h:208
 TMrbModule.h:209
 TMrbModule.h:210
 TMrbModule.h:211
 TMrbModule.h:212
 TMrbModule.h:213
 TMrbModule.h:214
 TMrbModule.h:215
 TMrbModule.h:216
 TMrbModule.h:217
 TMrbModule.h:218
 TMrbModule.h:219
 TMrbModule.h:220
 TMrbModule.h:221
 TMrbModule.h:222
 TMrbModule.h:223
 TMrbModule.h:224
 TMrbModule.h:225
 TMrbModule.h:226
 TMrbModule.h:227
 TMrbModule.h:228
 TMrbModule.h:229
 TMrbModule.h:230
 TMrbModule.h:231
 TMrbModule.h:232
 TMrbModule.h:233
 TMrbModule.h:234
 TMrbModule.h:235
 TMrbModule.h:236
 TMrbModule.h:237
 TMrbModule.h:238
 TMrbModule.h:239
 TMrbModule.h:240
 TMrbModule.h:241
 TMrbModule.h:242
 TMrbModule.h:243
 TMrbModule.h:244