| # Gaudi Framework, version v21r8 |

Home |  | Generated: 17 Mar 2010

# CollectionCloneAlg Class Reference

Small algorithm, which allows to merge N-tuples in a generic way. More...

Inheritance diagram for CollectionCloneAlg:

[legend]
Collaboration diagram for CollectionCloneAlg:

[legend]

List of all members.

## Public Member Functions
| CollectionCloneAlg (const std::string &name, ISvcLocator *pSvcLocator)
| Standard algorithm constructor.
virtual | ~CollectionCloneAlg ()
| Standard Destructor.
virtual StatusCode | initialize ()
| Initialize.
virtual StatusCode | finalize ()
| Finalize.
virtual StatusCode | execute ()
| Execute procedure.
virtual StatusCode | book (const NTuple::Tuple *nt)
| Book the N-tuple according to the specification.
virtual StatusCode | checkInput (const NTuple::Tuple *clone, const NTuple::Tuple *src)
StatusCode | mergeEntries (const std::string &input)
| Merge the entries of a single input tuple into the output.
StatusCode | connect ()
| Connect input and output N-tuples.
StatusCode | mergeInputTuples ()
| Merge all N-tuple entries.
## Private Attributes
INTupleSvc * | m_dataSvc
| Reference to data provider service.
std::string | m_tupleSvc
| Name of the data provider service.
std::string | m_output
| Output specification.
std::vector< std::string > | m_inputs
| input specifications
std::string | m_rootName
| Name of the root leaf (obtained at initialize).
std::string | m_outName
| Output tuple name.
std::string | m_criteria
| Selection criteria (if any).
std::string | m_selectorName
| Selector factory.

## Detailed Description

Small algorithm, which allows to merge N-tuples in a generic way.

In the options directory an python interface is presented, which shows how to steer this algorithm in a standaqlone program.

Author:
  : M.Frank

Version:
  : 1.0

Definition at line 127 of file CollectionCloneAlg.cpp.

## Constructor & Destructor Documentation

CollectionCloneAlg::CollectionCloneAlg | ( | const std::string & | name,
|  | ISvcLocator * | pSvcLocator |
| ) |  |  | `[inline]`

Standard algorithm constructor.

Definition at line 147 of file CollectionCloneAlg.cpp.

    00148   :     Algorithm(name, pSvcLocator),  m_dataSvc(0)
    00149   {
    00150     declareProperty("EvtTupleSvc", m_tupleSvc="EvtTupleSvc");
    00151     declareProperty("Input",       m_inputs);
    00152     declareProperty("Output",      m_output);
    00153   }

virtual CollectionCloneAlg::~CollectionCloneAlg | ( |  | ) | `[inline, virtual]`

Standard Destructor.

Definition at line 155 of file CollectionCloneAlg.cpp.

    00155                                     {
    00156   }

## Member Function Documentation

virtual StatusCode CollectionCloneAlg::initialize | ( |  | ) | `[inline, virtual]`

Initialize.

Reimplemented from Algorithm.

Definition at line 159 of file CollectionCloneAlg.cpp.

    00159                                     {
    00160     MsgStream log(msgSvc(), name());
    00161     m_rootName = "";
    00162     m_outName = "";
    00163     m_criteria = "";
    00164     m_selectorName = "";
    00165     StatusCode sc = service(m_tupleSvc, m_dataSvc, true);
    00166     if ( sc.isSuccess() )  {
    00167       std::string fun;
    00168       Tokenizer tok(true);
    00169       tok.analyse(m_output, " ", "", "", "=", "'", "'");
    00170       for ( Tokenizer::Items::iterator i = tok.items().begin(); i != tok.items().end(); i++ )   {
    00171         const std::string& tag = (*i).tag();
    00172         const std::string& val = (*i).value();
    00173         switch( ::toupper(tag[0]) )    {
    00174         case 'D':
    00175           m_outName = val;
    00176           break;
    00177         case 'S':
    00178           m_criteria = val;
    00179           break;
    00180         case 'F':
    00181           fun = val;
    00182         default:
    00183           break;
    00184         }
    00185       }
    00186       if ( m_outName.empty() )  {
    00187         log << MSG::ERROR << "Failed to analyze output specs:" << m_output << endmsg;
    00188         return StatusCode::FAILURE;
    00189       }
    00190       if ( fun.length() > 0 || m_criteria.length() > 0 )   {
    00191         if ( m_criteria.length() > 0 && fun.length() == 0 ) fun = "NTuple::Selector";
    00192         m_selectorName = fun;
    00193         return StatusCode::SUCCESS;
    00194       }
    00195       return sc;
    00196     }
    00197     log << MSG::ERROR << "Failed to access service \""
    00198         << m_tupleSvc << "\"." << endmsg;
    00199     return sc;
    00200   }

