genf::GFBookkeeping Class Reference

#include <GFBookkeeping.h>

Inheritance diagram for genf::GFBookkeeping:

Public Member Functions
void	reset ()
void	setNhits (int n)
void	bookMatrices (std::string key)
void	bookGFDetPlanes (std::string key)
void	bookNumbers (std::string key, double val=0.)
void	setMatrix (std::string key, unsigned int index, const TMatrixT< Double_t > &mat)
void	setDetPlane (std::string key, unsigned int index, const GFDetPlane &pl)
void	setNumber (std::string key, unsigned int index, const double &num)
bool	getMatrix (std::string key, unsigned int index, TMatrixT< Double_t > &mat) const
bool	getDetPlane (std::string key, unsigned int index, GFDetPlane &pl) const
bool	getNumber (std::string key, unsigned int index, double &num) const
std::vector< std::string >	getMatrixKeys () const
std::vector< std::string >	getGFDetPlaneKeys () const
std::vector< std::string >	getNumberKeys () const
void	addFailedHit (unsigned int)
unsigned int	hitFailed (unsigned int)
unsigned int	getNumFailed ()
	GFBookkeeping ()
	GFBookkeeping (const GFBookkeeping &)
virtual	~GFBookkeeping ()
void	Streamer (TBuffer &)
void	clearAll ()
void	clearFailedHits ()
void	Print (std::ostream &out=std::cout) const

Private Member Functions
GFBookkeeping &	operator= (const GFBookkeeping &)=delete
virtual void	Print (Option_t *) const

Private Attributes
std::map< std::string, TMatrixT< Double_t > * >	fMatrices
std::map< std::string, GFDetPlane * >	fPlanes
std::map< std::string, TMatrixT< Double_t > * >	fNumbers
std::vector< unsigned int >	fFailedHits
int	fNhits

Detailed Description

Definition at line 34 of file GFBookkeeping.h.

Constructor & Destructor Documentation

genf::GFBookkeeping::GFBookkeeping ( )

inline

Definition at line 72 of file GFBookkeeping.h.

: fNhits(-1) {}

genf::GFBookkeeping::GFBookkeeping

(

const GFBookkeeping &

bk

)

Definition at line 26 of file GFBookkeeping.cxx.

                                                       : TObject(bk) {
  fNhits = bk.fNhits;
  fMatrices = bk.fMatrices; //implicit copy constructor call
  fNumbers = bk.fNumbers;
  fPlanes = bk.fPlanes;
  fFailedHits = bk.fFailedHits;

  //deep copy

  std::map<std::string,TMatrixT<Double_t>*>::const_iterator it;
  std::map<std::string,TMatrixT<Double_t>*>::iterator it_here;

  it = bk.fMatrices.begin();
  it_here = fMatrices.begin();
  while(it!=bk.fMatrices.end()){
    it_here->second  = new TMatrixT<Double_t>[fNhits];
    for(int i=0;i<fNhits;++i){
      (it_here->second)[i] = (it->second)[i];
    }
    it++;
    it_here++;
  }

  it = bk.fNumbers.begin();
  it_here = fNumbers.begin();
  while(it!=bk.fNumbers.end()){
    it_here->second  = new TMatrixT<Double_t>[fNhits];
    for(int i=0;i<fNhits;++i){
      (it_here->second)[i] = (it->second)[i];
    }
    it++;
    it_here++;
  }

  std::map<std::string,genf::GFDetPlane*>::const_iterator ip;
  std::map<std::string,genf::GFDetPlane*>::iterator ip_here;

  ip = bk.fPlanes.begin();
  ip_here = fPlanes.begin();
  while(ip!=bk.fPlanes.end()){
    ip_here->second  = new genf::GFDetPlane[fNhits];
    for(int i=0;i<fNhits;++i){
      (ip_here->second)[i] = ((ip->second)[i]);
    }
    ip++;
    ip_here++;
  }


}

virtual genf::GFBookkeeping::~GFBookkeeping ( )

inlinevirtual

Definition at line 74 of file GFBookkeeping.h.

{clearAll();}

Member Function Documentation

void genf::GFBookkeeping::addFailedHit

