Index: trunk/source/processes/hadronic/models/management/src/G4HadronicInteraction.cc
===================================================================
--- trunk/source/processes/hadronic/models/management/src/G4HadronicInteraction.cc	(revision 819)
+++ trunk/source/processes/hadronic/models/management/src/G4HadronicInteraction.cc	(revision 962)
@@ -24,27 +24,45 @@
 // ********************************************************************
 //
+// $Id: G4HadronicInteraction.cc,v 1.4 2009/01/24 11:56:27 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-02-ref-02 $
 //
- // Hadronic Interaction  base class
- // original by H.P. Wellisch
- // modified by J.L. Chuma, TRIUMF, 21-Mar-1997
- // Last modified: 04-Apr-1997
- // reimplemented 1.11.2003 JPW.
- 
+// Hadronic Interaction  base class
+// original by H.P. Wellisch
+// modified by J.L. Chuma, TRIUMF, 21-Mar-1997
+// Last modified: 04-Apr-1997
+// reimplemented 1.11.2003 JPW.
+// 23-Jan-2009 V.Ivanchenko move constructor and destructor to the body
+
 #include "G4HadronicInteraction.hh"
- 
- G4double
-  G4HadronicInteraction::GetMinEnergy(
+#include "G4HadronicInteractionRegistry.hh"
+#include "G4HadronicException.hh"
+
+G4HadronicInteraction::G4HadronicInteraction(const G4String& modelName) :
+  verboseLevel(0), theMinEnergy(0.0*GeV), theMaxEnergy(25.0*GeV), 
+  isBlocked(false), theModelName(modelName)
+{ 
+  G4HadronicInteractionRegistry::Instance()->RegisterMe(this);
+}
+    
+G4HadronicInteraction::~G4HadronicInteraction()
+{
+  G4HadronicInteractionRegistry::Instance()->RemoveMe(this);
+}
+ 
+G4double G4HadronicInteraction::GetMinEnergy(
    const G4Material *aMaterial, const G4Element *anElement ) const
-  {
-    size_t i;
-    if( IsBlocked(aMaterial) )return 0.*GeV;
-    if( IsBlocked(anElement) )return 0.*GeV;
-    for( i=0; i<theMinEnergyListElements.size(); ++i )
-    {
-      if( anElement == theMinEnergyListElements[i].second )return theMinEnergyListElements[i].first;
+{
+  size_t i;
+  if( IsBlocked(aMaterial) )return 0.*GeV;
+  if( IsBlocked(anElement) )return 0.*GeV;
+  for( i=0; i<theMinEnergyListElements.size(); ++i )
+    {
+      if( anElement == theMinEnergyListElements[i].second )
+	return theMinEnergyListElements[i].first;
     }
     for( i=0; i<theMinEnergyList.size(); ++i )
     {
-      if( aMaterial == theMinEnergyList[i].second )return theMinEnergyList[i].first;
+      if( aMaterial == theMinEnergyList[i].second )
+	return theMinEnergyList[i].first;
     }
     if(IsBlocked()) return 0.*GeV;
@@ -54,17 +72,15 @@
            << " not found in min energy List" << G4endl;
     return theMinEnergy;
-  }
- 
- void
-  G4HadronicInteraction::SetMinEnergy(
-   G4double anEnergy,
-   G4Element *anElement )
-  {
-    if( IsBlocked(anElement) )
-      G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
+}
+ 
+void G4HadronicInteraction::SetMinEnergy(G4double anEnergy,
+					 G4Element *anElement )
+{
+  if( IsBlocked(anElement) )
+    G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
            << "    The model is not active for the Element  "
            << anElement->GetName() << "." << G4endl;
     
-    for( size_t i=0; i<theMinEnergyListElements.size(); ++i )
+  for( size_t i=0; i<theMinEnergyListElements.size(); ++i )
     {
       if( anElement == theMinEnergyListElements[i].second )
@@ -74,63 +90,60 @@
       }
     }
-    theMinEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
-  }
- 
- void
-  G4HadronicInteraction::SetMinEnergy(
-   G4double anEnergy,
-   G4Material *aMaterial )
-  {
-    if( IsBlocked(aMaterial) )
-      G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
+  theMinEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
+}
+ 
+void G4HadronicInteraction::SetMinEnergy(G4double anEnergy,
+					 G4Material *aMaterial )
+{
+  if( IsBlocked(aMaterial) )
+    G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
            << "    The model is not active for the Material "
            << aMaterial->GetName() << "." << G4endl;
     
-    for( size_t i=0; i<theMinEnergyList.size(); ++i )
+  for( size_t i=0; i<theMinEnergyList.size(); ++i )
     {
       if( aMaterial == theMinEnergyList[i].second )
-      {
-        theMinEnergyList[i].first = anEnergy;
-        return;
-      }
-    }
-    theMinEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
-  }
- 
- G4double
-  G4HadronicInteraction::GetMaxEnergy(
-   const G4Material *aMaterial, const G4Element *anElement ) const
-  {
-    size_t i;
-    if( IsBlocked(aMaterial) )return 0.0*GeV;
-    if( IsBlocked(anElement) )return 0.0*GeV;
-    for( i=0; i<theMaxEnergyListElements.size(); ++i )
-    {
-      if( anElement == theMaxEnergyListElements[i].second )return theMaxEnergyListElements[i].first;
+	{
+	  theMinEnergyList[i].first = anEnergy;
+	  return;
+	}
+    }
+  theMinEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
+}
+ 
+G4double G4HadronicInteraction::GetMaxEnergy(const G4Material *aMaterial, 
+					     const G4Element *anElement ) const
+{
+  size_t i;
+  if( IsBlocked(aMaterial) )return 0.0*GeV;
+  if( IsBlocked(anElement) )return 0.0*GeV;
+  for( i=0; i<theMaxEnergyListElements.size(); ++i )
+    {
+      if( anElement == theMaxEnergyListElements[i].second )
+	return theMaxEnergyListElements[i].first;
     }
     for( i=0; i<theMaxEnergyList.size(); ++i )
     {
-      if( aMaterial == theMaxEnergyList[i].second )return theMaxEnergyList[i].first;
+      if( aMaterial == theMaxEnergyList[i].second )
+	return theMaxEnergyList[i].first;
     }
     if(IsBlocked()) return 0.*GeV;
     if( verboseLevel > 0 )
       G4cout << "*** Warning from HadronicInteraction::GetMaxEnergy" << G4endl
-           << "    material " << aMaterial->GetName()
-           << " not found in min energy List" << G4endl;
+	     << "    material " << aMaterial->GetName()
+	     << " not found in min energy List" << G4endl;
     
     return theMaxEnergy;
-  }
- 
- void
-  G4HadronicInteraction::SetMaxEnergy(
-   G4double anEnergy,
-   G4Element *anElement ) 
-  {
-    if( IsBlocked(anElement) )
-      G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
+}
+ 
+void G4HadronicInteraction::SetMaxEnergy(G4double anEnergy,
+					 G4Element *anElement ) 
+{
+  if( IsBlocked(anElement) )
+    G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
            << "Warning: The model is not active for the Element  "
            << anElement->GetName() << "." << G4endl;
     
-    for( size_t i=0; i<theMaxEnergyListElements.size(); ++i )
+  for( size_t i=0; i<theMaxEnergyListElements.size(); ++i )
     {
       if( anElement == theMaxEnergyListElements[i].second )
@@ -140,66 +153,73 @@
       }
     }
-    theMaxEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
-  }
-
- void
-  G4HadronicInteraction::SetMaxEnergy(
-   G4double anEnergy,
-   G4Material *aMaterial )
-  {
-    if( IsBlocked(aMaterial) ) 
-      G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
+  theMaxEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
+}
+
+void G4HadronicInteraction::SetMaxEnergy(G4double anEnergy,
+					 G4Material *aMaterial )
+{
+  if( IsBlocked(aMaterial) ) 
+    G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
            << "Warning: The model is not active for the Material "
            << aMaterial->GetName() << "." << G4endl;
     
-    for( size_t i=0; i<theMaxEnergyList.size(); ++i )
+  for( size_t i=0; i<theMaxEnergyList.size(); ++i )
     {
       if( aMaterial == theMaxEnergyList[i].second )
-      {
+	{
         theMaxEnergyList[i].first = anEnergy;
         return;
-      }
-    }
-    theMaxEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
-  }
-
- void 
-  G4HadronicInteraction::DeActivateFor( G4Material *aMaterial )
-  {
-    theBlockedList.push_back(aMaterial);
-  }
-
- void 
-  G4HadronicInteraction::DeActivateFor( G4Element *anElement )
-  {
-    theBlockedListElements.push_back(anElement);
-  }
-
- G4bool 
-  G4HadronicInteraction::IsBlocked( const G4Material *aMaterial ) const
-  {
-    for( size_t i=0; i<theBlockedList.size(); ++i )
+	}
+    }
+  theMaxEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
+}
+
+void G4HadronicInteraction::DeActivateFor( G4Material *aMaterial )
+{
+  theBlockedList.push_back(aMaterial);
+}
+
+void G4HadronicInteraction::DeActivateFor( G4Element *anElement )
+{
+  theBlockedListElements.push_back(anElement);
+}
+
+G4bool G4HadronicInteraction::IsBlocked( const G4Material *aMaterial ) const
+{
+  for( size_t i=0; i<theBlockedList.size(); ++i )
     {
       if( aMaterial == theBlockedList[i] )
-      {
-        return true;
-      }
-    }
-    return false;
-  }
- 
- G4bool 
-  G4HadronicInteraction::IsBlocked( const G4Element *anElement ) const
-  {
-    for( size_t i=0; i<theBlockedListElements.size(); ++i )
+	{
+	  return true;
+	}
+    }
+  return false;
+}
+ 
+G4bool G4HadronicInteraction::IsBlocked( const G4Element *anElement ) const
+{
+  for( size_t i=0; i<theBlockedListElements.size(); ++i )
     {
       if( anElement == theBlockedListElements[i] )
-      {
-        return true;
-      }
-    }
-    return false;
-  }
- 
- /* end of file */
- 
+	{
+	  return true;
+	}
+    }
+  return false;
+}
+
+G4HadronicInteraction::G4HadronicInteraction(const G4HadronicInteraction &right )
+{ 
+  *this = right; 
+}
+    
+const G4HadronicInteraction& 
+G4HadronicInteraction::operator=(const G4HadronicInteraction &right )
+{ 
+  G4String text = "unintended use of G4HadronicInteraction::operator=";
+  throw G4HadronicException(__FILE__, __LINE__, text); 
+  return right;
+}
+ 
+/* end of file */
+ 
