KVDBSystem.h

/***************************************************************************
$Id: KVDBSystem.h,v 1.12 2008/03/07 15:01:34 ebonnet Exp $
                          KVDBSystem.h  -  description
                             -------------------
    begin                : jeu f� 13 2003
    copyright            : (C) 2003 by Alexis Mignon
    email                : mignon@ganil.fr
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef KV_DB_SYSTEM_H
#define KV_DB_SYSTEM_H
 
#include "KVDBRecord.h"
#include "Riostream.h"
#include "KVTarget.h"
#include "KVUnownedList.h"
class KV2Body;
class KVNumberList;
 
class KVDBSystem: public KVDBRecord {
 
private:
 
   KV2Body* fCinema = nullptr;            
 
   KVTarget* fTarget = nullptr;           //-> physical target used for experiment run
 
    mutable KVUnownedList fRunlist;
   Int_t fRuns = 0;                 
   ULong64_t fEvents = 0;           
 
protected:
   UInt_t fZbeam=0;              // charge of the projectile nucleus
   UInt_t fAbeam=0;               // Mass of the projectile nucleus
   UInt_t fZtarget=0;             // charge of the target nucleus
   UInt_t fAtarget=0;             // Mass of the target nucleus
   Float_t fEbeam=0.;              // Energy of the beam in MeV/nucleon
 
   KVDBTable* GetRunsTable();
 
public:
   KVDBSystem(){}
   KVDBSystem(const Char_t* name);
   KVDBSystem(int, int, int, int, Float_t);
   KVDBSystem(const KVNucleus& X, const KVNucleus& Y, const KVString& = "");
   virtual ~ KVDBSystem();
 
   KVTarget* GetTarget() const
   {
      return fTarget;
   }
   void SetTarget(KVTarget* targ)
   {
      fTarget = targ;
   }
 
   void ls(Option_t* option = "*") const override;
   UInt_t GetZtarget() const;
   UInt_t GetAtarget() const;
   UInt_t GetZbeam() const;
   UInt_t GetAbeam() const;
   UInt_t GetZproj() const;
   UInt_t GetAproj() const;
   Float_t GetEbeam() const;
   Float_t GetEproj() const;
   Float_t GetTargetThickness() const;
 
   UInt_t GetZtot() const;
   UInt_t GetAtot() const;
   Double_t GetZVtot() const;
   Double_t GetPtot() const;
   Double_t GetEtot() const;
   Double_t GetECM() const;
 
   Bool_t IsCollision() const;
 
   void SetZtarget(UInt_t z);
   void SetAtarget(UInt_t a);
   void SetZbeam(UInt_t z);
   void SetAbeam(UInt_t a);
   void SetEbeam(Float_t energy);
 
   void SetBeam(UInt_t z, UInt_t a, Float_t energy);
 
   KVUnownedList GetRuns() const;
 
   Int_t GetNGoodRunFiles() const;
   void GetRunList(KVNumberList&) const;
   KVNumberList GetRunList() const;
   void Save(std::ostream&) const;
   void Load(std::istream&,int = 1);
 
   Int_t Compare(const TObject*) const override;
 
   KV2Body* GetKinematics();
 
   void Print(Option_t* option = "") const override;
 
   void SetNumberRuns(Int_t n)
   {
      fRuns = n;
   }
   Int_t GetNumberRuns()
   {
      return fRuns;
   }
   void SetEvents(ULong64_t e)
   {
      fEvents = e;
   }
   ULong64_t GetEvents() const
   {
      return fEvents;
   }
 
   void SetRuns(const KVNumberList&, int = 1);
   void RemoveRun(KVDBRecord*);
   void RemoveRun(Int_t);
   void AddRun(KVDBRecord*);
   void AddRun(Int_t);
   void RemoveAllRuns();
   TString GetBatchName();
   TString GetBatchNameWithoutEnergy();
   TString GetReactionNameWithoutEnergy();
   TString GetReactionEnergyWithoutName();
 
   ClassDefOverride(KVDBSystem, 2)      // System class
};
 
inline UInt_t KVDBSystem::GetZtarget() const
{
   return fZtarget;
}
 
inline UInt_t KVDBSystem::GetAtarget() const
{
   return fAtarget;
}
 
inline UInt_t KVDBSystem::GetZtot() const
{
   return fZtarget + fZbeam;
}
 
inline UInt_t KVDBSystem::GetAtot() const
{
   return fAtarget + fAbeam;
}
 
inline UInt_t KVDBSystem::GetZbeam() const
{
   return fZbeam;
}
 
inline UInt_t KVDBSystem::GetAbeam() const
{
   return fAbeam;
}
 
inline UInt_t KVDBSystem::GetZproj() const
{
   return fZbeam;
}
 
inline UInt_t KVDBSystem::GetAproj() const
{
   return fAbeam;
}
 
inline Float_t KVDBSystem::GetEbeam() const
{
   return fEbeam;
}
 
inline Float_t KVDBSystem::GetEproj() const
{
   return fEbeam;
}
 
inline Float_t KVDBSystem::GetTargetThickness() const
{
   return (GetTarget() ? GetTarget()->GetTotalThickness() : 0.);
}
 
inline void KVDBSystem::SetZtarget(UInt_t z)
{
   fZtarget = z;
}
 
inline void KVDBSystem::SetAtarget(UInt_t a)
{
   fAtarget = a;
}
 
inline void KVDBSystem::SetZbeam(UInt_t z)
{
   fZbeam = z;
}
 
inline void KVDBSystem::SetAbeam(UInt_t a)
{
   fAbeam = a;
}
 
inline void KVDBSystem::SetEbeam(Float_t energy)
{
   fEbeam = energy;
}
 
inline void KVDBSystem::SetBeam(UInt_t z, UInt_t a, Float_t energy)
{
   fZbeam = z;
   fAbeam = a;
   fEbeam = energy;
}
#endif