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

#ifndef ALIMILLEPEDERECORD_H
#define ALIMILLEPEDERECORD_H

/**********************************************************************************************/
/* AliMillePedeRecords: class to store the data of single track processing                    */
/* Format: for each measured point the data is stored consequtively                           */
/* INDEX                                                      VALUE                           */
/* -1                                                         residual                        */
/* Local_param_id                                             dResidual/dLocal_param          */
/* ...                                                        ...                             */
/* -2                                                         weight of the measurement       */
/* Global_param_od                                            dResidual/dGlobal_param         */
/* ...                                                        ...                             */
/*                                                                                            */
/* The records for all processed tracks are stored in the temporary tree in orgder to be      */
/* reused for multiple iterations of MillePede                                                */
/*                                                                                            */
/* Author: ruben.shahoyan@cern.ch                                                             */
/*                                                                                            */
/**********************************************************************************************/
#include <TObject.h>

class AliMillePedeRecord : public TObject
{
 public:
  AliMillePedeRecord();
  AliMillePedeRecord(const AliMillePedeRecord& src);
  AliMillePedeRecord& operator=(const AliMillePedeRecord& rhs);
  //
  virtual    ~AliMillePedeRecord();
  void       Reset();
  void       Print(const Option_t *opt="")                   const;
  //
  Int_t      GetSize()                                       const {return fSize;}
  Int_t     *GetIndex()                                      const {return fIndex;}
  Int_t      GetIndex(int i)                                 const {return fIndex[i];}
  //
  void       GetIndexValue(Int_t i,Int_t &ind,Double_t &val) const {ind=fIndex[i]; val=fValue[i];}
  void       AddIndexValue(Int_t ind, Double_t val);
  void       AddResidual(Double_t val)                             {AddIndexValue(-1,val);}
  void       AddWeight(Double_t val)                               {AddIndexValue(-2,val);}
  Bool_t     IsResidual(Int_t i)                             const {return fIndex[i]==-1;}
  Bool_t     IsWeight(Int_t i)                               const {return fIndex[i]==-2;}
  //
  Double_t  *GetValue()                                      const {return fValue;}
  Double_t   GetValue(Int_t i)                               const {return fValue[i];}
  //
  void       MarkGroup(Int_t id);
  Int_t      GetNGroups()                                    const {return fNGroups;}
  Int_t      GetGroupID(Int_t i)                             const {return fGroupID[i];}
  Bool_t     IsGroupPresent(Int_t id)                        const;
  //
 protected:
  Int_t      GetDtBufferSize()                               const {return GetUniqueID()&0x0000ffff;}
  Int_t      GetGrBufferSize()                               const {return GetUniqueID()>>16;}
  void       SetDtBufferSize(Int_t sz)                             {SetUniqueID((GetGrBufferSize()<<16)+sz);}
  void       SetGrBufferSize(Int_t sz)                             {SetUniqueID(GetDtBufferSize()+(sz<<16));}
  void       ExpandDtBuffer(Int_t bfsize);
  void       ExpandGrBuffer(Int_t bfsize);
  //
 protected:
  Int_t      fSize;                             // size of the record
  Int_t      fNGroups;                          // number of groups (e.g. detectors) contributing
  Int_t   *  fGroupID;                          //[fNGroups] groups id's (in increasing order)
  Int_t   *  fIndex;                            //[fSize] index of variables
  Double_t*  fValue;                            //[fSize] array of values: derivs,residuals
  //
  ClassDef(AliMillePedeRecord,1)                // Record of track residuals and local/global deriavtives
};

inline void  AliMillePedeRecord::AddIndexValue(Int_t ind, Double_t val) 
{
  if (fSize>=GetDtBufferSize()) ExpandDtBuffer(2*(fSize+1));
  fIndex[fSize]=ind; 
  fValue[fSize++]=val;
}

