[u/mrichter/AliRoot.git] / STEER / AliLHCDipValT.h

#ifndef ALILHCDIPVALT_H
#define ALILHCDIPVALT_H

#include <typeinfo>
#include <TString.h>
#include <TObjString.h>
#include <TObject.h>
#include "AliLog.h"


/////////////////////////////////////////////////////////////////////////////////
//                                                                             //
//  AliLHCDipValT: templated class to store the array from processed           //
//  LHC DIP data. Associated with the time stamp either of the value           //
//  acquisition or the last sample timestamp if many samples were processed    //
//                                                                             //
//  Author: ruben.shahoyan@cern.ch                                             //
//                                                                             //
/////////////////////////////////////////////////////////////////////////////////

//_______________________________________________________________________________________
template<class Element> class AliLHCDipValT : public TObject
{
 public:
  //
  enum {
    kLastSpecial=BIT(14),         // last element of array is special (e.g. assigned error etc) 
    kProcessed1 =BIT(15),         // last element of array is special (e.g. assigned error etc) 
    kChar=BIT(22),
    kFloat=BIT(23)
  };
  //
  AliLHCDipValT(Int_t size=0, Double_t t=0);
  AliLHCDipValT(const AliLHCDipValT<Element> &src);
  virtual ~AliLHCDipValT() {delete[] fArray;}
  AliLHCDipValT& operator=(const AliLHCDipValT<Element> &src);
  Element&       operator[](Int_t i);
  Element        operator[](Int_t i)                          const;
  //
  void                SetSize(Int_t size);
  void                SetValue(Int_t i,Element v);
  void                SetValues(const Element *v, Int_t n);
  void                SetTimeStamp(Double_t v)                      {fTimeStamp = v;}
  // 
  Int_t               GetSizeTotal()                          const {return fSizeTot;}
  Element             GetValue(Int_t i=0)                     const;
  Element*            GetValues()                             const {return (Element*)fArray;}
  Double_t            GetTimeStamp()                          const {return fTimeStamp;}
  Char_t*             GetTimeAsString(Bool_t utc=kTRUE)       const {return TimeAsString(fTimeStamp,utc);}
  //
  void                SetProcessed1(Bool_t v=kTRUE)                 {SetBit(kProcessed1,v);}
  void                SetLastSpecial(Bool_t v=kTRUE)                {SetBit(kLastSpecial,v);}
  Bool_t              IsProcessed1()                          const {return TestBit(kProcessed1);}
  Bool_t              IsLastSpecial()                         const {return TestBit(kLastSpecial);}
  Int_t               GetSize()                               const {return IsLastSpecial() ? GetSizeTotal()-1:GetSizeTotal();}
  Bool_t              IsTypeC()                               const {return TestBit(kChar);}
  Bool_t              IsTypeF()                               const {return TestBit(kFloat);}
  Bool_t              IsTypeI()                               const {return !TestBit(kFloat|kChar);}
  //
  virtual void Clear(const Option_t *opt="");
  virtual void Print(const Option_t *opt="")                  const;
  //
  static Char_t*      TimeAsString(double t,Bool_t utc=kTRUE);
  //
 protected:
  //
  Double_t            fTimeStamp;        // timestamp of the entry
  Int_t               fSizeTot;          // vector total size (including special slots, like for errors)
  Element*            fArray;            //[fSizeTot] array of entries
  //
  ClassDef(AliLHCDipValT,1)
};


//__________________________________________________________________________
template<class Element>
AliLHCDipValT<Element>::AliLHCDipValT(Int_t size,Double_t t) 
: fTimeStamp(t),fSizeTot(0),fArray(0)
{
  //def. constructor
  SetSize(size);
  if      (!strcmp(typeid(fArray).name(),typeid(Char_t*).name())) SetBit(kChar);
  else if (!strcmp(typeid(fArray).name(),typeid(Double_t*).name()) ||
	   !strcmp(typeid(fArray).name(),typeid(Float_t*).name() )) SetBit(kFloat);
  //
}

//__________________________________________________________________________
template<class Element>
AliLHCDipValT<Element>::AliLHCDipValT(const AliLHCDipValT<Element> &src)
: TObject(src),fTimeStamp(src.fTimeStamp),fSizeTot(0),fArray(0)
{
  //copy constructor
  SetSize(src.GetSizeTotal());
  memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element));
}