virtual StatusCode CollectionCloneAlg::finalize | ( | void |  | ) | `[inline, virtual]`

Finalize.

Reimplemented from Algorithm.

Definition at line 203 of file CollectionCloneAlg.cpp.

    00203                                 {
    00204     if ( m_dataSvc ) m_dataSvc->release();
    00205     m_dataSvc = 0;
    00206     return StatusCode::SUCCESS;
    00207   }

virtual StatusCode CollectionCloneAlg::execute | ( |  | ) | `[inline, virtual]`

Execute procedure.

Definition at line 210 of file CollectionCloneAlg.cpp.

    00210                                   {
    00211     StatusCode status = connect();
    00212     if ( status.isSuccess() )  {
    00213       status = mergeInputTuples();
    00214     }
    00215     return status;
    00216   }

virtual StatusCode CollectionCloneAlg::book | ( | const NTuple::Tuple * | nt | ) | `[inline, virtual]`

Book the N-tuple according to the specification.

Definition at line 219 of file CollectionCloneAlg.cpp.

    00219                                                   {
    00220     MsgStream log(msgSvc(), name());
    00221     const INTuple::ItemContainer& items = nt->items();
    00222     StatusCode status = StatusCode::SUCCESS;
    00223     INTuple::ItemContainer::const_iterator i;
    00224     NTuple::Tuple* tuple = m_dataSvc->book(m_outName, nt->clID(), nt->title());
    00225     for (i = items.begin(); i != items.end(); ++i)  {
    00226       long type = (*i)->type();
    00227       switch(type)  {
    00228       case DataTypeInfo::UCHAR:
    00229         status = createItem(log, tuple, *i, (unsigned char)0);
    00230         break;
    00231       case DataTypeInfo::USHORT:
    00232         status = createItem(log, tuple, *i, (unsigned short)0);
    00233         break;
    00234       case DataTypeInfo::UINT:
    00235         status = createItem(log, tuple, *i, (unsigned int)0);
    00236         break;
    00237       case DataTypeInfo::ULONG:
    00238         status = createItem(log, tuple, *i, (unsigned long)0);
    00239         break;
    00240       case DataTypeInfo::CHAR:
    00241         status = createItem(log, tuple, *i, char(0));
    00242         break;
    00243       case DataTypeInfo::SHORT:
    00244         status = createItem(log, tuple, *i, short(0));
    00245         break;
    00246       case DataTypeInfo::INT:
    00247         status = createItem(log, tuple, *i, int(0));
    00248         break;
    00249       case DataTypeInfo::LONG:
    00250         status = createItem(log, tuple, *i, long(0));
    00251         break;
    00252       case DataTypeInfo::BOOL:
    00253         status = createItem(log, tuple, *i, false);
    00254         break;
    00255       case DataTypeInfo::FLOAT:
    00256         status = createItem(log, tuple, *i, float(0.0));
    00257         break;
    00258       case DataTypeInfo::DOUBLE:
    00259         status = createItem(log, tuple, *i, double(0.0));
    00260         break;
    00261       case DataTypeInfo::OBJECT_ADDR:
    00262         status = createItem(log, tuple, *i, (IOpaqueAddress*)0);
    00263         break;
    00264       case DataTypeInfo::POINTER:
    00265         status = createItem(log, tuple, *i, (void*)0);
    00266         break;
    00267       case DataTypeInfo::STRING:
    00268 //        status = createItem(log, tuple, *i, (std::string*)0);
    00269 //        break;
    00270       case DataTypeInfo::NTCHAR:
    00271 //        status = createItem(log, tuple, *i, (char*)0);
    00272 //        break;
    00273       case DataTypeInfo::UNKNOWN:
    00274       default:
    00275         status = StatusCode::FAILURE;
    00276         break;
    00277       }
    00278     }
    00279     return status;
    00280   }

