ROOT logo
TCTAnalyse » . » MeasureWF

class MeasureWF: public TObject

 MeassureWF

 This class handels the voltage scans produced with TCT Labview software (".tct" files)!
 Waveform vectors are stored in the histograms on which the data manipultaion rutines work

Function Members (Methods)

public:
MeasureWF(Int_t = 60)
MeasureWF(const MeasureWF&)
MeasureWF(Char_t*, Int_t = 5001, Float_t = 0)
MeasureWF(Int_t, Char_t*, Float_t = 0)
virtual~MeasureWF()
voidTObject::AbstractMethod(const char* method) const
voidAddHisto(Float_t, TH1F*)
voidAddHisto(Int_t, Float_t, TH1F*)
TGraph*AnalysePSTCT(Int_t = -1, Int_t = -1, Int_t = 1, Float_t = 0, Float_t = 0, Int_t = 2, Int_t = 1, Int_t = 1)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
TGraph*CCE(Float_t = -1111, Float_t = -1111, Int_t = 0, Int_t = 1)
TGraph*CCEE(Elec*, Float_t = -1111, Int_t = 0, Int_t = 1)
TGraph*CCEFit(Float_t = -1111, Float_t = -1111, Float_t = 1, Float_t = 200, Int_t = 0, Int_t = 1)
TH1F*ChargeShape(Float_t)
voidChargeShape(Int_t, Int_t, Int_t = 1)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
voidCompareHisto(TH1F*, Float_t)
virtual voidTObject::Copy(TObject& object) const
voidCorrectBaseLine(Int_t = 0)
virtual voidTObject::Delete(Option_t* option = "")MENU
TH1F*Derivation(Float_t, Int_t = 6, Int_t = 1)
voidDerivation(Int_t, Int_t, Int_t = 1)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
voidDraw(Float_t Volt, Option_t* opt, Float_t low = -1111, Float_t high = -1111)
voidDraw(Int_t, Option_t*, Float_t = -1111, Float_t = -1111)
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
TGraph*DrawIV(Int_t = 0)
voidDrawMulti(Float_t = -1111., Float_t = -1111., Int_t = -1, Int_t = -1, Int_t = 1, Int_t = 0, Int_t = -1111)
voidDrawTest(int)
TGraph*DrawTV(Int_t = 0)
virtual voidTObject::Dump() constMENU
voidEffTau(Int_t, Int_t, Float_t, Float_t, Int_t, Float_t, Float_t = 0.03)
voidEffTau(Int_t, Int_t, Float_t*, Float_t*, Int_t, Float_t, Float_t = 0.03)
voidEffTauComplex(Int_t, Int_t, Float_t, Float_t, Int_t, Float_t, Float_t = 0.03)
voidEffTauComplex(Int_t, Int_t, Float_t*, Float_t*, Int_t, Float_t, Float_t = 0.03)
voidEffTauSave(Int_t, Int_t, Float_t*, Float_t*, Int_t, Float_t*, Int_t, Float_t = 0.03)
TH1F*ElField(Int_t, Float_t, Float_t, Float_t, Int_t = -1, Int_t = 2, Int_t = 0)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
TH1F*EShaping(Elec*, Int_t)
TH1F*EShaping(Elec* el, Float_t Volt)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Float_tGetAnnealTime()
Float_tGetCurrent(Int_t index)
Float_tGetCurrent(Float_t Volt)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
doubleGetElField(TH1F*, Float_t, Float_t, Float_t)
Int_tGetEntries()
doubleGetEVel(double, double = -1)
Float_tGetFDV(Elec*, Float_t, Float_t, Float_t, Float_t, Int_t = 0, Int_t = 0)
Float_tGetFDV(Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Int_t = 0, Int_t = 0)
TH1F*GetHA(Double_t voltage)
TH1F*GetHA(Int_t index)
voidGetHistogram(Int_t number, TH1F* his)
voidGetHistogram(Float_t voltage, TH1F* his)
virtual const char*TObject::GetIconName() const
Int_tGetIndex(Float_t Volt)
voidGetIntegral(Float_t*, Float_t = 1, Float_t = -1111, Float_t = -1111)
voidGetIntegral(Float_t*, Float_t*, Float_t = 1, Float_t = -1111, Float_t = -1111)
virtual const char*TObject::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
Float_tGetT()
Float_tGetT(Float_t Volt)
Float_tGetT(Int_t index)
Float_tGetTime(Float_t = 3600)
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
doubleGetVelE(double, double = -1)
doubleGetVelField(TH1F*, Float_t, Float_t, Float_t)
TH1F*GetVelHisto(Float_t, Float_t, Int_t = 0)
Float_tGetVoltage(Int_t index)
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
voidInfo()
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
Int_tint2ascii(Char_t* v, Float_t, Int_t = 1)
Float_tIntegral(Float_t, Float_t = -1111, Float_t = -1111)
Float_tIntegral(Int_t, Float_t = -1111, Float_t = -1111)
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
voidLegend(TH1*, Int_t, Int_t, Int_t = 1, Int_t = 0)
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
Double_tMobility(Float_t, Float_t, Float_t, Double_t, Int_t = 0)
voidNormArray(Int_t, Float_t*)
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TH1F*operator()(Double_t voltage)
TH1F*operator()(Int_t index)
MeasureWF&operator=(const MeasureWF&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
TGraph*PosTime(Float_t = -1111., Float_t = -1111., Int_t = -1, Int_t = -1, Int_t = 1, Int_t = 0, Int_t = -1111)
virtual voidTObject::Print(Option_t* option = "") const
voidPrintVoltages()
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
TGraph*RiseTime(Float_t = -1111., Float_t = -1111., Int_t = -1, Int_t = -1, Int_t = 1, Int_t = 0, Int_t = -1111)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidScaleHisto(Float_t fac = -1)
voidScaleHisto(Int_t number, Float_t fac)
voidSetAnnealTime(Float_t x)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetCapacitance(Double_t x)
voidSetCurrents(Float_t* currents)
voidSetDate(Float_t* date)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetFrequencies(Float_t* freq)
voidSetHistoTime(int ind, Float_t start)
voidSetHistoTime(int num, Float_t* start)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetTemperatures(Float_t* temperatures)
voidSetTemperatures(Float_t T)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetVoltage(Int_t index, Float_t voltage)
voidSetVoltages(Float_t* voltages)
voidSetVoltages(Float_t svol, Float_t step)
voidSetVoltages(Int_t num, Float_t svol, Float_t step)
virtual voidShowMembers(TMemberInspector&)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
TGraph*Tau(Float_t, Int_t, Int_t, Float_t*, Float_t*, Int_t = 0, Int_t = 0, TArrayI = 0)
TGraph*Tau(Float_t, Int_t, Int_t, Float_t = 0, Float_t = 50, Int_t = 0, Int_t = 0, TArrayI = 0)
TGraph*Tau(Elec*, Float_t, Int_t, Int_t, Float_t = 0, Float_t = 50, Int_t = 0, Int_t = 0, TArrayI = 0)
TGraph*TauVolt(Float_t, Float_t, Int_t, Int_t, Float_t = 0, Float_t = 50, Int_t = 1, Int_t = 0)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
TGraph*VoltTau(Float_t, Float_t, Int_t, Int_t, Float_t = 0, Float_t = 50, Int_t = 0, Int_t = 0, Int_t = 1, TArrayI = 0)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
private:
voidReadTCTForm(TString, Int_t, Float_t = -1111, Float_t = -1111, Int_t = 0)

Data Members

public:
Double_tCAP! Capacitance of the diode
boolDrawMode
TStringHeaderHeader of the file
Char_tprefix[10]
TPaveText*pt!
Char_tsuffix[10]
private:
Float_tAnnealTime
TArrayFCurrentArray of Currents
TArrayFDateDate of the Measurement (or simulation)
TArrayFFrequenciesArray of Frequnecies
Float_tFrequencyFrequency of trigger
Int_tMultipleNumber of Voltages
TArrayFTemperatureArray of Temperatures
TArrayFVoltagesArray of Voltages
TClonesArray*histo->

Class Charts

Inheritance Chart:
TObject
MeasureWF

Function documentation

MeasureWF(Int_t = 60)
 Default Constructor
 		Int_t num    ; Number of aqusitions
MeasureWF(Int_t , Char_t* , Float_t = 0)
 Int_t  NumOfFiles; number of files to be read
 Char_t *FileName; file name without serial number and extension. The files are supposed to end with .txt
 Float_t offset; offset in time. In order to use CorrectBaseLine function it is recomended that signal starts at t=0 ns
MeasureWF(Char_t* , Int_t = 5001, Float_t = 0)
 Constructor
 		Char_t *FileName ; File Name
 		Int_t bins       ; Number of bins per waveform
 		Int_t Start       ; Shift in time (Start time)
void ReadTCTForm(TString , Int_t , Float_t = -1111, Float_t = -1111, Int_t = 0)
 Reads TCT Form File (internaly used by constructor)!
 	      TString FileName ;  file name
 	      Int_t Bins       ;  number of bins
 	      Float_t StartBin ;  StartBin of the histogram (values are multiplied with 1e9 - scale in ns
 	      Float_t EndBin   ;  EndBin of the histogram
 	      Int_t Show       ;  verbose reading
~MeasureWF()
 Destructor
void AddHisto(Int_t , Float_t , TH1F* )
 Add histogram (waveform)
 		Int_t Index     ;  Index of the waveform
 		Float_t Voltage ;  Voltage at Index
 		TH1F*           ;  pointer to histogram of the waveform
 This function is internally used for reading the measurement files
void AddHisto(Float_t , TH1F* )
 Add histogram (waveform)
 	        Float_t Voltage ;  Voltage at Index
 		TH1F*           ;  pointer to histogram of the waveform
 This function is internally used for reading the measurement files.
 It is assumed that the array of waveforms is already initialized
 with voltages specified
void CompareHisto(TH1F* , Float_t )
  Compares measured histogram to any other histogram!
  Measured histogram is scaled to the input histogram!
                   TH1F *his       ;  input histogram
 		     Float_t voltage ;  histogram at voltage
void DrawTest(int )
void Draw(Int_t , Option_t* , Float_t = -1111, Float_t = -1111)
  Draw waveform
           Int_t number     ;  index of waveform
           Option_t *option ;  graphic option (see TH1F)
 	     Float_t low      ;  Time window
 	     Float_t high     ;
TGraph * RiseTime(Float_t = -1111., Float_t = -1111., Int_t = -1, Int_t = -1, Int_t = 1, Int_t = 0, Int_t = -1111)
  Draws multiple waveform on the same plot with legend
           Float_t low      ; Time window
           Float_t high     ;
 	     Int_t Start      ; start index
 	     Int_t End        ; end index
	     Int_t Step       ; step (default=1)
         Int_t model      ; positive scale in volts=2, deconvoluted pulse=1
 One of the most used functions
TGraph * AnalysePSTCT(Int_t = -1, Int_t = -1, Int_t = 1, Float_t = 0, Float_t = 0, Int_t = 2, Int_t = 1, Int_t = 1)
  Draws multiple waveform on the same plot with legend
 	     Int_t Start      ; start index
 	     Int_t End        ; end index
	     Int_t Step       ; step (default=1)
         Float_t limit    ; treshold value
 One of the most used functions
TGraph * PosTime(Float_t = -1111., Float_t = -1111., Int_t = -1, Int_t = -1, Int_t = 1, Int_t = 0, Int_t = -1111)
  Draws multiple waveform on the same plot with legend
           Float_t low      ; Time window
           Float_t high     ;
 	     Int_t Start      ; start index
 	     Int_t End        ; end index
	     Int_t Step       ; step (default=1)
         Int_t model      ; positive scale in volts=2, deconvoluted pulse=1
 One of the most used functions
void DrawMulti(Float_t = -1111., Float_t = -1111., Int_t = -1, Int_t = -1, Int_t = 1, Int_t = 0, Int_t = -1111)
  Draws multiple waveform on the same plot with legend
           Float_t low      ; Time window
           Float_t high     ;
 	     Int_t Start      ; start index
 	     Int_t End        ; end index
	     Int_t Step       ; step (default=1)
         Int_t model      ; positive scale in volts=2, deconvoluted pulse=1
         Int_t indsub      ; substract wafeforw index
 One of the most used functions
Float_t Integral(Int_t , Float_t = -1111, Float_t = -1111)
 Get waveform integral in time window
 	Int_t i      ; index
      Float_t mint ; Time window
      Float_t maxt ;
 One of the most used functions
Float_t Integral(Float_t , Float_t = -1111, Float_t = -1111)
 Get waveform integral in time window (uses voltage insted of index)
void GetIntegral(Float_t* , Float_t* , Float_t = 1, Float_t = -1111, Float_t = -1111)
 Gets integrals in certain time window
 		Float_t  *x  ;  array of voltages
 		Float_t  *y  ;  array of integrals
 		Float_t  scale ;  scaling factor
 		Float_t mint;   Time window
 		Float_t maxt;
void GetIntegral(Float_t* , Float_t = 1, Float_t = -1111, Float_t = -1111)
 Get Integral values only
TGraph * CCE(Float_t = -1111, Float_t = -1111, Int_t = 0, Int_t = 1)
 Get integral (charge) plot
                Float_t mint  ; Time Window
                Float_t maxt  ;
		    Int_t model   ; lin-lin=0  scale  sqrt-lin=1 abs(lin)-lin=2
		    Int_t Show    ; show graph
TGraph * CCEFit(Float_t = -1111, Float_t = -1111, Float_t = 1, Float_t = 200, Int_t = 0, Int_t = 1)
 Get integral (charge) plot
                Float_t mint  ; Time Window
                Float_t maxt  ;
		    Int_t model   ; lin-lin=0  scale  sqrt-lin=1 abs(lin)-lin=2
		    Int_t Show    ; show graph
void Legend(TH1* , Int_t , Int_t , Int_t = 1, Int_t = 0)
 Draw Legen (DrawMulti)
	       TH1F *ch    ; histogam
	       Int_t start ; start index
	       Int_t end   ; end index
	       Int_t model ; positive scale in volts=2
Float_t GetFDV(Elec* , Float_t , Float_t , Float_t , Float_t , Int_t = 0, Int_t = 0)
	Calculates FDV using CCE plot
		     Elec *el   ;  electronics used (See Elec)
		     See GetFDV(Float_t, Float_t .... ), for the rest of information
Float_t GetFDV(Float_t , Float_t , Float_t , Float_t , Float_t , Float_t , Int_t = 0, Int_t = 0)
	Calculates FDV using integral of current
		     Float_t low;  Time window
		     Float_t hi ;
		     Float_t x0 ;  first point of the first line
		     Float_t x1 ;  second point of the first line
		     Float_t x2 ;  first point of the second line
		     Float_t x3 ;  second point of the second line
		     Int_t model;  the model for FDV calculation (see CCE)
		     Int_t show ;  show plot
TGraph * Tau(Elec* , Float_t , Int_t , Int_t , Float_t = 0, Float_t = 50, Int_t = 0, Int_t = 0, TArrayI = 0)
 Calcultaes rendered integrals above FDV with the trapping time ; waveform is deconvoluted first
			Elec *el        ;  electronics
			Float_t tau     ;  trapping time constant
			Int_t start     ;  start index
			Int_t end       ;  end index
			Float_t mintime ;  Time window
			Float_t maxtime ; Time window
			Int_t Show      ; show graph
			Int_t model     ;
                    TArrayI exlist  ; list of excluded points = 0
TGraph * Tau(Float_t , Int_t , Int_t , Float_t* , Float_t* , Int_t = 0, Int_t = 0, TArrayI = 0)
 Calcultaes rendered integrals above FDV with the trapping time
			Float_t tau     ;  trapping time constant
			Int_t start     ;  start index
			Int_t end       ;  end index
			Float_t *mint   ; Time windows for each separate measurement
			Float_t *maxt   ;
			Int_t Show      ; show graph
			Int_t model     ; graphs with positive voltages =1
                    TArrayI exlist  ; list of excluded points = 0
TGraph * Tau(Float_t , Int_t , Int_t , Float_t = 0, Float_t = 50, Int_t = 0, Int_t = 0, TArrayI = 0)
 Calcultaes rendered integrals above FDV with the trapping time
			Float_t tau     ;  trapping time constant
			Int_t start     ;  start index
			Int_t end       ;  end index
			Float_t mint    ; Time window
			Float_t maxt    ;
			Int_t Show      ; show graph
			Int_t model     ; positive voltage scale graph=2
                    TArrayI exlist  ; list of excluded points = 0
TGraph * TauVolt(Float_t , Float_t , Int_t , Int_t , Float_t = 0, Float_t = 50, Int_t = 1, Int_t = 0)
 Calcultaes rendered integrals above FDV with the trapping time. The output is plot Integral vs voltage @ diff. tau.
			Float_t taus    ; Time interval
			Float_t taue    ;
			Int_t start     ;  start index
			Int_t end       ;  end index
			Float_t mint    ; Time window
			Float_t maxt    ;
			Int_t res       ; how many steps per nsh
			Int_t model     ; see VoltTau
TGraph * VoltTau(Float_t , Float_t , Int_t , Int_t , Float_t = 0, Float_t = 50, Int_t = 0, Int_t = 0, Int_t = 1, TArrayI = 0)
 Calcultaes rendered integrals above FDV with the trapping time. It scan throug and finds trapping time at which the integral doesn't depend on voltage
			Float_t taus    ; Time interval
			Float_t taue    ;
			Int_t start     ;  start index
			Int_t end       ;  end index
			Float_t mint    ; Time window
			Float_t maxt    ;
			Int_t Show      ; show graph
			Int_t model     ; if model >= 0 as measured
					  if model < 0 deconvoluted
					  Abs(model) - 0 negative voltage
					               > positive voltage
                    Int_t res;        resolution; number of points per ns - default = 1
                    TArrayI exlist  ; list of excluded points = 0
void EffTau(Int_t , Int_t , Float_t , Float_t , Int_t , Float_t , Float_t = 0.03)
 Same as EffTau, with the array of minimal and maximal fit times given
void EffTauComplex(Int_t , Int_t , Float_t , Float_t , Int_t , Float_t , Float_t = 0.03)
 Same as EffTauComplex, with  the array of minimal and maximal fit times given
void EffTauSave(Int_t , Int_t , Float_t* , Float_t* , Int_t , Float_t* , Int_t , Float_t = 0.03)
 Determination of the tau with exponential fit to the tail of the measured waveform
 		Int_t start  ;  start index
		Int_t end    ;  end index
		Float_t mint ;  Time window
		Float_t maxt ;
		Int_t eh     ; electrons=0 , holes=1
		Float_t D    ; detector thickness in um
		Float_t *dt  ; carrier drift tume
		Int_t startV ; index of the start voltage
void EffTau(Int_t , Int_t , Float_t* , Float_t* , Int_t , Float_t , Float_t = 0.03)
 Determination of the tau with exponential fit to the tail of the measured waveform
 		Int_t start  ;  start index
		Int_t end    ;  end index
		Float_t mint ;  Time window
		Float_t maxt ;
		Int_t eh     ; electrons=0 , holes=1
		Float_t Vdep ; full depletion voltage
		Float_t D    ; detector thickness in um
void EffTauComplex(Int_t , Int_t , Float_t* , Float_t* , Int_t , Float_t , Float_t = 0.03)
 Determination of the tau with exponential fit to the tail of the measured waveform
 		Int_t start  ;  start index
		Int_t end    ;  end index
		Float_t mint ;  Time window
		Float_t maxt ;
		Int_t eh     ; electrons=0 , holes=1
		Float_t Vdep ; full depletion voltage
		Float_t D    ; detector thickness in um
TH1F * ElField(Int_t , Float_t , Float_t , Float_t , Int_t = -1, Int_t = 2, Int_t = 0)
extraction of the electric field from the measurements
 		Int_t hisnum ; number of histogram
		Float_t tau  ; effective trapping time
		Float_t ts   ; low edge of the time window (drift)
		Float_t te   ; high edge of the time window (drift)
		Int_t nab    ; charge of the carrier (=1 hole, =-1 electron)
            Int_t what   ; what kind of output  histogram
		Int_t MobMod ; Mobility Model (see EField Class)
TH1F * Derivation(Float_t , Int_t = 6, Int_t = 1)
 Calcultes the charge (current integral) as a function of time
				Float_t Volt; voltage
TH1F * ChargeShape(Float_t )
 Calcultes the charge (current integral) as a function of time
				Float_t Volt; voltage
void Derivation(Int_t , Int_t , Int_t = 1)
void ChargeShape(Int_t , Int_t , Int_t = 1)
void CorrectBaseLine(Int_t = 0)
 Corrects the base line from [-oo,0]. It is a shift in y -axis!
	Int_t method   ;   =0 all plots are averaged , =1 separate waveforms are used
void Info()
 shows information about measurements
Float_t GetTime(Float_t = 3600)
 Calculates the time of measurement
		Float_t scale ; scale (3600 = 1h)
TGraph * DrawIV(Int_t = 0)
 Draws IV for the given measurement
TGraph * DrawTV(Int_t = 0)
 Draws TV for the given measurement
 Int_t model ; model=0 as measured , model=1  change the sign of both axes
TH1F* EShaping(Elec* , Int_t )
 The waveform is shaped with electronics
		Int_t index; index of the plot
void NormArray(Int_t , Float_t* )
 array normalization
TGraph * CCEE(Elec* , Float_t = -1111, Int_t = 0, Int_t = 1)
 Same as CCE but electronics is used for shaping (peak of the shaped pulse is used)!
			Elec *el          ;  electronics
			Float_t normalize ;  normalization to certain number
	                Int_t model       ;  lin-lin=0  scale  sqrt-lin=1 abs(lin)-lin=2
			Int_t Show        ;  show plots
Double_t Mobility(Float_t , Float_t , Float_t , Double_t , Int_t = 0)
Int_t int2ascii(Char_t* v, Float_t , Int_t = 1)
 int to ascii with signs (same as in MeasureWF)
void SetHistoTime(int num, Float_t* start)
void SetHistoTime(int ind, Float_t start)
TH1F * GetVelHisto(Float_t , Float_t , Int_t = 0)
double GetElField(TH1F* , Float_t , Float_t , Float_t )
double GetVelE(double , double = -1)
double GetEVel(double , double = -1)
double GetVelField(TH1F* , Float_t , Float_t , Float_t )
MeasureWF(Int_t = 60)
  void DBSetTau(Float_t x) {DBSet(10,x);}
  void DBSetSign(Float_t x) {if(x<0) DBSet(3,-10); else DBSet(3,10);}
  MeasureWF(Char_t *,Int_t,Int_t,Int_t,Float_t,Float_t);
void SetAnnealTime(Float_t x)
Voltage Current Section
Float_t GetAnnealTime()
{return AnnealTime;}
void SetVoltages(Float_t* voltages)
Set vectors               

 Adoption
{for(Int_t i=0;i<Multiple;i++) Voltages[i]=voltages[i];}
void SetCurrents(Float_t* currents)
{for(Int_t i=0;i<Multiple;i++) Current[i]=currents[i];}
void SetTemperatures(Float_t* temperatures)
{for(Int_t i=0;i<Multiple;i++) Temperature[i]=temperatures[i];}
void SetFrequencies(Float_t* freq)
{for(Int_t i=0;i<Multiple;i++) Frequencies[i]=freq[i];}
void SetDate(Float_t* date)
{for(Int_t i=0;i<6;i++) Date[i]=date[i];}
void SetVoltage(Int_t index, Float_t voltage)
individual
{Voltages[index]=voltage;}
void SetVoltages(Float_t svol, Float_t step)
{for(Int_t z=0;z<Multiple;z++) Voltages[z]=svol+step*(Float_t)z;}
void SetVoltages(Int_t num, Float_t svol, Float_t step)
{for(Int_t z=num;z<Multiple;z++) Voltages[z]=svol+step*(Float_t)(z-num);}
void SetTemperatures(Float_t T)
{for(Int_t z=0;z<Multiple;z++) Temperature[z]=T;}
Float_t GetVoltage(Int_t index)
{return(Voltages[index]);}
Int_t GetIndex(Float_t Volt)
{for(Int_t i=0;i<Multiple;i++) if(Voltages[i]==Volt) return(i); printf("No such measurement!\n"); return(-1);}
Float_t GetCurrent(Int_t index)
{return(Current[index]);}
Float_t GetCurrent(Float_t Volt)
{for(Int_t i=0;i<Multiple;i++) if(Voltages[i]==Volt) return(Current[i]); printf("No such measurement!\n"); return -1;}
void SetCapacitance(Double_t x)
{CAP=x;}
void PrintVoltages()
Input Output section
Draw Section
{printf("Defined Voltages::\n"); for(Int_t i=0;i<Multiple;i++) printf("(%d,%f)\n",i,Voltages[i]);}
void Draw(Float_t Volt, Option_t* opt, Float_t low = -1111, Float_t high = -1111)
Draw Section
{if(GetIndex(Volt)==-1) return; else Draw(GetIndex(Volt),opt,low,high);}
void GetHistogram(Int_t number, TH1F* his)
{((TH1F *)histo->At(number))->Copy(*his);}
void GetHistogram(Float_t voltage, TH1F* his)
{for(Int_t i=0;i<Multiple;i++) if(Voltages[i]==voltage) ((TH1F *)histo->At(i))->Copy(*his);}
TH1F * GetHA(Double_t voltage)
{Int_t index=0; for(Int_t i=0;i<Multiple;i++) if(Voltages[i]==voltage) index=i; return((TH1F *)histo->At(index));}
TH1F * GetHA(Int_t index)
{return((TH1F *)histo->At(index));}
TH1F * operator()(Double_t voltage)
{return(GetHA(voltage));}
TH1F * operator()(Int_t index)
TH1F *GetHA(Int_t index) {return((TH1F *)histo->At(index));};
{return((TH1F *)histo->At(index));}
void ScaleHisto(Float_t fac = -1)
{ for(int i=0;i<Multiple;i++) ScaleHisto(i,fac); }
void ScaleHisto(Int_t number, Float_t fac)
Integral Section
{((TH1F *)histo->At(number))->Scale(fac);}
TH1F * EShaping(Elec* , Int_t )
Int_t GetEntries()
 General section
{return(Multiple);}
Float_t GetT()
{Float_t sumT=0; for(Int_t i=0;i<Multiple;i++) sumT+=Temperature[i]; return(sumT/Multiple); }
Float_t GetT(Float_t Volt)
{return (Temperature[GetIndex(Volt)]);}
Float_t GetT(Int_t index)
  void realft(float *, unsigned long , int);
  void four1(float *, unsigned long , int);
{return (Temperature[index]);}