source: MEMPHYS/HEAD/applications/MEMPHYS_analysis.cxx @ 162

// AIDA analysis program over MEMPHYS.root file.

// AIDA :
#include <AIDA/AIDA.h>

// std :
#include <iostream>

//////////////////////////////////////////////////////////////////////////////
bool getXYZ(
 AIDA::ITuple& aParent
,int aColumn
,double& aX
,double& aY
,double& aZ
) 
//////////////////////////////////////////////////////////////////////////////
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
{
  AIDA::ITupleEntry* entry = (AIDA::ITupleEntry*)aParent.getObject(aColumn);
  if(!entry) return false;

  AIDA::ITuple* tuple = dynamic_cast<AIDA::ITuple*>(entry);
  if(!tuple) return false;

  tuple->start();
  if(!tuple->next()) return false;

  aX = tuple->getDouble(0);
  aY = tuple->getDouble(1);
  aZ = tuple->getDouble(2);

  return true;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
bool dump_tracks(
 AIDA::ITuple& aParent
) 
//////////////////////////////////////////////////////////////////////////////
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
{
  AIDA::ITupleEntry* entry = (AIDA::ITupleEntry*)aParent.getObject(8);
  if(!entry) return false;

  AIDA::ITuple* tuple = dynamic_cast<AIDA::ITuple*>(entry);
  if(!tuple) return false;

  //if(nPart!=tracks->rows()) {
  //  std::cout << "read: nPart / tracks mismatch " 
  //              << nPart << " " << tracks->rows() << std::endl;
  //  return false;
  //}

  tuple->start();
  int irow = 0;
  while(tuple->next()) {

    int pId = tuple->getInt(0);
    int parent = tuple->getInt(1);
    int timeStart = tuple->getInt(2);

    double dx,dy,dz;
    if(!getXYZ(*tuple,3,dx,dy,dz)) return false;

    double mass = tuple->getDouble(4);
    double pTot = tuple->getDouble(5);
    double ETot = tuple->getDouble(6);

    double px,py,pz;
    if(!getXYZ(*tuple,7,dx,dy,dz)) return false;
    double start_x,start_y,start_z;
    if(!getXYZ(*tuple,8,dx,dy,dz)) return false;
    double stop_x,stop_y,stop_z;
    if(!getXYZ(*tuple,9,dx,dy,dz)) return false;

    int startVol = tuple->getDouble(10);
    int stopVol = tuple->getDouble(11);

    std::cout << "----> Tk{"<<irow<<"}: " 
              << " pId " << pId
              << " parent " << parent
                << " creation time " << timeStart 
                << " Volumes " << startVol << " " << stopVol << "\n"
                << " Start Pos (" << start_x << "," << start_y << "," << start_z << ")\n"
                << " Stop Pos (" << stop_x << "," << stop_y << "," << stop_z << ")\n"
                << " dx,dy,dz " << dx << " " << dy << " " << dz << "\n"
                << " m " << mass
                << " ETot " << ETot
                << " pTot " << pTot
                << " px,py,pz " << px << " " << py << " " << pz << "\n"
                << std::endl;

    irow++;
  }
  return true;
}
//////////////////////////////////////////////////////////////////////////////
int main(
 int //aArgc
,char** //aArgv
) 
//////////////////////////////////////////////////////////////////////////////
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
{
  //std::string arg1 = aArgc>=2?aArgv[1]:"";

  std::string program = "MEMPHYS_analysis";
  std::string header = program + " : ";

  AIDA::IAnalysisFactory* aida = AIDA_createAnalysisFactory();
  if(!aida) {
    std::cout << header << "AIDA not found." << std::endl;
    return 1;
  }

  AIDA::ITreeFactory* treeFactory = aida->createTreeFactory();
  if(!treeFactory) {
    std::cout << header << "can't get a TreeFactory." << std::endl;
    return 1;
  }

  AIDA::ITree* tree = treeFactory->create("MEMPHYS.root","root",true,false);
  if(!tree) {
    std::cout << header << "can't open data file." << std::endl;
    return 1;
  }

  AIDA::IManagedObject* object = tree->find("Event");
  if(!object) {
    std::cout << header 
              << "object Event not found in tree." 
              << std::endl;
    return 1;
  }
  AIDA::ITuple* tuple = dynamic_cast<AIDA::ITuple*>(object);
  if(!tuple) {
    std::cout << header << "object not an AIDA::ITuple." << std::endl;
    return 1;
  }

  int coln = tuple->columns();
  for(int index=0;index<coln;index++) {
    std::cout << header 
              << " icol = " << index
              << ", label = " << tuple->columnName(index) 
              << ", type = " << tuple->columnType(index) 
              << std::endl;
  }

  std::cout << header << "rows = " << tuple->rows() << std::endl;

  //int nentries = tuple->rows();
  //int nentries = 100000;
  int nentries = 40;
  std::cout << header 
            << "traitements de " << nentries << " entrees" 
            << std::endl;

  int irow = 0;
  tuple->start();
  while(tuple->next() && (irow<nentries)) {

    int eventId = tuple->getInt(0);
    //int inputEvtId = tuple->getInt(1);
    //int interMode = tuple->getInt(2);
    //int vtxVol = tuple->getInt(3);

    int nPart = tuple->getInt(5);
    //int leptonIndex = tuple->getInt(6);
    //int protonIndex = tuple->getInt(7);

    int nHits = tuple->getInt(9);
    int nDigits = tuple->getInt(11);
    double sumPE = tuple->getDouble(12);

    std::cout << ">>>>>>>>>>>>> Event{" << irow << "}: "
              << " evt Id " << eventId 
    //        << " evt Input Id " << inputEvtId
    //        << "\n interaction mode " << interMode
    //        << " start in volume " << vtxVol << "\n"
              <<" #tracks: " << nPart
              <<" #hits: " << nHits
              <<" #digits: " << nDigits
              <<" sumPE " << sumPE
              << std::endl;

    if(!dump_tracks(*tuple)) return false;

    irow++;
  }

  delete treeFactory;
  delete tree;
  delete aida;

  return 0;
}