virtual StatusCode CollectionCloneAlg::checkInput | ( | const NTuple::Tuple * | clone,
|  | const NTuple::Tuple * | src |
| ) |  |  | `[inline, virtual]`

Definition at line 283 of file CollectionCloneAlg.cpp.

    00283                                                                                    {
    00284     MsgStream log(msgSvc(), name());
    00285     if ( 0 != clone && 0 != src )   {
    00286       const INTuple::ItemContainer& clone_items  = clone->items();
    00287       const std::string clone_id = clone->registry()->identifier();
    00288       const std::string src_id = src->registry()->identifier();
    00289
    00290       INTuple::ItemContainer::const_iterator i;
    00291       log << MSG::ERROR;
    00292       for (i = clone_items.begin(); i != clone_items.end(); ++i)  {
    00293         const INTupleItem* itm = *i;
    00294         const std::string& nam = itm->name();
    00295         const INTupleItem* src_itm = src->find(nam);
    00296         if ( !src_itm )  {
    00297           log << "Tuple item " << nam << " not present in " << src_id << endmsg;
    00298           return StatusCode::FAILURE;
    00299         }
    00300         if ( itm->type() != src_itm->type() )  {
    00301           log << "Tuple item " << nam << " are of different types in "
    00302             << src_id   << ":" << src_itm->typeName() << " <-> "
    00303             << clone_id << ":" << itm->typeName() << endmsg;
    00304           return StatusCode::FAILURE;
    00305         }
    00306         if ( itm->ndim() != src_itm->ndim() )  {
    00307           log << "Tuple item " << nam << " have different dimensions in "
    00308             << src_id   << ":" << src_itm->ndim() << " <-> "
    00309             << clone_id << ":" << itm->ndim() << endmsg;
    00310           return StatusCode::FAILURE;
    00311         }
    00312         for (int j=0; j<itm->ndim(); ++j)  {
    00313           if ( src_itm->dim(j) != itm->dim(j) )  {
    00314             log << "Tuple item " << nam << " have different dimensions in "
    00315               << src_id   << "[" << j << "]:" << src_itm->dim(j) << " <-> "
    00316               << clone_id << "[" << j << "]:" << itm->dim(j) << endmsg;
    00317             return StatusCode::FAILURE;
    00318           }
    00319         }
    00320         if ( itm->hasIndex() != src_itm->hasIndex() )  {
    00321           log << "Tuple item " << nam << " has different index colums "
    00322             << src_id   << ":" << src_itm->hasIndex() << " <-> "
    00323             << clone_id << ":" << itm->hasIndex() << endmsg;
    00324           return StatusCode::FAILURE;
    00325         }
    00326         if ( itm->hasIndex() )  {
    00327           if ( itm->index() != src_itm->index() )  {
    00328             log << "Tuple item " << nam << " has different index colums "
    00329               << src_id   << ":" << src_itm->index() << " <-> "
    00330               << clone_id << ":" << itm->index() << endmsg;
    00331             return StatusCode::FAILURE;
    00332           }
    00333         }
    00334       }
    00335       return StatusCode::SUCCESS;
    00336     }
    00337     return StatusCode::FAILURE;
    00338   }

StatusCode CollectionCloneAlg::mergeEntries | ( | const std::string & | input | ) | `[inline]`

Merge the entries of a single input tuple into the output.

