[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 "AliDCSArray.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:
  //
  AliLHCDipValT(Int_t size=0, Double_t t=0,Int_t nv=1);
  AliLHCDipValT(AliLHCDipValT<Element> &src);
  virtual ~AliLHCDipValT() {delete[] fArray;}
  AliLHCDipValT& operator=(const AliLHCDipValT<Element> &src);
  AliLHCDipValT& operator+=(const AliLHCDipValT<Element> &src);
  AliLHCDipValT& operator+=(const AliDCSArray &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;}
  void                SetNSamplesUsed(Int_t n)                      {SetUniqueID((UInt_t)n);}
  // 
  Int_t               GetSize()                               const {return fSize;}
  Element             GetValue(Int_t i=0)                     const;
  Element*            GetValues()                             const {return (Element*)fArray;}
  Double_t            GetTimeStamp()                          const {return fTimeStamp;}
  Int_t               GetNSamplesUsed()                       const {return GetUniqueID();}
  Char_t*             GetTimeAsString()                       const {return TimeAsString(fTimeStamp);}
  //
  virtual void Average(const Option_t *opt="");
  virtual void Clear(const Option_t *opt="");
  virtual void Print(const Option_t *opt="")                  const;
  //
  static Char_t*      TimeAsString(double t);
  //
 protected:
  //
  Double_t            fTimeStamp;        // timestamp of the entry
  Int_t               fSize;
  Element*            fArray;            //[fSize] array of entries
  //
  ClassDef(AliLHCDipValT,1)
};


//__________________________________________________________________________
template<class Element>
AliLHCDipValT<Element>::AliLHCDipValT(Int_t size,Double_t t,Int_t nv) 
: fTimeStamp(t),fSize(0),fArray(0)
{
  //def. constructor
  SetNSamplesUsed(nv);
  SetSize(size);
}

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

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

//__________________________________________________________________________
template<class Element>
AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator+=(const AliLHCDipValT<Element> &src)
{
  //addition
  TString tp = typeid(fArray).name();
  if (tp == typeid(Char_t*).name()) {
    if (fSize<1 && src.fSize>0) *this=src; // for strings reassign only if this is empty
  }
  else if (fSize!=src.fSize) {
    AliError(Form("Sizes of arrays to add must be the same (%d vs %d)",fSize,src.fSize));
    return *this;    
  }
  else {
    double wtime0 = fTimeStamp*GetNSamplesUsed();
    double wtime1 = src.fTimeStamp*src.GetNSamplesUsed();
    int wtot = GetNSamplesUsed() + src.GetNSamplesUsed();
    SetNSamplesUsed(wtot);
    if (wtot>0) SetTimeStamp( (wtime0 + wtime1)/wtot );
    for (int i=fSize;i--;) fArray[i] += src.fArray[i];
  }
  return *this;
}

//__________________________________________________________________________
template<class Element>
AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator+=(const AliDCSArray &src)
{
  //addition
  TString tp = typeid(fArray).name();
  int isstr = (tp==typeid(Char_t*).name()) + (src.GetType()==AliDCSArray::kString);
  if ( isstr == 1) {
    AliError("Only one of the sides is of the string type");
    return *this;
  }
  else if (isstr == 2) { // both are string type
    if (fSize<1 && src.GetNEntries()>0) {
      TString str;
      for (int i=0;i<src.GetNEntries();i++) {
	str += ((TObjString*)src.GetStringArray(i))->GetName();
	str += " ";
      }
      SetSize(str.Length()+1);
      memcpy(fArray,str.Data(),fSize*sizeof(char));
    }
  } else {
    if (fSize>src.GetNEntries()) {
      AliError(Form("Size of RHS (%d) is smaller than size of LHS (%d)",src.GetNEntries(),fSize));
      return *this;
    }
    for (int i=fSize;i--;) {
      Element &val = fArray[i];
      if      (src.GetType() == AliDCSArray::kDouble) val += src.GetDouble()[i];
      else if (src.GetType() == AliDCSArray::kFloat)  val += src.GetFloat()[i];
      else if (src.GetType() == AliDCSArray::kInt)    val += src.GetInt()[i];
      else if (src.GetType() == AliDCSArray::kUInt)   val += src.GetUInt()[i];
      else if (src.GetType() == AliDCSArray::kChar)   val += src.GetChar()[i];
      else if (src.GetType() == AliDCSArray::kBool)   val += src.GetBool()[i];
    }
  }
  //
  double wtime0 = fTimeStamp*GetNSamplesUsed();
  double wtime1 = src.GetTimeStamp();
  int wtot = GetNSamplesUsed() + 1;
  SetNSamplesUsed(wtot);
  if (wtot>0) SetTimeStamp( (wtime0 + wtime1)/wtot ); 
  //
  return *this;
}

