GFBookkeeping.cxx

Go to the documentation of this file.

/* Copyright 2008-2010, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert

   This file is part of GENFIT.

   GENFIT is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   GENFIT is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with GENFIT.  If not, see <http://www.gnu.org/licenses/>.
*/
#include"GFBookkeeping.h"
#include"GFException.h"
#include<sstream>
#include"TString.h"
#include"TBuffer.h"


genf::GFBookkeeping::GFBookkeeping(const GFBookkeeping& bk): 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++;
  }


}


void genf::GFBookkeeping::Streamer(TBuffer &R__b)
{
  
  
   // 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    
   }
  
}

void genf::GFBookkeeping::bookMatrices(std::string key){
  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::bookGFDetPlanes(std::string key){
  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];
}

//val is default set to 0.
void genf::GFBookkeeping::bookNumbers(std::string key,double val){
  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::setMatrix(std::string key, unsigned int index,
                            const TMatrixT<Double_t>& mat){
  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::setDetPlane(std::string key, unsigned int index,
                                      const genf::GFDetPlane& pl){
  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::setNumber(std::string key, unsigned int index,
                            const double& num){
  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;
}

bool genf::GFBookkeeping::getMatrix(std::string key,
                            unsigned int index,
                            TMatrixT<Double_t>& mat) const {
  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;
}
bool genf::GFBookkeeping::getDetPlane(std::string key,
                              unsigned int index,
                                      genf::GFDetPlane& pl) const {

  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;
}
bool genf::GFBookkeeping::getNumber(std::string key,
                            unsigned int index,
                            double& num) const {
  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;
}

void genf::GFBookkeeping::addFailedHit(unsigned int id){
  fFailedHits.push_back( id );
}

unsigned int genf::GFBookkeeping::getNumFailed(){
  return fFailedHits.size();
}

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

void genf::GFBookkeeping::clearFailedHits(){
  fFailedHits.clear();
}

void genf::GFBookkeeping::reset() {
  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::clearAll(){
  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();
}

std::vector< std::string > genf::GFBookkeeping::getMatrixKeys() const {
  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;
}
std::vector< std::string > genf::GFBookkeeping::getGFDetPlaneKeys() const {
  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;
}
std::vector< std::string > genf::GFBookkeeping::getNumberKeys() const {
  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;
}


void genf::GFBookkeeping::Print(std::ostream& out /* = std::cout */) const {
  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;
}


//ClassImp(GFBookkeeping)