Definition at line 341 of file CollectionCloneAlg.cpp.

    00341                                                    {
    00342     MsgStream log(msgSvc(), name());
    00343     NTuplePtr out(m_dataSvc, m_outName);
    00344     if ( 0 != out )  {
    00345       const INTuple::ItemContainer& clone_items  = out->items();
    00346       std::vector<GenericAddress> addrVector(clone_items.size());
    00347       StatusCode status = StatusCode::SUCCESS;
    00348       NTuplePtr nt(m_dataSvc, input);
    00349       size_t k = 0, nentry = 0;
    00350       if ( 0 != nt ) {
    00351         const INTuple::ItemContainer& source_items = nt->items();
    00352         for (k=0; k < source_items.size(); ++k )  {
    00353           if ( source_items[k]->type() == DataTypeInfo::OBJECT_ADDR )  {
    00354             *(IOpaqueAddress**)source_items[k]->buffer() = &addrVector[k];
    00355           }
    00356         }
    00357         while ( status.isSuccess() ) {
    00358           status = m_dataSvc->readRecord(nt.ptr());
    00359           if ( status.isSuccess() )   {
    00360             INTuple::ItemContainer::const_iterator i;
    00361             nentry++;
    00362             for (k=0,i = source_items.begin(); i != source_items.end(); ++i,++k)  {
    00363               const INTupleItem* src_itm = *i;
    00364               const INTupleItem* out_itm = out->find(src_itm->name());
    00365               size_t size = 0;
    00366               switch((*i)->type())  {
    00367               case DataTypeInfo::UCHAR:
    00368                 size = sizeof(unsigned char);
    00369                 break;
    00370               case DataTypeInfo::USHORT:
    00371                 size = sizeof(unsigned short);
    00372                 break;
    00373               case DataTypeInfo::UINT:
    00374                 size = sizeof(unsigned int);
    00375                 break;
    00376               case DataTypeInfo::ULONG:
    00377                 size = sizeof(unsigned long);
    00378                 break;
    00379               case DataTypeInfo::CHAR:
    00380                 size = sizeof(char);
    00381                 break;
    00382               case DataTypeInfo::SHORT:
    00383                 size = sizeof(short);
    00384                 break;
    00385               case DataTypeInfo::INT:
    00386                 size = sizeof(int);
    00387                 break;
    00388               case DataTypeInfo::LONG:
    00389                 size = sizeof(long);
    00390                 break;
    00391               case DataTypeInfo::BOOL:
    00392                 size = sizeof(bool);
    00393                 break;
    00394               case DataTypeInfo::FLOAT:
    00395                 size = sizeof(float);
    00396                 break;
    00397               case DataTypeInfo::DOUBLE:
    00398                 size = sizeof(double);
    00399                 break;
    00400               case DataTypeInfo::STRING:
    00401                 *(std::string*)out_itm->buffer() = *(std::string*)src_itm->buffer();
    00402                 size = 0;
    00403                 break;
    00404               case DataTypeInfo::NTCHAR:
    00405                 size = ::strlen((const char*)src_itm->buffer())+1;
    00406                 break;
    00407               case DataTypeInfo::POINTER:
    00408                 {
    00409                   *(void**)out_itm->buffer() = *(void**)src_itm->buffer();
    00410                   size = 0;
    00411                 }
    00412                 break;
    00413               case DataTypeInfo::OBJECT_ADDR:
    00414                 {
    00415                 IOpaqueAddress* ppA1  = &addrVector[k];
    00416                 IOpaqueAddress** ppA2 = (IOpaqueAddress**)out_itm->buffer();
    00417                 *ppA2 = ppA1;
    00418                 size = 0;
    00419                 }
    00420                 break;
    00421               case DataTypeInfo::UNKNOWN:
    00422               default:
    00423                 size = 0;
    00424                 break;
    00425               }
    00426               if ( size > 0 )  {
    00427                 ::memcpy((void*)out_itm->buffer(), src_itm->buffer(), size*src_itm->length());
    00428               }
    00429             }
    00430             status = m_dataSvc->writeRecord(out.ptr());
    00431             if ( !status.isSuccess() )  {
    00432               log << MSG::ERROR << "Failed to write record " << nentry
    00433                   << " from " << input << " to " << m_outName << endmsg;
    00434             }
    00435           }
    00436         }
    00437         log << MSG::INFO << "End of reading tuple " << input
    00438             << " after " << nentry << " entries." << endmsg;
    00439
    00440         if ( nentry > 0 || m_selectorName != "" )  {
    00441           return StatusCode::SUCCESS;
    00442         }
    00443         return StatusCode::FAILURE;
    00444       }
    00445       log << MSG::ERROR << "Failed to access input: " << input << endmsg;
    00446     }
    00447     return StatusCode::FAILURE;
    00448   }