//__________________________________________________________________________
template<class Element>
AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator=(const AliLHCDipValT<Element> &src)
{
  //assingment
  if (this != &src) {
    ((TObject*)this)->operator=(src);
    if (GetSizeTotal()!=src.GetSizeTotal()) SetSize(src.GetSizeTotal());
    SetTimeStamp(src.GetTimeStamp());
    memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element));    
  }
  return *this;
}

//__________________________________________________________________________
template<class Element>
Char_t* AliLHCDipValT<Element>::TimeAsString(double t, Bool_t utc)
{
  // time as string in UTC or local format
  static char buff[22];
  time_t tt = (time_t) t;
  struct tm *time = utc ? gmtime(&tt) : localtime(&tt);
  snprintf(buff,21,"%02d:%02d:%02d %02d/%02d/%04d",time->tm_hour,time->tm_min,time->tm_sec,
	  time->tm_mday,time->tm_mon+1,time->tm_year+1900);
  return (char*)buff;
}

//__________________________________________________________________________
template<class Element>
void AliLHCDipValT<Element>::SetValue(Int_t i,Element v)
{
  //assign value
  if (i>=GetSizeTotal() || i<0) {
    AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
    return;
  }
  fArray[i] = v;
}

//__________________________________________________________________________
template<class Element>
void AliLHCDipValT<Element>::SetValues(const Element* v, Int_t n)
{
  //assign value
  if (n!=GetSizeTotal()) SetSize(n);
  memcpy(fArray,v,n*sizeof(Element));
}

//__________________________________________________________________________
template<class Element>
Element& AliLHCDipValT<Element>::operator[](Int_t i)
{
  //obtain value refeterence
  if (i>=GetSizeTotal() || i<0) {
    AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
    return fArray[0];
  }
  return fArray[i];
}

//__________________________________________________________________________
template<class Element>
Element AliLHCDipValT<Element>::operator[](Int_t i) const
{
  //obtain value
  if (i>=GetSizeTotal() || i<0) {
    AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
    return 0;
  }
  return fArray[i];
}

//__________________________________________________________________________
template<class Element>
Element AliLHCDipValT<Element>::GetValue(Int_t i) const
{
  //obtain value
  if (i>=GetSizeTotal() || i<0) {
    AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
    return 0;
  }
  return fArray[i];
}

//__________________________________________________________________________
template<class Element>
void AliLHCDipValT<Element>::SetSize(Int_t sz)
{
  //resize
  Element* arr = 0;
  if (sz>0) {
    arr = new Element[sz];
    int nc = GetSizeTotal() > sz ? sz:GetSizeTotal(); // n elems to copy
    if (nc && fArray) memcpy(arr, fArray, nc*sizeof(Element));
    if (nc<sz) memset(arr+nc, 0, (sz-nc)*sizeof(Element));
    if (fArray) delete[] fArray;
    fArray = arr;
    fSizeTot = sz;
  }
  else {
    delete[] fArray;
    fArray = 0;
    fSizeTot = 0;
  }
}

//__________________________________________________________________________
template<class Element>
void AliLHCDipValT<Element>::Print(const Option_t *opt) const
{
  // print time and value
  TString str = opt; 
  str.ToLower();
  if (str.Contains("raw")) printf("%.1f ",GetTimeStamp());
  else printf("[%s] ",GetTimeAsString(!str.Contains("loc")));
  //
  TString tp = typeid(fArray).name();
  if ( tp==typeid(Char_t*).name() ) printf(": %s\n",(Char_t*)fArray);
  else {
    int sz = GetSize();
    if (sz>1) printf("\n");
    Bool_t eolOK = kFALSE;
    for (int i=0;i<sz;i++) {
      if      (tp == typeid(Int_t*).name()    || tp == typeid(UInt_t*).name() ) {
	if (!str.Contains("bit")) printf(" %6d |" ,(Int_t)fArray[i]);
	else {
	  printf(" ");
	  int val = (int)fArray[i];
	  for (int j=sizeof(int)*8;j--;) printf("%d",(val>>j)&0x1);
	  printf(" |");
	}

      }
      else if (tp == typeid(Double_t*).name() || tp == typeid(Float_t*).name()) printf(" %+.3e |",(Float_t)fArray[i]);
      else printf(" ");
      eolOK = kFALSE;
      if ( (i+1)%5 == 0) {printf("\n"); eolOK = kTRUE;}
    }
    if (IsLastSpecial()) {
      if (sz>1 && !eolOK) {printf("\n"); eolOK = kTRUE;}
      if (tp == typeid(Double_t*).name() || tp == typeid(Float_t*).name()) {
	printf(" Error: %+e\n",(Float_t)fArray[sz]);
	eolOK = kTRUE;
      }
    }
    if (!eolOK) printf("\n");
  }
  //
}