#endif
Commit	Line	Data
de34b538	1	#ifndef ALIMILLEPEDERECORD_H
	2	#define ALIMILLEPEDERECORD_H
	3
	4	/**********************************************************************************************/
	5	/* AliMillePedeRecords: class to store the data of single track processing */
	6	/* Format: for each measured point the data is stored consequtively */
	7	/* INDEX VALUE */
	8	/* -1 residual */
	9	/* Local_param_id dResidual/dLocal_param */
	10	/* ... ... */
	11	/* -2 weight of the measurement */
	12	/* Global_param_od dResidual/dGlobal_param */
	13	/* ... ... */
	14	/* */
	15	/* The records for all processed tracks are stored in the temporary tree in orgder to be */
	16	/* reused for multiple iterations of MillePede */
	17	/* */
	18	/* Author: ruben.shahoyan@cern.ch */
	19	/* */
	20	/**********************************************************************************************/
	21	#include <TObject.h>
	22
	23	class AliMillePedeRecord : public TObject
	24	{
	25	public:
	26	AliMillePedeRecord();
	27	AliMillePedeRecord(const AliMillePedeRecord& src);
	28	AliMillePedeRecord& operator=(const AliMillePedeRecord& rhs);
	29	//
	30	virtual ~AliMillePedeRecord();
	31	void Reset();
	32	void Print(const Option_t *opt="") const;
	33	//
	34	Int_t GetSize() const {return fSize;}
	35	Int_t *GetIndex() const {return fIndex;}
	36	Int_t GetIndex(int i) const {return fIndex[i];}
	37	//
	38	void GetIndexValue(Int_t i,Int_t &ind,Double_t &val) const {ind=fIndex[i]; val=fValue[i];}
	39	void AddIndexValue(Int_t ind, Double_t val);
	40	void AddResidual(Double_t val) {AddIndexValue(-1,val);}
	41	void AddWeight(Double_t val) {AddIndexValue(-2,val);}
	42	Bool_t IsResidual(Int_t i) const {return fIndex[i]==-1;}
	43	Bool_t IsWeight(Int_t i) const {return fIndex[i]==-2;}
	44	//
	45	Double_t *GetValue() const {return fValue;}
	46	Double_t GetValue(Int_t i) const {return fValue[i];}
	47	//
	48	void MarkGroup(Int_t id);
	49	Int_t GetNGroups() const {return fNGroups;}
	50	Int_t GetGroupID(Int_t i) const {return fGroupID[i];}
	51	Bool_t IsGroupPresent(Int_t id) const;
	52	//
	53	protected:
	54	Int_t GetDtBufferSize() const {return GetUniqueID()&0x0000ffff;}
	55	Int_t GetGrBufferSize() const {return GetUniqueID()>>16;}
	56	void SetDtBufferSize(Int_t sz) {SetUniqueID((GetGrBufferSize()<<16)+sz);}
	57	void SetGrBufferSize(Int_t sz) {SetUniqueID(GetDtBufferSize()+(sz<<16));}
	58	void ExpandDtBuffer(Int_t bfsize);
	59	void ExpandGrBuffer(Int_t bfsize);
	60	//
	61	protected:
	62	Int_t fSize; // size of the record
	63	Int_t fNGroups; // number of groups (e.g. detectors) contributing
	64	Int_t * fGroupID; //[fNGroups] groups id's (in increasing order)
65	Int_t * fIndex; //[fSize] index of variables
66	Double_t* fValue; //[fSize] array of values: derivs,residuals
67	//
68	ClassDef(AliMillePedeRecord,1) // Record of track residuals and local/global deriavtives
69	};
70
71	inline void AliMillePedeRecord::AddIndexValue(Int_t ind, Double_t val)
72	{
73	if (fSize>=GetDtBufferSize()) ExpandDtBuffer(2*(fSize+1));
74	fIndex[fSize]=ind;
75	fValue[fSize++]=val;
76	}
77
78	#endif