(

unsigned int

id

)

Definition at line 364 of file GFBookkeeping.cxx.

                                                   {
  fFailedHits.push_back( id );
}

void genf::GFBookkeeping::bookGFDetPlanes

(

std::string

key

)

Definition at line 212 of file GFBookkeeping.cxx.

                                                    {
  if(fNhits<0){
    GFException exc("fNhits not defined",__LINE__,__FILE__);
    throw exc;
  }
  if(fPlanes[key] != NULL){
    std::ostringstream ostr;
    ostr << "The key " << key
         << " is already occupied in genf::GFBookkeeping::bookGFDetPlanes()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  fPlanes[key]  = new genf::GFDetPlane[fNhits];
}

void genf::GFBookkeeping::bookMatrices

(

std::string

key

)

Definition at line 197 of file GFBookkeeping.cxx.

                                                 {
  if(fNhits<0){
    GFException exc("fNhits not defined",__LINE__,__FILE__);
    throw exc;
  }
  if(fMatrices[key] != NULL){
    std::ostringstream ostr;
    ostr << "The key " << key
         << " is already occupied in genf::GFBookkeeping::bookMatrices()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  fMatrices[key]  = new TMatrixT<Double_t>[fNhits];
}

void genf::GFBookkeeping::bookNumbers	(	std::string	key,
		double	val = 0.
	)

Definition at line 228 of file GFBookkeeping.cxx.

                                                           {
  if(fNhits<0){
    GFException exc("fNhits not defined",__LINE__,__FILE__);
    throw exc;
  }
  if(fPlanes[key] != NULL){
    std::ostringstream ostr;
    ostr << "The key " << key
         << " is already occupied in genf::GFBookkeeping::bookNumbers()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  fNumbers[key]  = new TMatrixT<Double_t>[fNhits];
  for(int i=0;i<fNhits;++i){
    ((fNumbers[key])[i]).ResizeTo(1,1);
    ((fNumbers[key])[i])[0][0] = val;
  }

}

void genf::GFBookkeeping::clearAll

(

)

Definition at line 406 of file GFBookkeeping.cxx.

                                {
  std::map<std::string, TMatrixT<Double_t>* >::iterator itMat;
  for(itMat=fMatrices.begin();itMat!=fMatrices.end();itMat++){
    if(itMat->second!=NULL) delete [] itMat->second;
  }
  std::map<std::string, genf::GFDetPlane* >::iterator itPl;
  for(itPl=fPlanes.begin();itPl!=fPlanes.end();itPl++){
    if(itPl->second!=NULL) delete [] itPl->second;
  }
  std::map<std::string, TMatrixT<Double_t>* >::iterator itNum;
  for(itNum=fNumbers.begin();itNum!=fNumbers.end();itNum++){
    if(itNum->second!=NULL) delete [] itNum->second;
  }
  fMatrices.clear();
  fPlanes.clear();
  fNumbers.clear();
}

void genf::GFBookkeeping::clearFailedHits

(

)

Definition at line 382 of file GFBookkeeping.cxx.

                                       {
  fFailedHits.clear();
}

bool genf::GFBookkeeping::getDetPlane	(	std::string	key,
		unsigned int	index,
		genf::GFDetPlane &	pl
	)		const

Definition at line 322 of file GFBookkeeping.cxx.

                                                                {

  auto iPlane = fPlanes.find(key);
  if(iPlane == fPlanes.end()){
    std::ostringstream ostr;
    ostr << "The key " << key << " is unknown in genf::GFBookkeeping::getGFDetPlane()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  if(index>=(unsigned int)fNhits){
    std::ostringstream ostr;
    ostr << "The index " << index
         << " is out of range in genf::GFBookkeeping::getGFDetPlane()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  pl = iPlane->second[index];
  return true;
}

std::vector< std::string > genf::GFBookkeeping::getGFDetPlaneKeys

(

)

const

Definition at line 432 of file GFBookkeeping.cxx.

                                                                  {
  std::vector< std::string > keys;
  std::map<std::string, genf::GFDetPlane* >::const_iterator it;
  for(it=fPlanes.begin();it!=fPlanes.end();it++){
    if(it->second!=NULL) keys.push_back(it->first);
  }
  return keys;
}

bool genf::GFBookkeeping::getMatrix	(	std::string	key,
		unsigned int	index,
		TMatrixT< Double_t > &	mat
	)		const

Definition at line 301 of file GFBookkeeping.cxx.

                                                           {
  auto iMatrix = fMatrices.find(key);
  if(iMatrix == fMatrices.end()){
    std::ostringstream ostr;
    ostr << "The key " << key << " is unknown in genf::GFBookkeeping::getMatrix()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  if(index>=(unsigned int)fNhits){
    std::ostringstream ostr;
    ostr << "The index " << index
         << " is out of range in genf::GFBookkeeping::getMatrix()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  mat.ResizeTo(iMatrix->second[index]);
  mat = iMatrix->second[index];
  return true;
}

std::vector< std::string > genf::GFBookkeeping::getMatrixKeys

(

)

const

Definition at line 424 of file GFBookkeeping.cxx.

                                                              {
  std::vector< std::string > keys;
  std::map<std::string, TMatrixT<Double_t>* >::const_iterator it;
  for(it=fMatrices.begin();it!=fMatrices.end();it++){
    if(it->second!=NULL) keys.push_back(it->first);
  }
  return keys;
}

bool genf::GFBookkeeping::getNumber	(	std::string	key,
		unsigned int	index,
		double &	num
	)		const

Definition at line 343 of file GFBookkeeping.cxx.

                                               {
  auto iNumber = fNumbers.find(key);
  if(iNumber == fNumbers.end()){
    std::ostringstream ostr;
    ostr << "The key " << key << " is unknown in genf::GFBookkeeping::getNumber()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  if(index>=(unsigned int)fNhits){
    std::ostringstream ostr;
    ostr << "The index " << index
         << " is out of range in genf::GFBookkeeping::getNumber()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  num = iNumber->second[index][0][0];
  return true;
}

std::vector< std::string > genf::GFBookkeeping::getNumberKeys

(

)

const

Definition at line 440 of file GFBookkeeping.cxx.

                                                              {
  std::vector< std::string > keys;
  std::map<std::string, TMatrixT<Double_t>* >::const_iterator it;
  for(it=fNumbers.begin();it!=fNumbers.end();it++){
    if(it->second!=NULL) keys.push_back(it->first);
  }
  return keys;
}

unsigned int genf::GFBookkeeping::getNumFailed

(

)

Definition at line 368 of file GFBookkeeping.cxx.

                                            {
  return fFailedHits.size();
}

unsigned int genf::GFBookkeeping::hitFailed

(

unsigned int

id

)

Definition at line 372 of file GFBookkeeping.cxx.

                                                        {
  unsigned int retVal = 0;
  for(unsigned int i=0;i<fFailedHits.size();++i){
    if(fFailedHits.at(i) == id){
      ++retVal;
    }
  }
  return retVal;
}

GFBookkeeping& genf::GFBookkeeping::operator= ( const GFBookkeeping &  )

privatedelete

void genf::GFBookkeeping::Print

(

std::ostream &

out = std::cout

)

const

Definition at line 450 of file GFBookkeeping.cxx.

                                                     {
  out << "=============genf::GFBookkeeping::print()==============" << std::endl;
  out << "-----printing all matrices:------" << std::endl;
  std::vector<std::string> keys = getMatrixKeys();
  for(unsigned int i=0;i<keys.size();++i){
    out << "key " << keys.at(i) << " has " << fNhits
              << " entries:" << std::endl;
    for(int j=0;j<fNhits;++j){
      TMatrixT<Double_t> m;
      getMatrix(keys.at(i),j,m);
      m.Print(); // TODO print the matrix outself
    }
  }
  out << "-----printing all GFDetPlanes:------" << std::endl;
  keys = getGFDetPlaneKeys();
  for(unsigned int i=0;i<keys.size();++i){
    out << "key " << keys.at(i) << " has " << fNhits
              << " entries:" << std::endl;
    for(int j=0;j<fNhits;++j){
      genf::GFDetPlane p;
      getDetPlane(keys.at(i),j,p);
      p.Print(out);
    }
  }
  out << "-----printing all numbers:------" << std::endl;
  keys = getNumberKeys();
  for(unsigned int i=0;i<keys.size();++i){
    out << "key " << keys.at(i) << " has " << fNhits
              << " entries:" << std::endl;
    for(int j=0;j<fNhits;++j){
      double n(-1111.);
      getNumber(keys.at(i),j,n);
      out << n << std::endl;
    }
  }
  out << "-----failed hits:------" << std::endl;
  for(unsigned int i=0;i<fFailedHits.size();++i){
    out << fFailedHits.at(i) << " ";
  }
  out << std::endl;
}

virtual void genf::GFBookkeeping::Print ( Option_t *  ) const

inlineprivatevirtual

Definition at line 86 of file GFBookkeeping.h.

    { throw GFException(std::string(__func__) + "::Print(Option_t*) not available", __LINE__, __FILE__).setFatal(); }

void genf::GFBookkeeping::reset

(

)

Definition at line 386 of file GFBookkeeping.cxx.

                              {
  std::vector<std::string> matKeys = getMatrixKeys();
  std::vector<std::string> planeKeys = getGFDetPlaneKeys();
  std::vector<std::string> numKeys = getNumberKeys();

  clearAll();
  clearFailedHits();

  for(unsigned int i=0;i<matKeys.size();++i){
    bookMatrices(matKeys.at(i));
  }
  for(unsigned int i=0;i<planeKeys.size();++i){
    bookGFDetPlanes(planeKeys.at(i));
  }
  for(unsigned int i=0;i<numKeys.size();++i){
    bookNumbers(numKeys.at(i));
  }

}

void genf::GFBookkeeping::setDetPlane	(	std::string	key,
		unsigned int	index,
		const GFDetPlane &	pl
	)

Definition at line 266 of file GFBookkeeping.cxx.

                                                               {
  if(fPlanes[key] == NULL){
    std::ostringstream ostr;
    ostr << "The key " << key << " is unknown in genf::GFBookkeeping::setGFDetPlane()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  if(index>=(unsigned int)fNhits){
    std::ostringstream ostr;
    ostr << "The index " << index
         << " is out of range in genf::GFBookkeeping::setGFDetPlane()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  (fPlanes[key])[index] = pl;
}

void genf::GFBookkeeping::setMatrix	(	std::string	key,
		unsigned int	index,
		const TMatrixT< Double_t > &	mat
	)

Definition at line 248 of file GFBookkeeping.cxx.

                                                          {
  if(fMatrices[key] == NULL){
    std::ostringstream ostr;
    ostr << "The key " << key << " is unknown in genf::GFBookkeeping::setMatrix()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  if(index>=(unsigned int)fNhits){
    std::ostringstream ostr;
    ostr << "The index " << index
         << " is out of range in genf::GFBookkeeping::setMatrix()";
   GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  (fMatrices[key])[index].ResizeTo(mat);
  (fMatrices[key])[index] = mat;
}

void genf::GFBookkeeping::setNhits ( int  n )

inline

Definition at line 50 of file GFBookkeeping.h.

{fNhits=n; reset();}

void genf::GFBookkeeping::setNumber	(	std::string	key,
		unsigned int	index,
		const double &	num
	)

Definition at line 283 of file GFBookkeeping.cxx.

                                              {
  if(fNumbers[key] == NULL){
    std::ostringstream ostr;
    ostr << "The key " << key << " is unknown in genf::GFBookkeeping::setNumber()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  if(index>=(unsigned int)fNhits){
    std::ostringstream ostr;
    ostr << "The index " << index
         << " is out of range in genf::GFBookkeeping::setNumber()";
    GFException exc(ostr.str(),__LINE__,__FILE__);
    throw exc;
  }
  ((fNumbers[key])[index])[0][0] = num;
}

void genf::GFBookkeeping::Streamer

(

TBuffer &

R__b

)

Definition at line 78 of file GFBookkeeping.cxx.

{


   // Stream an object of class GFBookkeeping.
   if (R__b.IsReading()) {

     //     Version_t R__v = R__b.ReadVersion();
     TObject::Streamer(R__b);

     clearAll();

     R__b >> fNhits;

     TString s;
     std::string key;
     unsigned int nkeys;
     TMatrixT<Double_t> mat;
     genf::GFDetPlane pl;

     {//reading matrices
       R__b >> nkeys;
       for(unsigned int i=0;i<nkeys;++i){
         s.Streamer(R__b);
         key = s.Data();
         bookMatrices(key);
         for(int j=0;j<fNhits;++j){
           mat.Streamer(R__b);
           setMatrix(key,j,mat);
         }
       }
     }//done reading matrices
     {//reading planes
       R__b >> nkeys;
       for(unsigned int i=0;i<nkeys;++i){
         s.Streamer(R__b);
         key = s.Data();
         bookGFDetPlanes(key);
         for(int j=0;j<fNhits;++j){
           pl.Streamer(R__b);
           setDetPlane(key,j,pl);
         }
       }
     }//done reading planes
     {//reading numbers
       R__b >> nkeys;
       for(unsigned int i=0;i<nkeys;++i){
         s.Streamer(R__b);
         key = s.Data();
         bookNumbers(key);
         for(int j=0;j<fNhits;++j){
           mat.Streamer(R__b);
           setNumber(key,j,mat[0][0]);
         }
       }
     }//done reading numbers
     {//read failed hits
       clearFailedHits();
       unsigned int nFailedHits;
       R__b >> nFailedHits;
       unsigned int aFailedHit;
       for(unsigned int i=0;i<nFailedHits;++i){
         R__b >> aFailedHit;
         fFailedHits.push_back(aFailedHit);
       }
     }//done reading failed hits
   } else {
     //     R__b.WriteVersion(genf::GFBookkeeping::IsA());
     TObject::Streamer(R__b);

     //write number of hits
     R__b << fNhits;

     std::vector<std::string> keys;
     {//save matrices
       keys = getMatrixKeys();
       R__b << (unsigned int)(keys.size());
       for(unsigned int i=0;i<keys.size();++i){
         TString s(keys.at(i));
         s.Streamer(R__b);
         for(int j=0;j<fNhits;++j){
           ((fMatrices[keys.at(i)])[j]).Streamer(R__b);
         }
       }
     }
     keys.clear();
     {//save GFDetPlanes
       keys = getGFDetPlaneKeys();
       R__b << (unsigned int)(keys.size());
       for(unsigned int i=0;i<keys.size();++i){
         TString s(keys.at(i));
         s.Streamer(R__b);
         for(int j=0;j<fNhits;++j){
           ((fPlanes[keys.at(i)])[j]).Streamer(R__b);
         }
       }
     }//done saving GFDetPlanes
     keys.clear();
     {//save numbers
       keys = getNumberKeys();
       R__b << (unsigned int)(keys.size());
       for(unsigned int i=0;i<keys.size();++i){
         TString s(keys.at(i));
         s.Streamer(R__b);
         for(int j=0;j<fNhits;++j){
           ((fNumbers[keys.at(i)])[j]).Streamer(R__b);
         }
       }
     }//done saving numbers
     {//save failedHits
       R__b << ((unsigned int) fFailedHits.size());
       for(unsigned int i=0;i<fFailedHits.size();++i){
         R__b << fFailedHits.at(i);
       }
     }//done saving failed Hits
   }

}

Member Data Documentation

std::vector< unsigned int > genf::GFBookkeeping::fFailedHits

private

Definition at line 45 of file GFBookkeeping.h.

std::map<std::string, TMatrixT<Double_t>* > genf::GFBookkeeping::fMatrices

private

Definition at line 39 of file GFBookkeeping.h.

int genf::GFBookkeeping::fNhits

private

Definition at line 46 of file GFBookkeeping.h.

std::map<std::string, TMatrixT<Double_t>* > genf::GFBookkeeping::fNumbers

private

Definition at line 44 of file GFBookkeeping.h.

std::map<std::string, GFDetPlane* > genf::GFBookkeeping::fPlanes

private

Definition at line 40 of file GFBookkeeping.h.

---

The documentation for this class was generated from the following files:

• GFBookkeeping.h
• GFBookkeeping.cxx