//__________________________________________________________________________
template<class Element>
void AliLHCDipValT<Element>::Clear(const Option_t *)
{
  // reset to 0 everything
  SetTimeStamp(0);
  memset(fArray,0,GetSizeTotal()*sizeof(Element));
}


typedef AliLHCDipValT<Double_t> AliLHCDipValD;
typedef AliLHCDipValT<Float_t>  AliLHCDipValF;
typedef AliLHCDipValT<Int_t>    AliLHCDipValI;
typedef AliLHCDipValT<Char_t>   AliLHCDipValC;


#endif
Commit	Line	Data
9b0229cf	1	#ifndef ALILHCDIPVALT_H
	2	#define ALILHCDIPVALT_H
	3
	4	#include <typeinfo>
	5	#include <TString.h>
	6	#include <TObjString.h>
	7	#include <TObject.h>
9b0229cf	8	#include "AliLog.h"
9b0229cf	9
	10
	11	/////////////////////////////////////////////////////////////////////////////////
	12	// //
	13	// AliLHCDipValT: templated class to store the array from processed //
	14	// LHC DIP data. Associated with the time stamp either of the value //
	15	// acquisition or the last sample timestamp if many samples were processed //
	16	// //
	17	// Author: ruben.shahoyan@cern.ch //
	18	// //
	19	/////////////////////////////////////////////////////////////////////////////////
	20
	21	//_______________________________________________________________________________________
	22	template<class Element> class AliLHCDipValT : public TObject
	23	{
	24	public:
	25	//
799c6677	26	enum {
	27	kLastSpecial=BIT(14), // last element of array is special (e.g. assigned error etc)
	28	kProcessed1 =BIT(15), // last element of array is special (e.g. assigned error etc)
	29	kChar=BIT(22),
	30	kFloat=BIT(23)
	31	};
	32	//
	33	AliLHCDipValT(Int_t size=0, Double_t t=0);
	34	AliLHCDipValT(const AliLHCDipValT<Element> &src);
9b0229cf	35	virtual ~AliLHCDipValT() {delete[] fArray;}
9b0229cf	36	AliLHCDipValT& operator=(const AliLHCDipValT<Element> &src);
9b0229cf	37	Element& operator[](Int_t i);
	38	Element operator[](Int_t i) const;
	39	//
	40	void SetSize(Int_t size);
	41	void SetValue(Int_t i,Element v);
	42	void SetValues(const Element *v, Int_t n);
	43	void SetTimeStamp(Double_t v) {fTimeStamp = v;}
9b0229cf	44	//
94179526	45	Int_t GetSizeTotal() const {return fSizeTot;}
9b0229cf	46	Element GetValue(Int_t i=0) const;
	47	Element* GetValues() const {return (Element*)fArray;}
	48	Double_t GetTimeStamp() const {return fTimeStamp;}
63bd40f4	49	Char_t* GetTimeAsString(Bool_t utc=kTRUE) const {return TimeAsString(fTimeStamp,utc);}
9b0229cf	50	//
799c6677	51	void SetProcessed1(Bool_t v=kTRUE) {SetBit(kProcessed1,v);}
	52	void SetLastSpecial(Bool_t v=kTRUE) {SetBit(kLastSpecial,v);}
	53	Bool_t IsProcessed1() const {return TestBit(kProcessed1);}
	54	Bool_t IsLastSpecial() const {return TestBit(kLastSpecial);}
	55	Int_t GetSize() const {return IsLastSpecial() ? GetSizeTotal()-1:GetSizeTotal();}
	56	Bool_t IsTypeC() const {return TestBit(kChar);}
	57	Bool_t IsTypeF() const {return TestBit(kFloat);}
	58	Bool_t IsTypeI() const {return !TestBit(kFloat\|kChar);}
	59	//
9b0229cf	60	virtual void Clear(const Option_t *opt="");
	61	virtual void Print(const Option_t *opt="") const;
	62	//
63bd40f4	63	static Char_t* TimeAsString(double t,Bool_t utc=kTRUE);
9b0229cf	64	//
	65	protected:
	66	//
	67	Double_t fTimeStamp; // timestamp of the entry
94179526	68	Int_t fSizeTot; // vector total size (including special slots, like for errors)
94179526	69	Element* fArray; //[fSizeTot] array of entries
9b0229cf	70	//
	71	ClassDef(AliLHCDipValT,1)
	72	};
	73
	74
	75	//__________________________________________________________________________
	76	template<class Element>
