Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

AIDA_HistogramFactory.cpp

Go to the documentation of this file.
00001 #include "AIDA_HistogramFactory.h"
00002 #include "AIDA_Dev/IDevTree.h"
00003 #include "AIDA_Dev/IDevHistogramFactory.h"
00004 
00005 #include "AIDA_Dev/IDevHistogram1D.h"
00006 #include "AIDA_Dev/IDevHistogram2D.h"
00007 #include "AIDA_Dev/IDevHistogram3D.h"
00008 #include "AIDA_Dev/IDevCloud1D.h"
00009 #include "AIDA_Dev/IDevCloud2D.h"
00010 #include "AIDA_Dev/IDevCloud3D.h"
00011 #include "AIDA_Dev/IDevProfile1D.h"
00012 #include "AIDA_Dev/IDevProfile2D.h"
00013 
00014 #include <typeinfo>
00015 
00016 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00017 #include <exception>
00018 #include <iostream>
00019 #define HISTOGRAM_REPORT_ERROR( XXX ) std::cerr << XXX << std::endl
00020 #endif
00021 
00022 
00023 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::AIDA_HistogramFactory( AIDA::Dev::IDevTree& tree,
00024                                                       AIDA::Dev::IDevHistogramFactory& factory ):
00025   m_tree( tree ),
00026   m_factory( factory )
00027 {}
00028 
00029 bool
00030 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::destroy( AIDA::IBaseHistogram* histo )
00031 {
00032   AIDA::IManagedObject* object = dynamic_cast< AIDA::IManagedObject* >( histo );
00033   if ( ! object ) return false;
00034   return m_tree.rm( m_tree.findPath( *object ) );
00035 }
00036 
00037 AIDA::ICloud1D*
00038 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCloud1D( const std::string& name, const std::string& title, int nMax, const std::string& options )
00039 {
00040 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00041   try{
00042 #endif
00043   AIDA::Dev::IDevCloud1D* p = m_factory.createCloud1D( title, nMax, options );
00044   return registerObject( p, name );
00045 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00046   }
00047   catch( std::exception& e ) {
00048     HISTOGRAM_REPORT_ERROR( e.what() );
00049     return 0;
00050   }
00051 #endif
00052 }
00053 
00054 AIDA::ICloud1D*
00055 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCloud1D( const std::string& name )
00056 {
00057 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00058   try{
00059 #endif
00060   AIDA::Dev::IDevCloud1D* p = m_factory.createCloud1D();
00061   return registerObject( p, name );
00062 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00063   }
00064   catch( std::exception& e ) {
00065     HISTOGRAM_REPORT_ERROR( e.what() );
00066     return 0;
00067   }
00068 #endif
00069 }
00070 
00071 AIDA::ICloud1D*
00072 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::ICloud1D& original )
00073 {
00074 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00075   try{
00076 #endif
00077   AIDA::Dev::IDevCloud1D* p = m_factory.createCopy( original );
00078   return registerObject( p, name );
00079 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00080   }
00081   catch( std::exception& e ) {
00082     HISTOGRAM_REPORT_ERROR( e.what() );
00083     return 0;
00084   }
00085 #endif
00086 }
00087 
00088 AIDA::ICloud2D*
00089 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCloud2D( const std::string& name, const std::string& title, int nMax, const std::string& options )
00090 {
00091 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00092   try{
00093 #endif
00094   AIDA::Dev::IDevCloud2D* p = m_factory.createCloud2D( title, nMax, options );
00095   return registerObject( p, name );
00096 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00097   }
00098   catch( std::exception& e ) {
00099     HISTOGRAM_REPORT_ERROR( e.what() );
00100     return 0;
00101   }
00102 #endif
00103 }
00104 
00105 AIDA::ICloud2D*
00106 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCloud2D( const std::string& name )
00107 {
00108 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00109   try{
00110 #endif
00111   AIDA::Dev::IDevCloud2D* p = m_factory.createCloud2D();
00112   return registerObject( p, name );
00113 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00114   }
00115   catch( std::exception& e ) {
00116     HISTOGRAM_REPORT_ERROR( e.what() );
00117     return 0;
00118   }
00119 #endif
00120 }
00121 
00122 AIDA::ICloud2D*
00123 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::ICloud2D& original )
00124 {
00125 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00126   try{
00127 #endif
00128   AIDA::Dev::IDevCloud2D* p = m_factory.createCopy( original );
00129   return registerObject( p, name );
00130 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00131   }
00132   catch( std::exception& e ) {
00133     HISTOGRAM_REPORT_ERROR( e.what() );
00134     return 0;
00135   }
00136 #endif
00137 }
00138 
00139 AIDA::ICloud3D*
00140 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCloud3D( const std::string& name, const std::string& title, int nMax, const std::string& options )
00141 {
00142 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00143   try{
00144 #endif
00145   AIDA::Dev::IDevCloud3D* p = m_factory.createCloud3D( title, nMax, options );
00146   return registerObject( p, name );
00147 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00148   }
00149   catch( std::exception& e ) {
00150     HISTOGRAM_REPORT_ERROR( e.what() );
00151     return 0;
00152   }
00153 #endif
00154 }
00155 
00156 AIDA::ICloud3D*
00157 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCloud3D( const std::string& name )
00158 {
00159 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00160   try{
00161 #endif
00162   AIDA::Dev::IDevCloud3D* p = m_factory.createCloud3D();
00163   return registerObject( p, name );
00164 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00165   }
00166   catch( std::exception& e ) {
00167     HISTOGRAM_REPORT_ERROR( e.what() );
00168     return 0;
00169   }
00170 #endif
00171 }
00172 
00173 AIDA::ICloud3D*
00174 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::ICloud3D& original )
00175 {
00176 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00177   try{
00178 #endif
00179   AIDA::Dev::IDevCloud3D* p = m_factory.createCopy( original );
00180   return registerObject( p, name );
00181 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00182   }
00183   catch( std::exception& e ) {
00184     HISTOGRAM_REPORT_ERROR( e.what() );
00185     return 0;
00186   }
00187 #endif
00188 }
00189 
00190 AIDA::IHistogram1D*
00191 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram1D( const std::string& name, const std::string& title, int nBins, double lowerEdge, double upperEdge, const std::string& options )
00192 {
00193 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00194   try{
00195 #endif
00196   AIDA::Dev::IDevHistogram1D* p = m_factory.createHistogram1D( title, nBins, lowerEdge, upperEdge, options );
00197   return registerObject( p, name );
00198 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00199   }
00200   catch( std::exception& e ) {
00201     HISTOGRAM_REPORT_ERROR( e.what() );
00202     return 0;
00203   }
00204 #endif
00205 }
00206 
00207 AIDA::IHistogram1D*
00208 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram1D( const std::string& name, const std::string& title, const std::vector< double >& binEdge, const std::string& options )
00209 {
00210 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00211   try{
00212 #endif
00213   AIDA::Dev::IDevHistogram1D* p = m_factory.createHistogram1D( title, binEdge, options );
00214   return registerObject( p, name );
00215 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00216   }
00217   catch( std::exception& e ) {
00218     HISTOGRAM_REPORT_ERROR( e.what() );
00219     return 0;
00220   }
00221 #endif
00222 }
00223 
00224 AIDA::IHistogram1D*
00225 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram1D( const std::string& name, int nBins, double lowerEdge, double upperEdge )
00226 {
00227 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00228   try{
00229 #endif
00230   AIDA::Dev::IDevHistogram1D* p = m_factory.createHistogram1D( nBins, lowerEdge, upperEdge );
00231   return registerObject( p, name );
00232 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00233   }
00234   catch( std::exception& e ) {
00235     HISTOGRAM_REPORT_ERROR( e.what() );
00236     return 0;
00237   }
00238 #endif
00239 }
00240 
00241 AIDA::IHistogram1D*
00242 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::IHistogram1D& original )
00243 {
00244 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00245   try{
00246 #endif
00247   AIDA::Dev::IDevHistogram1D* p = m_factory.createCopy( original );
00248   return registerObject( p, name );
00249 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00250   }
00251   catch( std::exception& e ) {
00252     HISTOGRAM_REPORT_ERROR( e.what() );
00253     return 0;
00254   }
00255 #endif
00256 }
00257 
00258 AIDA::IHistogram2D*
00259 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram2D( const std::string& name, const std::string& title, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY, const std::string& options )
00260 {
00261 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00262   try{
00263 #endif
00264   AIDA::Dev::IDevHistogram2D* p = m_factory.createHistogram2D( title, nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY, options );
00265   return registerObject( p, name );
00266 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00267   }
00268   catch( std::exception& e ) {
00269     HISTOGRAM_REPORT_ERROR( e.what() );
00270     return 0;
00271   }
00272 #endif
00273 }
00274 
00275 AIDA::IHistogram2D*
00276 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram2D( const std::string& name, const std::string& title, const std::vector< double >& binEdgeX, const std::vector< double >& binEdgeY, const std::string& options )
00277 {
00278 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00279   try{
00280 #endif
00281   AIDA::Dev::IDevHistogram2D* p = m_factory.createHistogram2D( title, binEdgeX, binEdgeY, options );
00282   return registerObject( p, name );
00283 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00284   }
00285   catch( std::exception& e ) {
00286     HISTOGRAM_REPORT_ERROR( e.what() );
00287     return 0;
00288   }
00289 #endif
00290 }
00291 
00292 AIDA::IHistogram2D*
00293 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram2D( const std::string& name, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY )
00294 {
00295 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00296   try{
00297 #endif
00298   AIDA::Dev::IDevHistogram2D* p = m_factory.createHistogram2D( nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY );
00299   return registerObject( p, name );
00300 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00301   }
00302   catch( std::exception& e ) {
00303     HISTOGRAM_REPORT_ERROR( e.what() );
00304     return 0;
00305   }
00306 #endif
00307 }
00308 
00309 AIDA::IHistogram2D*
00310 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::IHistogram2D& original )
00311 {
00312 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00313   try{
00314 #endif
00315   AIDA::Dev::IDevHistogram2D* p = m_factory.createCopy( original );
00316   return registerObject( p, name );
00317 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00318   }
00319   catch( std::exception& e ) {
00320     HISTOGRAM_REPORT_ERROR( e.what() );
00321     return 0;
00322   }
00323 #endif
00324 }
00325 
00326 AIDA::IHistogram3D*
00327 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram3D( const std::string& name, const std::string& title, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY, int nBinsZ, double lowerEdgeZ, double upperEdgeZ, const std::string& options )
00328 {
00329 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00330   try{
00331 #endif
00332   AIDA::Dev::IDevHistogram3D* p = m_factory.createHistogram3D( title, nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY, nBinsZ, lowerEdgeZ, upperEdgeZ, options );
00333   return registerObject( p, name );
00334 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00335   }
00336   catch( std::exception& e ) {
00337     HISTOGRAM_REPORT_ERROR( e.what() );
00338     return 0;
00339   }
00340 #endif
00341 }
00342 
00343 AIDA::IHistogram3D*
00344 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram3D( const std::string& name, const std::string& title, const std::vector< double >& binEdgeX, const std::vector< double >& binEdgeY, const std::vector< double >& binEdgeZ, const std::string& options )
00345 {
00346 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00347   try{
00348 #endif
00349   AIDA::Dev::IDevHistogram3D* p = m_factory.createHistogram3D( title, binEdgeX, binEdgeY, binEdgeZ, options );
00350   return registerObject( p, name );
00351 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00352   }
00353   catch( std::exception& e ) {
00354     HISTOGRAM_REPORT_ERROR( e.what() );
00355     return 0;
00356   }
00357 #endif
00358 }
00359 
00360 AIDA::IHistogram3D*
00361 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createHistogram3D( const std::string& name, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY, int nBinsZ, double lowerEdgeZ, double upperEdgeZ )
00362 {
00363 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00364   try{
00365 #endif
00366   AIDA::Dev::IDevHistogram3D* p = m_factory.createHistogram3D( nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY, nBinsZ, lowerEdgeZ, upperEdgeZ );
00367   return registerObject( p, name );
00368 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00369   }
00370   catch( std::exception& e ) {
00371     HISTOGRAM_REPORT_ERROR( e.what() );
00372     return 0;
00373   }
00374 #endif
00375 }
00376 
00377 AIDA::IHistogram3D*
00378 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::IHistogram3D& original )
00379 {
00380 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00381   try{
00382 #endif
00383   AIDA::Dev::IDevHistogram3D* p = m_factory.createCopy( original );
00384   return registerObject( p, name );
00385 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00386   }
00387   catch( std::exception& e ) {
00388     HISTOGRAM_REPORT_ERROR( e.what() );
00389     return 0;
00390   }
00391 #endif
00392 }
00393 
00394 AIDA::IProfile1D*
00395 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile1D( const std::string& name, const std::string& title, int nBins, double lowerEdge, double upperEdge, const std::string& options )
00396 {
00397 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00398   try{
00399 #endif
00400   AIDA::Dev::IDevProfile1D* p = m_factory.createProfile1D( title, nBins, lowerEdge, upperEdge, options );
00401   return registerObject( p, name );
00402 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00403   }
00404   catch( std::exception& e ) {
00405     return 0;
00406   }
00407 #endif
00408 }
00409 
00410 AIDA::IProfile1D*
00411 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile1D( const std::string& name, const std::string& title, int nBins, double lowerEdge, double upperEdge, double lowerValue, double upperValue, const std::string& options )
00412 {
00413 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00414   try{
00415 #endif
00416   AIDA::Dev::IDevProfile1D* p = m_factory.createProfile1D( title, nBins, lowerEdge, upperEdge, lowerValue, upperValue, options );
00417   return registerObject( p, name );
00418 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00419   }
00420   catch( std::exception& e ) {
00421     HISTOGRAM_REPORT_ERROR( e.what() );
00422     return 0;
00423   }
00424 #endif
00425 }
00426 
00427 AIDA::IProfile1D*
00428 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile1D( const std::string& name, const std::string& title, const std::vector< double >& binEdge, const std::string& options )
00429 {
00430 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00431   try{
00432 #endif
00433   AIDA::Dev::IDevProfile1D* p = m_factory.createProfile1D( title, binEdge, options );
00434   return registerObject( p, name );
00435 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00436   }
00437   catch( std::exception& e ) {
00438     HISTOGRAM_REPORT_ERROR( e.what() );
00439     return 0;
00440   }
00441 #endif
00442 }
00443 
00444 AIDA::IProfile1D*
00445 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile1D( const std::string& name, const std::string& title, const std::vector< double >& binEdge, double lowerValue, double upperValue, const std::string& options )
00446 {
00447 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00448   try{
00449 #endif
00450   AIDA::Dev::IDevProfile1D* p = m_factory.createProfile1D( title, binEdge, lowerValue, upperValue, options );
00451   return registerObject( p, name );
00452 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00453   }
00454   catch( std::exception& e ) {
00455     HISTOGRAM_REPORT_ERROR( e.what() );
00456     return 0;
00457   }
00458 #endif
00459 }
00460 
00461 AIDA::IProfile1D*
00462 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile1D( const std::string& name, int nBins, double lowerEdge, double upperEdge )
00463 {
00464 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00465   try{
00466 #endif
00467   AIDA::Dev::IDevProfile1D* p = m_factory.createProfile1D( nBins, lowerEdge, upperEdge );
00468   return registerObject( p, name );
00469 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00470   }
00471   catch( std::exception& e ) {
00472     HISTOGRAM_REPORT_ERROR( e.what() );
00473     return 0;
00474   }
00475 #endif
00476 }
00477 
00478 AIDA::IProfile1D*
00479 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile1D( const std::string& name, int nBins, double lowerEdge, double upperEdge, double lowerValue, double upperValue )
00480 {
00481 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00482   try{
00483 #endif
00484   AIDA::Dev::IDevProfile1D* p = m_factory.createProfile1D( nBins, lowerEdge, upperEdge, lowerValue, upperValue );
00485   return registerObject( p, name );
00486 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00487   }
00488   catch( std::exception& e ) {
00489     HISTOGRAM_REPORT_ERROR( e.what() );
00490     return 0;
00491   }
00492 #endif
00493 }
00494 
00495 AIDA::IProfile1D*
00496 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::IProfile1D& original )
00497 {
00498 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00499   try{
00500 #endif
00501   AIDA::Dev::IDevProfile1D* p = m_factory.createCopy( original );
00502   return registerObject( p, name );
00503 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00504   }
00505   catch( std::exception& e ) {
00506     HISTOGRAM_REPORT_ERROR( e.what() );
00507     return 0;
00508   }
00509 #endif
00510 }
00511 
00512 AIDA::IProfile2D*
00513 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile2D( const std::string& name, const std::string& title, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY, const std::string& options )
00514 {
00515 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00516   try{
00517 #endif
00518   AIDA::Dev::IDevProfile2D* p = m_factory.createProfile2D( title, nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY, options );
00519   return registerObject( p, name );
00520 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00521   }
00522   catch( std::exception& e ) {
00523     HISTOGRAM_REPORT_ERROR( e.what() );
00524     return 0;
00525   }
00526 #endif
00527 }
00528 
00529 AIDA::IProfile2D*
00530 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile2D( const std::string& name, const std::string& title, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY, double lowerValue, double upperValue, const std::string& options )
00531 {
00532 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00533   try{
00534 #endif
00535   AIDA::Dev::IDevProfile2D* p = m_factory.createProfile2D( title, nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY, lowerValue, upperValue, options );
00536   return registerObject( p, name );
00537 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00538   }
00539   catch( std::exception& e ) {
00540     HISTOGRAM_REPORT_ERROR( e.what() );
00541     return 0;
00542   }
00543 #endif
00544 }
00545 
00546 AIDA::IProfile2D*
00547 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile2D( const std::string& name, const std::string& title, const std::vector< double >& binEdgeX, const std::vector< double >& binEdgeY, const std::string& options )
00548 {
00549 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00550   try{
00551 #endif
00552   AIDA::Dev::IDevProfile2D* p = m_factory.createProfile2D( title, binEdgeX, binEdgeY, options );
00553   return registerObject( p, name );
00554 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00555   }
00556   catch( std::exception& e ) {
00557     HISTOGRAM_REPORT_ERROR( e.what() );
00558     return 0;
00559   }
00560 #endif
00561 }
00562 
00563 AIDA::IProfile2D*
00564 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile2D( const std::string& name, const std::string& title, const std::vector< double >& binEdgeX, const std::vector< double >& binEdgeY, double lowerValue, double upperValue, const std::string& options )
00565 {
00566 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00567   try{
00568 #endif
00569   AIDA::Dev::IDevProfile2D* p = m_factory.createProfile2D( title, binEdgeX, binEdgeY, lowerValue, upperValue, options );
00570   return registerObject( p, name );
00571 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00572   }
00573   catch( std::exception& e ) {
00574     HISTOGRAM_REPORT_ERROR( e.what() );
00575     return 0;
00576   }
00577 #endif
00578 }
00579 
00580 AIDA::IProfile2D*
00581 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile2D( const std::string& name, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY )
00582 {
00583 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00584   try{
00585 #endif
00586   AIDA::Dev::IDevProfile2D* p = m_factory.createProfile2D( nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY );
00587   return registerObject( p, name );
00588 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00589   }
00590   catch( std::exception& e ) {
00591     HISTOGRAM_REPORT_ERROR( e.what() );
00592     return 0;
00593   }
00594 #endif
00595 }
00596 
00597 AIDA::IProfile2D*
00598 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createProfile2D( const std::string& name, int nBinsX, double lowerEdgeX, double upperEdgeX, int nBinsY, double lowerEdgeY, double upperEdgeY, double lowerValue, double upperValue )
00599 {
00600 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00601   try{
00602 #endif
00603   AIDA::Dev::IDevProfile2D* p = m_factory.createProfile2D( nBinsX, lowerEdgeX, upperEdgeX, nBinsY, lowerEdgeY, upperEdgeY, lowerValue, upperValue );
00604   return registerObject( p, name );
00605 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00606   }
00607   catch( std::exception& e ) {
00608     HISTOGRAM_REPORT_ERROR( e.what() );
00609     return 0;
00610   }
00611 #endif
00612 }
00613 
00614 AIDA::IProfile2D*
00615 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::createCopy( const std::string& name, const AIDA::IProfile2D& original )
00616 {
00617 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00618   try{
00619 #endif
00620   AIDA::Dev::IDevProfile2D* p = m_factory.createCopy( original );
00621   return registerObject( p, name );
00622 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00623   }
00624   catch( std::exception& e ) {
00625     HISTOGRAM_REPORT_ERROR( e.what() );
00626     return 0;
00627   }
00628 #endif
00629 }
00630 
00631 AIDA::IHistogram1D*
00632 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::add( const std::string& name, const AIDA::IHistogram1D& a, const AIDA::IHistogram1D& b )
00633 {
00634 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00635   try{
00636 #endif
00637   AIDA::Dev::IDevHistogram1D* p = m_factory.add( a, b );
00638   return registerObject( p, name );
00639 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00640   }
00641   catch( std::exception& e ) {
00642     HISTOGRAM_REPORT_ERROR( e.what() );
00643     return 0;
00644   }
00645 #endif
00646 }
00647 
00648 AIDA::IHistogram2D*
00649 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::add( const std::string& name, const AIDA::IHistogram2D& a, const AIDA::IHistogram2D& b )
00650 {
00651 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00652   try{
00653 #endif
00654   AIDA::Dev::IDevHistogram2D* p = m_factory.add( a, b );
00655   return registerObject( p, name );
00656 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00657   }
00658   catch( std::exception& e ) {
00659     HISTOGRAM_REPORT_ERROR( e.what() );
00660     return 0;
00661   }
00662 #endif
00663 }
00664 
00665 AIDA::IHistogram3D*
00666 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::add( const std::string& name, const AIDA::IHistogram3D& a, const AIDA::IHistogram3D& b )
00667 {
00668 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00669   try{
00670 #endif
00671   AIDA::Dev::IDevHistogram3D* p = m_factory.add( a, b );
00672   return registerObject( p, name );
00673 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00674   }
00675   catch( std::exception& e ) {
00676     HISTOGRAM_REPORT_ERROR( e.what() );
00677     return 0;
00678   }
00679 #endif
00680 }
00681 
00682 AIDA::IHistogram1D*
00683 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::subtract( const std::string& name, const AIDA::IHistogram1D& a, const AIDA::IHistogram1D& b )
00684 {
00685 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00686   try{
00687 #endif
00688   AIDA::Dev::IDevHistogram1D* p = m_factory.subtract( a, b );
00689   return registerObject( p, name );
00690 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00691   }
00692   catch( std::exception& e ) {
00693     HISTOGRAM_REPORT_ERROR( e.what() );
00694     return 0;
00695   }
00696 #endif
00697 }
00698 
00699 AIDA::IHistogram2D*
00700 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::subtract( const std::string& name, const AIDA::IHistogram2D& a, const AIDA::IHistogram2D& b )
00701 {
00702 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00703   try{
00704 #endif
00705   AIDA::Dev::IDevHistogram2D* p = m_factory.subtract( a, b );
00706   return registerObject( p, name );
00707 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00708   }
00709   catch( std::exception& e ) {
00710     HISTOGRAM_REPORT_ERROR( e.what() );
00711     return 0;
00712   }
00713 #endif
00714 }
00715 
00716 AIDA::IHistogram3D*
00717 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::subtract( const std::string& name, const AIDA::IHistogram3D& a, const AIDA::IHistogram3D& b )
00718 {
00719 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00720   try{
00721 #endif
00722   AIDA::Dev::IDevHistogram3D* p = m_factory.subtract( a, b );
00723   return registerObject( p, name );
00724 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00725   }
00726   catch( std::exception& e ) {
00727     HISTOGRAM_REPORT_ERROR( e.what() );
00728     return 0;
00729   }
00730 #endif
00731 }
00732 
00733 AIDA::IHistogram1D*
00734 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::multiply( const std::string& name, const AIDA::IHistogram1D& a, const AIDA::IHistogram1D& b )
00735 {
00736 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00737   try{
00738 #endif
00739   AIDA::Dev::IDevHistogram1D* p = m_factory.multiply( a, b );
00740   return registerObject( p, name );
00741 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00742   }
00743   catch( std::exception& e ) {
00744     HISTOGRAM_REPORT_ERROR( e.what() );
00745     return 0;
00746   }
00747 #endif
00748 }
00749 
00750 AIDA::IHistogram2D*
00751 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::multiply( const std::string& name, const AIDA::IHistogram2D& a, const AIDA::IHistogram2D& b )
00752 {
00753 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00754   try{
00755 #endif
00756   AIDA::Dev::IDevHistogram2D* p = m_factory.multiply( a, b );
00757   return registerObject( p, name );
00758 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00759   }
00760   catch( std::exception& e ) {
00761     HISTOGRAM_REPORT_ERROR( e.what() );
00762     return 0;
00763   }
00764 #endif
00765 }
00766 
00767 AIDA::IHistogram3D*
00768 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::multiply( const std::string& name, const AIDA::IHistogram3D& a, const AIDA::IHistogram3D& b )
00769 {
00770 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00771   try{
00772 #endif
00773   AIDA::Dev::IDevHistogram3D* p = m_factory.multiply( a, b );
00774   return registerObject( p, name );
00775 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00776   }
00777   catch( std::exception& e ) {
00778     HISTOGRAM_REPORT_ERROR( e.what() );
00779     return 0;
00780   }
00781 #endif
00782 }
00783 
00784 AIDA::IHistogram1D*
00785 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::divide( const std::string& name, const AIDA::IHistogram1D& a, const AIDA::IHistogram1D& b )
00786 {
00787 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00788   try{
00789 #endif
00790   AIDA::Dev::IDevHistogram1D* p = m_factory.divide( a, b );
00791   return registerObject( p, name );
00792 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00793   }
00794   catch( std::exception& e ) {
00795     HISTOGRAM_REPORT_ERROR( e.what() );
00796     return 0;
00797   }
00798 #endif
00799 }
00800 
00801 AIDA::IHistogram2D*
00802 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::divide( const std::string& name, const AIDA::IHistogram2D& a, const AIDA::IHistogram2D& b )
00803 {
00804 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00805   try{
00806 #endif
00807   AIDA::Dev::IDevHistogram2D* p = m_factory.divide( a, b );
00808   return registerObject( p, name );
00809 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00810   }
00811   catch( std::exception& e ) {
00812     HISTOGRAM_REPORT_ERROR( e.what() );
00813     return 0;
00814   }
00815 #endif
00816 }
00817 
00818 AIDA::IHistogram3D*
00819 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::divide( const std::string& name, const AIDA::IHistogram3D& a, const AIDA::IHistogram3D& b )
00820 {
00821 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00822   try{
00823 #endif
00824   AIDA::Dev::IDevHistogram3D* p = m_factory.divide( a, b );
00825   return registerObject( p, name );
00826 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00827   }
00828   catch( std::exception& e ) {
00829     HISTOGRAM_REPORT_ERROR( e.what() );
00830     return 0;
00831   }
00832 #endif
00833 }
00834 
00835 AIDA::IHistogram1D*
00836 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::projectionX( const std::string& name, const AIDA::IHistogram2D& h )
00837 {
00838 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00839   try{
00840 #endif
00841   AIDA::Dev::IDevHistogram1D* p = m_factory.projectionX( h );
00842   return registerObject( p, name );
00843 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00844   }
00845   catch( std::exception& e ) {
00846     HISTOGRAM_REPORT_ERROR( e.what() );
00847     return 0;
00848   }
00849 #endif
00850 }
00851 
00852 AIDA::IHistogram1D*
00853 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::projectionY( const std::string& name, const AIDA::IHistogram2D& h )
00854 {
00855 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00856   try{
00857 #endif
00858   AIDA::Dev::IDevHistogram1D* p = m_factory.projectionY( h );
00859   return registerObject( p, name );
00860 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00861   }
00862   catch( std::exception& e ) {
00863     HISTOGRAM_REPORT_ERROR( e.what() );
00864     return 0;
00865   }
00866 #endif
00867 }
00868 
00869 AIDA::IHistogram1D*
00870 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::sliceX( const std::string& name, const AIDA::IHistogram2D& h, int indexY )
00871 {
00872 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00873   try{
00874 #endif
00875   AIDA::Dev::IDevHistogram1D* p = m_factory.sliceX( h, indexY );
00876   return registerObject( p, name );
00877 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00878   }
00879   catch( std::exception& e ) {
00880     HISTOGRAM_REPORT_ERROR( e.what() );
00881     return 0;
00882   }
00883 #endif
00884 }
00885 
00886 AIDA::IHistogram1D*
00887 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::sliceY( const std::string& name, const AIDA::IHistogram2D& h, int indexX )
00888 {
00889 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00890   try{
00891 #endif
00892   AIDA::Dev::IDevHistogram1D* p = m_factory.sliceY( h, indexX );
00893   return registerObject( p, name );
00894 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00895   }
00896   catch( std::exception& e ) {
00897     HISTOGRAM_REPORT_ERROR( e.what() );
00898     return 0;
00899   }
00900 #endif
00901 }
00902 
00903 AIDA::IHistogram1D*
00904 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::sliceX( const std::string& name, const AIDA::IHistogram2D& h, int indexY1, int indexY2 )
00905 {
00906 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00907   try{
00908 #endif
00909   AIDA::Dev::IDevHistogram1D* p = m_factory.sliceX( h, indexY1, indexY2 );
00910   return registerObject( p, name );
00911 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00912   }
00913   catch( std::exception& e ) {
00914     HISTOGRAM_REPORT_ERROR( e.what() );
00915     return 0;
00916   }
00917 #endif
00918 }
00919 
00920 AIDA::IHistogram1D*
00921 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::sliceY( const std::string& name, const AIDA::IHistogram2D& h, int indexX1, int indexX2 )
00922 {
00923 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00924   try{
00925 #endif
00926   AIDA::Dev::IDevHistogram1D* p = m_factory.sliceY( h, indexX1, indexX2 );
00927   return registerObject( p, name );
00928 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00929   }
00930   catch( std::exception& e ) {
00931     HISTOGRAM_REPORT_ERROR( e.what() );
00932     return 0;
00933   }
00934 #endif
00935 }
00936 
00937 AIDA::IHistogram2D*
00938 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::projectionXY( const std::string& name, const AIDA::IHistogram3D& h )
00939 {
00940 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00941   try{
00942 #endif
00943   AIDA::Dev::IDevHistogram2D* p = m_factory.projectionXY( h );
00944   return registerObject( p, name );
00945 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00946   }
00947   catch( std::exception& e ) {
00948     HISTOGRAM_REPORT_ERROR( e.what() );
00949     return 0;
00950   }
00951 #endif
00952 }
00953 
00954 AIDA::IHistogram2D*
00955 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::projectionXZ( const std::string& name, const AIDA::IHistogram3D& h )
00956 {
00957 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00958   try{
00959 #endif
00960   AIDA::Dev::IDevHistogram2D* p = m_factory.projectionXZ( h );
00961   return registerObject( p, name );
00962 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00963   }
00964   catch( std::exception& e ) {
00965     HISTOGRAM_REPORT_ERROR( e.what() );
00966     return 0;
00967   }
00968 #endif
00969 }
00970 
00971 AIDA::IHistogram2D*
00972 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::projectionYZ( const std::string& name, const AIDA::IHistogram3D& h )
00973 {
00974 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00975   try{
00976 #endif
00977   AIDA::Dev::IDevHistogram2D* p = m_factory.projectionYZ( h );
00978   return registerObject( p, name );
00979 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00980   }
00981   catch( std::exception& e ) {
00982     HISTOGRAM_REPORT_ERROR( e.what() );
00983     return 0;
00984   }
00985 #endif
00986 }
00987 
00988 AIDA::IHistogram2D*
00989 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::sliceXY( const std::string& name, const AIDA::IHistogram3D& h, int indexZ1, int indexZ2 )
00990 {
00991 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00992   try{
00993 #endif
00994   AIDA::Dev::IDevHistogram2D* p = m_factory.sliceXY( h, indexZ1, indexZ2 );
00995   return registerObject( p, name );
00996 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
00997   }
00998   catch( std::exception& e ) {
00999     HISTOGRAM_REPORT_ERROR( e.what() );
01000     return 0;
01001   }
01002 #endif
01003 }
01004 
01005 AIDA::IHistogram2D*
01006 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::sliceXZ( const std::string& name, const AIDA::IHistogram3D& h, int indexY1, int indexY2 )
01007 {
01008 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
01009   try{
01010 #endif
01011   AIDA::Dev::IDevHistogram2D* p = m_factory.sliceXZ( h, indexY1, indexY2 );
01012   return registerObject( p, name );
01013 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
01014   }
01015   catch( std::exception& e ) {
01016     HISTOGRAM_REPORT_ERROR( e.what() );
01017     return 0;
01018   }
01019 #endif
01020 }
01021 
01022 AIDA::IHistogram2D*
01023 Anaphe::AIDA_Histogram_native::AIDA_HistogramFactory::sliceYZ( const std::string& name, const AIDA::IHistogram3D& h, int indexX1, int indexX2 )
01024 {
01025 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
01026   try{
01027 #endif
01028   AIDA::Dev::IDevHistogram2D* p = m_factory.sliceYZ( h, indexX1, indexX2 );
01029   return registerObject( p, name );
01030 #ifdef ANAPHE_HISTOGRAM_NO_EXCEPTIONS_TO_USER
01031   }
01032   catch( std::exception& e ) {
01033     HISTOGRAM_REPORT_ERROR( e.what() );
01034     return 0;
01035   }
01036 #endif
01037 }

Generated on Tue Nov 19 12:32:17 2002 for AIDA_Histogram_native by doxygen1.2.16