//__________________________________________________________________________
template<class Element>
Char_t* AliLHCDipValT<Element>::TimeAsString(double t)
{
  time_t tt = (time_t) t;
  char* st = ctime(&tt);
  *(strchr(st,'\n')) = 0;
  return st;
}

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

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

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

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

//__________________________________________________________________________
template<class Element>
Element AliLHCDipValT<Element>::GetValue(Int_t i) const
{
  //obtain value
  if (i>=fSize || i<0) {
    AliError(Form("Index %d is out of range 0:%d",i,fSize-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 = fSize > sz ? sz:fSize; // n elems to copy
    if (nc) memcpy(arr, fArray, nc*sizeof(Element));
    if (nc<sz) memset(arr+nc, 0, (sz-nc)*sizeof(Element));
    if (fSize) delete[] fArray;
    fArray = arr;
    fSize = sz;
  }
  else {
    delete[] fArray;
    fSize = 0;
  }
}

//__________________________________________________________________________
template<class Element>
void AliLHCDipValT<Element>::Print(const Option_t *opt) const
{
  // print time and value
  TString str = opt; 
  str.ToLower();
  printf("Timestamp: ");
  if (str.Contains("raw")) printf("%f",GetTimeStamp());
  else printf("%s",GetTimeAsString());
  printf(" | samples %6d | Value: ",GetNSamplesUsed());
  //
  TString tp = typeid(fArray).name();
  if ( tp==typeid(Char_t*).name() ) printf(" => %s\n",(Char_t*)fArray);
  else {
    if (fSize>1) printf("\n");
    for (int i=0;i<fSize;i++) {
      if      (tp == typeid(Int_t*).name()    || tp == typeid(UInt_t*).name() ) printf("#%4d %+11d |",i,(Int_t)fArray[i]);
      else if (tp == typeid(Double_t*).name() || tp == typeid(Float_t*).name()) printf("#%4d %+e |",  i,(Double_t)fArray[i]);
      else printf(" ");
      if ( (i+1)%5 == 0) printf("\n");
    }
    if (fSize%5) printf("\n");
  }
  //
}

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

//__________________________________________________________________________
template<class Element>
void AliLHCDipValT<Element>::Average(const Option_t *)
{
  // average of samples
  int n = GetNSamplesUsed();
  if (n>0) for (int i=fSize;i--;) fArray[i] /= n;
  //
}


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>
	8	#include "AliDCSArray.h"
	9	#include "AliLog.h"
9b0229cf	10
	11
	12	/////////////////////////////////////////////////////////////////////////////////
	13	// //
	14	// AliLHCDipValT: templated class to store the array from processed //
	15	// LHC DIP data. Associated with the time stamp either of the value //
	16	// acquisition or the last sample timestamp if many samples were processed //
	17	// //
	18	// Author: ruben.shahoyan@cern.ch //
	19	// //
	20	/////////////////////////////////////////////////////////////////////////////////
	21
	22	//_______________________________________________________________________________________
	23	template<class Element> class AliLHCDipValT : public TObject
	24	{
	25	public:
	26	//
	27	AliLHCDipValT(Int_t size=0, Double_t t=0,Int_t nv=1);
	28	AliLHCDipValT(AliLHCDipValT<Element> &src);
	29	virtual ~AliLHCDipValT() {delete[] fArray;}
	30	AliLHCDipValT& operator=(const AliLHCDipValT<Element> &src);
	31	AliLHCDipValT& operator+=(const AliLHCDipValT<Element> &src);
	32	AliLHCDipValT& operator+=(const AliDCSArray &src);
	33	Element& operator[](Int_t i);
	34	Element operator[](Int_t i) const;
	35	//
	36	void SetSize(Int_t size);
	37	void SetValue(Int_t i,Element v);
	38	void SetValues(const Element *v, Int_t n);
	39	void SetTimeStamp(Double_t v) {fTimeStamp = v;}
	40	void SetNSamplesUsed(Int_t n) {SetUniqueID((UInt_t)n);}
	41	//
	42	Int_t GetSize() const {return fSize;}
	43	Element GetValue(Int_t i=0) const;
	44	Element* GetValues() const {return (Element*)fArray;}
	45	Double_t GetTimeStamp() const {return fTimeStamp;}
	46	Int_t GetNSamplesUsed() const {return GetUniqueID();}
	47	Char_t* GetTimeAsString() const {return TimeAsString(fTimeStamp);}
	48	//
	49	virtual void Average(const Option_t *opt="");
	50	virtual void Clear(const Option_t *opt="");
	51	virtual void Print(const Option_t *opt="") const;
	52	//
	53	static Char_t* TimeAsString(double t);
	54	//
	55	protected:
	56	//
	57	Double_t fTimeStamp; // timestamp of the entry
	58	Int_t fSize;
	59	Element* fArray; //[fSize] array of entries
	60	//
	61	ClassDef(AliLHCDipValT,1)
	62	};
	63
	64
	65	//__________________________________________________________________________
	66	template<class Element>
	67	AliLHCDipValT<Element>::AliLHCDipValT(Int_t size,Double_t t,Int_t nv)
	68	: fTimeStamp(t),fSize(0),fArray(0)
	69	{
	70	//def. constructor
	71	SetNSamplesUsed(nv);
	72	SetSize(size);
	73	}
74
75	//__________________________________________________________________________
76	template<class Element>
77	AliLHCDipValT<Element>::AliLHCDipValT(AliLHCDipValT<Element> &src)
78	: TObject(src),fTimeStamp(src.fTimeStamp),fSize(0),fArray(0)
79	{
80	//copy constructor
81	SetSize(src.fSize);
82	memcpy(fArray,src.fArray,fSize*sizeof(Element));
83	}
84
85	//__________________________________________________________________________
86	template<class Element>
87	AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator=(const AliLHCDipValT<Element> &src)
88	{
89	//assingment
90	if (this != &src) {
91	((TObject*)this)->operator=(src);
92	SetTimeStamp(src.GetTimeStamp());
93	if (fSize!=src.fSize) SetSize(src.fSize);
94	memcpy(fArray,src.fArray,fSize*sizeof(Element));
95	}
96	return *this;
97	}
98
99	//__________________________________________________________________________
100	template<class Element>
101	AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator+=(const AliLHCDipValT<Element> &src)
102	{
103	//addition
104	TString tp = typeid(fArray).name();
105	if (tp == typeid(Char_t*).name()) {
106	if (fSize<1 && src.fSize>0) *this=src; // for strings reassign only if this is empty
107	}
108	else if (fSize!=src.fSize) {
109	AliError(Form("Sizes of arrays to add must be the same (%d vs %d)",fSize,src.fSize));
110	return *this;
111	}
112	else {
113	double wtime0 = fTimeStamp*GetNSamplesUsed();
114	double wtime1 = src.fTimeStamp*src.GetNSamplesUsed();
115	int wtot = GetNSamplesUsed() + src.GetNSamplesUsed();
116	SetNSamplesUsed(wtot);
117	if (wtot>0) SetTimeStamp( (wtime0 + wtime1)/wtot );
118	for (int i=fSize;i--;) fArray[i] += src.fArray[i];
119	}
120	return *this;
121	}
122
123	//__________________________________________________________________________
124	template<class Element>
125	AliLHCDipValT<Element>& AliLHCDipValT<Element>::operator+=(const AliDCSArray &src)
126	{
127	//addition
128	TString tp = typeid(fArray).name();
129	int isstr = (tp==typeid(Char_t*).name()) + (src.GetType()==AliDCSArray::kString);
130	if ( isstr == 1) {
131	AliError("Only one of the sides is of the string type");
132	return *this;
133	}
134	else if (isstr == 2) { // both are string type
135	if (fSize<1 && src.GetNEntries()>0) {
136	TString str;
137	for (int i=0;i<src.GetNEntries();i++) {
138	str += ((TObjString*)src.GetStringArray(i))->GetName();
139	str += " ";
140	}
141	SetSize(str.Length()+1);
142	memcpy(fArray,str.Data(),fSize*sizeof(char));
143	}
144	} else {
145	if (fSize>src.GetNEntries()) {
146	AliError(Form("Size of RHS (%d) is smaller than size of LHS (%d)",src.GetNEntries(),fSize));
147	return *this;
148	}
149	for (int i=fSize;i--;) {
150	Element &val = fArray[i];
151	if (src.GetType() == AliDCSArray::kDouble) val += src.GetDouble()[i];
152	else if (src.GetType() == AliDCSArray::kFloat) val += src.GetFloat()[i];
153	else if (src.GetType() == AliDCSArray::kInt) val += src.GetInt()[i];
154	else if (src.GetType() == AliDCSArray::kUInt) val += src.GetUInt()[i];
155	else if (src.GetType() == AliDCSArray::kChar) val += src.GetChar()[i];
156	else if (src.GetType() == AliDCSArray::kBool) val += src.GetBool()[i];
157	}
158	}
159	//
160	double wtime0 = fTimeStamp*GetNSamplesUsed();
161	double wtime1 = src.GetTimeStamp();
162	int wtot = GetNSamplesUsed() + 1;
163	SetNSamplesUsed(wtot);
164	if (wtot>0) SetTimeStamp( (wtime0 + wtime1)/wtot );
165	//
166	return *this;
167	}
168
169	//__________________________________________________________________________
170	template<class Element>
171	Char_t* AliLHCDipValT<Element>::TimeAsString(double t)
172	{
173	time_t tt = (time_t) t;
174	char* st = ctime(&tt);
175	*(strchr(st,'\n')) = 0;
176	return st;
177	}
178
179	//__________________________________________________________________________
180	template<class Element>
181	void AliLHCDipValT<Element>::SetValue(Int_t i,Element v)
182	{
183	//assign value
184	if (i>=fSize \|\| i<0) {
185	AliError(Form("Index %d is out of range 0:%d",i,fSize-1));
186	return;
187	}
188	fArray[i] = v;
189	}
190
191	//__________________________________________________________________________
192	template<class Element>
193	void AliLHCDipValT<Element>::SetValues(const Element* v, Int_t n)
194	{
195	//assign value
196	if (n!=fSize) SetSize(n);
197	memcpy(fArray,v,n*sizeof(Element));
198	}
199
200	//__________________________________________________________________________
201	template<class Element>
202	Element& AliLHCDipValT<Element>::operator[](Int_t i)
203	{
204	//obtain value refeterence
205	if (i>=fSize \|\| i<0) {
206	AliError(Form("Index %d is out of range 0:%d",i,fSize-1));
207	return fArray[0];
208	}
209	return fArray[i];
210	}
211
212	//__________________________________________________________________________
213	template<class Element>
214	Element AliLHCDipValT<Element>::operator[](Int_t i) const
215	{
216	//obtain value
217	if (i>=fSize \|\| i<0) {
218	AliError(Form("Index %d is out of range 0:%d",i,fSize-1));
219	return 0;
220	}
221	return fArray[i];
222	}
223
224	//__________________________________________________________________________
225	template<class Element>
226	Element AliLHCDipValT<Element>::GetValue(Int_t i) const
227	{
228	//obtain value
229	if (i>=fSize \|\| i<0) {
230	AliError(Form("Index %d is out of range 0:%d",i,fSize-1));
231	return 0;
232	}
233	return fArray[i];
234	}
235
236	//__________________________________________________________________________
237	template<class Element>
238	void AliLHCDipValT<Element>::SetSize(Int_t sz)
239	{
240	//resize
241	Element* arr = 0;
242	if (sz>0) {
243	arr = new Element[sz];
244	int nc = fSize > sz ? sz:fSize; // n elems to copy
245	if (nc) memcpy(arr, fArray, nc*sizeof(Element));
246	if (nc<sz) memset(arr+nc, 0, (sz-nc)*sizeof(Element));
247	if (fSize) delete[] fArray;
248	fArray = arr;
249	fSize = sz;
250	}
251	else {
252	delete[] fArray;
253	fSize = 0;
254	}
255	}
256
257	//__________________________________________________________________________
258	template<class Element>
259	void AliLHCDipValT<Element>::Print(const Option_t *opt) const
260	{
261	// print time and value
262	TString str = opt;
263	str.ToLower();
264	printf("Timestamp: ");
265	if (str.Contains("raw")) printf("%f",GetTimeStamp());
266	else printf("%s",GetTimeAsString());
267	printf(" \| samples %6d \| Value: ",GetNSamplesUsed());
268	//
269	TString tp = typeid(fArray).name();
270	if ( tp==typeid(Char_t).name() ) printf(" => %s\n",(Char_t)fArray);
271	else {
272	if (fSize>1) printf("\n");
273	for (int i=0;i<fSize;i++) {
274	if (tp == typeid(Int_t).name() \|\| tp == typeid(UInt_t).name() ) printf("#%4d %+11d \|",i,(Int_t)fArray[i]);
275	else if (tp == typeid(Double_t).name() \|\| tp == typeid(Float_t).name()) printf("#%4d %+e \|", i,(Double_t)fArray[i]);
276	else printf(" ");
277	if ( (i+1)%5 == 0) printf("\n");
278	}
279	if (fSize%5) printf("\n");
280	}
281	//
282	}
283
284	//__________________________________________________________________________
285	template<class Element>
286	void AliLHCDipValT<Element>::Clear(const Option_t *)
287	{
288	// reset to 0 everything
289	SetNSamplesUsed(0);
290	SetTimeStamp(0);
291	memset(fArray,0,fSize*sizeof(Element));
292	}
293
294	//__________________________________________________________________________
295	template<class Element>
296	void AliLHCDipValT<Element>::Average(const Option_t *)
297	{
298	// average of samples
299	int n = GetNSamplesUsed();
300	if (n>0) for (int i=fSize;i--;) fArray[i] /= n;
301	//
302	}
303
304
305	typedef AliLHCDipValT<Double_t> AliLHCDipValD;
306	typedef AliLHCDipValT<Float_t> AliLHCDipValF;
307	typedef AliLHCDipValT<Int_t> AliLHCDipValI;
308	typedef AliLHCDipValT<Char_t> AliLHCDipValC;
309
310
311
312	#endif