StatusCode CollectionCloneAlg::connect | ( |  | ) | `[inline]`

Connect input and output N-tuples.

Definition at line 451 of file CollectionCloneAlg.cpp.

    00451                          {
    00452     StatusCode status = StatusCode::SUCCESS;
    00453     for (size_t i=0; i < m_inputs.size(); ++i)  {
    00454       NTuplePtr nt(m_dataSvc, m_inputs[i]);
    00455       if ( !(0 == nt) )    {
    00456         NTuplePtr out(m_dataSvc, m_outName);
    00457         if ( 0 == out )  {
    00458           status = book(nt);
    00459         }
    00460         else  {
    00461           status = checkInput(out, nt);
    00462         }
    00463         if ( !status.isSuccess() )  {
    00464           return status;
    00465         }
    00466         else if ( m_selectorName != "" )   {
    00467           SmartIF<ISelectStatement> stmt(ROOT::Reflex::PluginService::Create<IInterface*>(m_selectorName,serviceLocator()));
    00468           if ( stmt.isValid( ) )    {
    00469             if ( m_criteria.length() > 0 ) stmt->setCriteria(m_criteria);
    00470             nt->attachSelector(stmt);
    00471           }
    00472           else  {
    00473             MsgStream log(msgSvc(), name());
    00474             log << MSG::ERROR << "Failed to attach tuple selector to " << m_inputs[i] << endmsg;
    00475             return StatusCode::FAILURE;
    00476           }
    00477         }
    00478       }
    00479       else  {
    00480         MsgStream log(msgSvc(), name());
    00481         log << MSG::ERROR << "Failed to access tuple: " << m_inputs[i] << endmsg;
    00482         return StatusCode::FAILURE;
    00483       }
    00484     }
    00485     return StatusCode::SUCCESS;
    00486   }

StatusCode CollectionCloneAlg::mergeInputTuples | ( |  | ) | `[inline]`

Merge all N-tuple entries.

Definition at line 489 of file CollectionCloneAlg.cpp.

    00489                                  {
    00490     MsgStream log(msgSvc(), name());
    00491     for (size_t inp=0; inp < m_inputs.size(); ++inp)  {
    00492       StatusCode sc = mergeEntries(m_inputs[inp]);
    00493       if ( !sc.isSuccess() )  {
    00494         log << MSG::ERROR << "Failed to merge tuple:" << m_inputs[inp] << endmsg;
    00495         return sc;
    00496       }
    00497     }
    00498     return StatusCode::SUCCESS;
    00499   }

## Member Data Documentation

INTupleSvc* CollectionCloneAlg::m_dataSvc`[private]`

Reference to data provider service.

Definition at line 129 of file CollectionCloneAlg.cpp.

std::string CollectionCloneAlg::m_tupleSvc`[private]`

Name of the data provider service.

Definition at line 131 of file CollectionCloneAlg.cpp.

std::string CollectionCloneAlg::m_output`[private]`

Output specification.

Definition at line 133 of file CollectionCloneAlg.cpp.

std::vector<std::string> CollectionCloneAlg::m_inputs`[private]`

input specifications

Definition at line 135 of file CollectionCloneAlg.cpp.

std::string CollectionCloneAlg::m_rootName`[private]`

Name of the root leaf (obtained at initialize).

Definition at line 137 of file CollectionCloneAlg.cpp.

std::string CollectionCloneAlg::m_outName`[private]`

Output tuple name.

Definition at line 139 of file CollectionCloneAlg.cpp.

std::string CollectionCloneAlg::m_criteria`[private]`

Selection criteria (if any).

Definition at line 141 of file CollectionCloneAlg.cpp.

std::string CollectionCloneAlg::m_selectorName`[private]`

Selector factory.

Definition at line 143 of file CollectionCloneAlg.cpp.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r8/GaudiSvc/src/NTupleSvc/CollectionCloneAlg.cpp