QAverageVectorC.cc

Go to the documentation of this file.

#include "QAverageVectorC.hh"
#include <sstream>
#include <algorithm>
 
using std::stringstream;
using std::vector;
using std::endl;
using std::cout;
using std::string;
 
QObjectImp(QAverageVectorC);
using namespace Diana;
 
QAverageVectorC::QAverageVectorC()
  : fNumEvents(0)
{}
QAverageVectorC::QAverageVectorC(const QAverageVectorC& orig)
  : QVectorC(orig),
    fNumEvents(0)
{
  fNumEvents=orig.fNumEvents;
  fSourceRuns=orig.fSourceRuns;
}
QAverageVectorC::QAverageVectorC(const QVectorC &orig)
  : QVectorC(orig),
    fNumEvents(0)
{}
void QAverageVectorC::Clear()
{
  QVectorC::Clear();
  fSourceRuns.clear();
  fNumEvents = 0;
}
 
QError QAverageVectorC::WriteOnStream (std::ostream &o) const 
{
  QError err = QERR_SUCCESS;
  
  // QVectorC dump
  const QVectorC vec = *this;
  err = vec.WriteOnStream(o);
  if(err != QERR_SUCCESS) return err;
  o<<"fNumEvents"<<"\t"<<fNumEvents<<endl;
  // source runs
  o<<"fSourceRuns.size"<<"\t"<<fSourceRuns.size()<<endl;
  
  if(fSourceRuns.empty()) return err;
 
  for(size_t j=0; j<fSourceRuns.size(); j++) {
    o<<"fSourceRuns["<<j<<"]"<<"\t"<<fSourceRuns[j]<<"\t"<< endl; 
  }
 
  return err;
}
 
QError QAverageVectorC::ReadFromStream(std::istream& ob) 
{
  QError err = QERR_SUCCESS;
 
  std::string tag;
  int numev, size, run;
  stringstream str;
  // read QVectorC 
 
  QVectorC vec;
 
  err = vec.ReadFromStream(ob);
  if(err != QERR_SUCCESS) return err;
  this->QVectorC::operator=(vec);
 
  // restart from the beginning of ob
  ob.clear();
  ob.seekg(std::ios::beg); 
  // read fNumEvents    
  string line;
  do {
      getline(ob,line);
      stringstream sline;
      sline<<line;
      sline>> tag;
    if(tag == "fNumEvents") sline >> numev;
  } while(tag != "fNumEvents");
  
  if(tag != "fNumEvents") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fNumEvents");
    return err;
  }
  fNumEvents = numev;
 
  // read fSource Runs
  ob >> tag >> size;
  if(tag != "fSourceRuns.size") {
    err = QERR_UNKNOWN_ERR;
    err.SetDescription("Expected tag fSourceRuns.size");
    return err;
  }
 
  char s[50];
 
  for(Int_t i=0; i<size; i++) {
    ob >> tag >> run;
    snprintf(s,50,"fSourceRuns[%d]",i);    
    if(tag != s) {
      err = QERR_UNKNOWN_ERR;
      err.SetDescription("Expected tag fSourceRuns");
      return err;    
    }
    fSourceRuns.push_back(run);
   }
  
  
  return err;
}
/*
const QAverageVectorC &QAverageVectorC::operator+=(const QAverageVectorC &alt)
{
  // Make sure the sizes match
  if(Size()!=alt.Size()){
    std::stringstream msg;
    msg << "Can not add two average vectors of different size. ("
        << Size() << "!=" << alt.Size() << ").";
    DianaThrow(QError(QERR_SIZE_NOT_MATCH,__FILE__,__LINE__,
                      msg.str().c_str()));
  }
 
  // Get the new weighted average
  for(size_t i=0;i<Size();i++)
    (*this)[i]=(fNumEvents*(*this)[i]+alt.fNumEvents*alt[i])
      *1./(fNumEvents+alt.fNumEvents);
 
  // Set the new number of Events
  fNumEvents+=alt.fNumEvents;
 
  // Update the list of source runs
  for(size_t i=0;i<alt.fSourceRuns.size();i++)
    fSourceRuns.push_back(alt.fSourceRuns[i]);
 
  // Make sure the list is unique
  std::sort(fSourceRuns.begin(),fSourceRuns.end());
  std::vector<int>::iterator it=
    std::unique(fSourceRuns.begin(),fSourceRuns.end());
  fSourceRuns.resize(std::distance(fSourceRuns.begin(),it));
 
  return (*this);
}
 
QAverageVectorC QAverageVectorC::operator+(const QAverageVectorC &alt) const
{
  QAverageVectorC ret(*this);
  ret+=alt;
  return ret;
}
*/
const QAverageVectorC& QAverageVectorC::operator=(const QVectorC& orig)
{
   Clear();
   QVectorC::operator=(orig);
   return *this;
}
const QAverageVectorC& QAverageVectorC::operator=(const QAverageVectorC& orig)
{
   Clear();
   QVectorC::operator=(orig);
   fNumEvents=orig.fNumEvents;
   fSourceRuns=orig.fSourceRuns;
   return *this;
}