/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/include/root/MTRun.hh

Go to the documentation of this file.

#ifndef ROOT_MTRun
#define ROOT_MTRun


#include "TObject.h"
#include "TClonesArray.h"
#include "TRefArray.h"
#include "TRef.h"
#include "TH1.h"
#include "TMath.h"
#include <vector>
#include <map>

class MTChip;
class MTDif;
class MTDetector;
class Run;

////////////////////////////////////////////////////////////////////////////
// CLASS MTRUN(containing constant run indormations)
//- 1 Run correspond a 1 prise de donnée réel.
//  ou a une configuration chjip + dif en mode calibration
//- Dans un Run il ne peut y avoir qu' une cofiguration de DIF et de Hardroc
////////////////////////////////////////////////////////////////////////////


class MTRun : public TObject {

public:
   MTRun();
   MTRun(const Run& aRun);
   virtual ~MTRun();
   MTRun& operator=(const Run& aRun);
private:
   // Run informations
   
   UInt_t        id;                 // XML or in filename for XDaq
   TString       name;               // XML
   TString       date;               // XML
   bool          processed;          // default false

   bool          calibrationRun;     // Set by parser. Default is false;
   bool          difSynchro;         //set true for dif_synchro acquisition
   // Reconstruction information
   
   time_t      reconstructionDate ;  // millisec from 1 janv 1970 */
   TString     rawDataFilename;      // <- from XML
   TString     svnrev;               // <- from source code
   Char_t      rawDataFormat;        // Raw data format
         
   //electronic
   Char_t      daqSoftVersion;       // DAQ software version
         Char_t      cccFirmwareVersion;   // CCC firmwareVersion


/*
   // Detector information
   TString       detectorName;
   TString       detectorDescription;

   // Chamber configuration information
   std::map<UInt_t,MTChamber*>    chamberConfig; // Map key is dif id
   // Dif configuration information
   std::map<UInt_t,MTDif*>    difConfig; // Map key is dif id
   // Chip configuration information
   std::map<Long_t,MTChip*>   chipConfig;// Map key is chip softId
*/
   UShort_t delayTrigger;

   // calibration only    // Infos from calibration raw data file
   Float_t injectedCharge;      // 16 bits
   UShort_t widthCtest;     // 10 bit store in 16 bits
   UShort_t periodCtest;    // 10 bit store in 16 bits
   UShort_t delayCtest;     // 10 bit store in 16 bits

   MTDetector *detector;

   

public:

   time_t   GetReconstructionDate(TString  &dateToComplete) const;
   void     SetRawDataFilename(TString   value) { rawDataFilename = value;};
   TString  GetRawDataFilename(void)  const     { return rawDataFilename; };
   TString  GetRunName(void)  const   { return name; };
   UInt_t   GetRunId(void ) const { return id; } ;
   void     SetRunId(UInt_t value ) { id = value ; } ;

   bool     GetProcessed(void) { return processed; } ;
   void     SetProcessed(bool value) { processed = value; } ;

   TString  GetDate() {return date;};
   void     SetDate(TString     aDate) { date = aDate; };

   TString  GetSvnVersion() const { return svnrev; }; 

   bool     IsCalibrationRun(void) const { return calibrationRun; };
   void     SetCalibrationRun(bool aValue) { calibrationRun = aValue; }

   bool     IsDifSynchro(void) const { return difSynchro; };
   void     SetDifSynchro(bool aValue) { difSynchro = aValue; }

   void       SetDectector(MTDetector *value) { detector = value; } ;
   MTDetector* GetDetector(void) const { return detector ; } ;

  Char_t   GetRawDataFormat() const { return rawDataFormat ; };
  Char_t   GetDaqSoftVersion() const { return daqSoftVersion ; };
  Char_t   GetCCCFirmwareVersion() const { return cccFirmwareVersion ; };

  const MTChip& GetOneChip(void ) const ;

/*
TString GetDetectorDescription(void) const{ return detectorDescription;  };
void  SetDetectorDescription(TString  aValue){ detectorDescription = aValue;};

*/
/*
// Chamber configuration information
const std::map<UInt_t,MTChamber*>& GetChamberConfigs(void)
{ return chamberConfig; } ;
const MTChamber&  GetChamberConfig(UInt_t id) const
 { return *(chamberConfig.find(id)->second); };

// Dif configuration information
const std::map<UInt_t,MTDif*>& GetDifConfigs(void)
{ return difConfig; } ;
const MTDif&                  GetDifConfig(UInt_t id) const
 { return *(difConfig.find(id)->second); };

// Chip configuration information
const std::map<Long_t,MTChip*>& GetChipConfigs(void) const
{return chipConfig;};
const MTChip& GetChipConfig(Long_t chipId) const
{ return *(chipConfig.find(chipId)->second); };
void SetChipConfig(Long_t chipId, MTChip& chip)
{ chipConfig[chipId] = &chip;};
*/
   // calibration only    // Infos from calibration raw data file
   Float_t   GetInjectedCharge(void) const { return injectedCharge; } ;
   UShort_t GetWidthCtest(void) const   { return widthCtest;   } ;
   UShort_t GetPeriodCtest(void) const  { return periodCtest;  } ;
   UShort_t GetDelayCtest(void) const   { return delayCtest;   } ;
   UShort_t GetDelayTrigger(void) const { return delayTrigger;  } ;


   //void SetInjectedCharge(UInt_t aValue) {  injectedCharge = aValue; } ;
   void SetInjectedCharge(Float_t aValue) {  injectedCharge = aValue; } ;
   void SetWidthCtest(UInt_t aValue)   {  widthCtest = aValue;   } ;
   void SetPeriodCtest(UInt_t aValue)  {  periodCtest = aValue;  } ;
   void SetDelayCtest(UInt_t aValue)   {  delayCtest = aValue;   } ;
   void SetDelayTrigger(UInt_t aValue) {  delayTrigger = aValue;   } ;

         void  Info(void) const;

   ClassDef(MTRun, 30)  //MTRun structure
};


#endif

---