799c6677	77	AliLHCDipValT<Element>::AliLHCDipValT(Int_t size,Double_t t)
94179526	78	: fTimeStamp(t),fSizeTot(0),fArray(0)
9b0229cf	79	{
9b0229cf	80	//def. constructor
9b0229cf	81	SetSize(size);
799c6677	82	if (!strcmp(typeid(fArray).name(),typeid(Char_t*).name())) SetBit(kChar);
	83	else if (!strcmp(typeid(fArray).name(),typeid(Double_t*).name()) \|\|
	84	!strcmp(typeid(fArray).name(),typeid(Float_t*).name() )) SetBit(kFloat);
	85	//
9b0229cf	86	}
	87
	88	//__________________________________________________________________________
	89	template<class Element>
799c6677	90	AliLHCDipValT<Element>::AliLHCDipValT(const AliLHCDipValT<Element> &src)
94179526	91	: TObject(src),fTimeStamp(src.fTimeStamp),fSizeTot(0),fArray(0)
9b0229cf	92	{
9b0229cf	93	//copy constructor
799c6677	94	SetSize(src.GetSizeTotal());
799c6677	95	memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element));
9b0229cf	96	}
	97
	98	//__________________________________________________________________________
	99	template<class Element>
	100	AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator=(const AliLHCDipValT<Element> &src)
	101	{
	102	//assingment
	103	if (this != &src) {
	104	((TObject*)this)->operator=(src);
799c6677	105	if (GetSizeTotal()!=src.GetSizeTotal()) SetSize(src.GetSizeTotal());
9b0229cf	106	SetTimeStamp(src.GetTimeStamp());
799c6677	107	memcpy(fArray,src.fArray,GetSizeTotal()*sizeof(Element));
9b0229cf	108	}
	109	return *this;
	110	}
	111
9b0229cf	112	//__________________________________________________________________________
9b0229cf	113	template<class Element>
63bd40f4	114	Char_t* AliLHCDipValT<Element>::TimeAsString(double t, Bool_t utc)
9b0229cf	115	{
63bd40f4	116	// time as string in UTC or local format
41ff94a3	117	static char buff[22];
9b0229cf	118	time_t tt = (time_t) t;
41ff94a3	119	struct tm *time = utc ? gmtime(&tt) : localtime(&tt);
d97d27ff	120	snprintf(buff,21,"%02d:%02d:%02d %02d/%02d/%04d",time->tm_hour,time->tm_min,time->tm_sec,
41ff94a3	121	time->tm_mday,time->tm_mon+1,time->tm_year+1900);
41ff94a3	122	return (char*)buff;
9b0229cf	123	}
	124
	125	//__________________________________________________________________________
	126	template<class Element>
	127	void AliLHCDipValT<Element>::SetValue(Int_t i,Element v)
	128	{
	129	//assign value
799c6677	130	if (i>=GetSizeTotal() \|\| i<0) {
799c6677	131	AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
9b0229cf	132	return;
	133	}
	134	fArray[i] = v;
	135	}
	136
	137	//__________________________________________________________________________
	138	template<class Element>
	139	void AliLHCDipValT<Element>::SetValues(const Element* v, Int_t n)
	140	{
	141	//assign value
799c6677	142	if (n!=GetSizeTotal()) SetSize(n);
9b0229cf	143	memcpy(fArray,v,n*sizeof(Element));
	144	}
	145
	146	//__________________________________________________________________________
	147	template<class Element>
	148	Element& AliLHCDipValT<Element>::operator[](Int_t i)
	149	{
	150	//obtain value refeterence
799c6677	151	if (i>=GetSizeTotal() \|\| i<0) {
799c6677	152	AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
9b0229cf	153	return fArray[0];
	154	}
	155	return fArray[i];
	156	}
	157
	158	//__________________________________________________________________________
	159	template<class Element>
	160	Element AliLHCDipValT<Element>::operator[](Int_t i) const
	161	{
	162	//obtain value
799c6677	163	if (i>=GetSizeTotal() \|\| i<0) {
799c6677	164	AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
9b0229cf	165	return 0;
	166	}
	167	return fArray[i];
	168	}
	169
	170	//__________________________________________________________________________
	171	template<class Element>
	172	Element AliLHCDipValT<Element>::GetValue(Int_t i) const
	173	{
	174	//obtain value
799c6677	175	if (i>=GetSizeTotal() \|\| i<0) {
799c6677	176	AliError(Form("Index %d is out of range 0:%d",i,GetSizeTotal()-1));
9b0229cf	177	return 0;
	178	}
	179	return fArray[i];
	180	}
	181
	182	//__________________________________________________________________________
	183	template<class Element>
	184	void AliLHCDipValT<Element>::SetSize(Int_t sz)
	185	{
	186	//resize
	187	Element* arr = 0;
	188	if (sz>0) {
	189	arr = new Element[sz];
799c6677	190	int nc = GetSizeTotal() > sz ? sz:GetSizeTotal(); // n elems to copy
f8b1c575	191	if (nc && fArray) memcpy(arr, fArray, nc*sizeof(Element));
9b0229cf	192	if (nc<sz) memset(arr+nc, 0, (sz-nc)*sizeof(Element));
f8b1c575	193	if (fArray) delete[] fArray;
9b0229cf	194	fArray = arr;
94179526	195	fSizeTot = sz;
9b0229cf	196	}
	197	else {
	198	delete[] fArray;
94179526	199	fArray = 0;
94179526	200	fSizeTot = 0;
9b0229cf	201	}
	202	}
	203
	204	//__________________________________________________________________________
	205	template<class Element>
	206	void AliLHCDipValT<Element>::Print(const Option_t *opt) const
	207	{
	208	// print time and value
	209	TString str = opt;
	210	str.ToLower();
799c6677	211	if (str.Contains("raw")) printf("%.1f ",GetTimeStamp());
63bd40f4	212	else printf("[%s] ",GetTimeAsString(!str.Contains("loc")));
9b0229cf	213	//
9b0229cf	214	TString tp = typeid(fArray).name();
799c6677	215	if ( tp==typeid(Char_t).name() ) printf(": %s\n",(Char_t)fArray);
9b0229cf	216	else {
799c6677	217	int sz = GetSize();
	218	if (sz>1) printf("\n");
	219	Bool_t eolOK = kFALSE;
	220	for (int i=0;i<sz;i++) {
63bd40f4	221	if (tp == typeid(Int_t).name() \|\| tp == typeid(UInt_t).name() ) {
	222	if (!str.Contains("bit")) printf(" %6d \|" ,(Int_t)fArray[i]);
	223	else {
	224	printf(" ");
	225	int val = (int)fArray[i];
	226	for (int j=sizeof(int)*8;j--;) printf("%d",(val>>j)&0x1);
	227	printf(" \|");
	228	}
	229
	230	}
799c6677	231	else if (tp == typeid(Double_t).name() \|\| tp == typeid(Float_t).name()) printf(" %+.3e \|",(Float_t)fArray[i]);
9b0229cf	232	else printf(" ");
799c6677	233	eolOK = kFALSE;
	234	if ( (i+1)%5 == 0) {printf("\n"); eolOK = kTRUE;}
	235	}
	236	if (IsLastSpecial()) {
	237	if (sz>1 && !eolOK) {printf("\n"); eolOK = kTRUE;}
	238	if (tp == typeid(Double_t).name() \|\| tp == typeid(Float_t).name()) {
	239	printf(" Error: %+e\n",(Float_t)fArray[sz]);
	240	eolOK = kTRUE;
	241	}
9b0229cf	242	}
799c6677	243	if (!eolOK) printf("\n");
9b0229cf	244	}
	245	//
	246	}
	247
	248	//__________________________________________________________________________
	249	template<class Element>
	250	void AliLHCDipValT<Element>::Clear(const Option_t *)
	251	{
	252	// reset to 0 everything
9b0229cf	253	SetTimeStamp(0);
799c6677	254	memset(fArray,0,GetSizeTotal()*sizeof(Element));
9b0229cf	255	}
	256
	257
	258	typedef AliLHCDipValT<Double_t> AliLHCDipValD;
	259	typedef AliLHCDipValT<Float_t> AliLHCDipValF;
	260	typedef AliLHCDipValT<Int_t> AliLHCDipValI;
	261	typedef AliLHCDipValT<Char_t> AliLHCDipValC;
	262
	263
	264
	265	#endif