#include <PndFieldCreator.h>

Inheritance diagram for PndFieldCreator:

Public Member Functions
	PndFieldCreator ()

virtual	~PndFieldCreator ()

virtual FairField *	createFairField ()

virtual void	SetParm ()

Protected Attributes
PndFieldPar *	fFieldPar

PndSolenoidPar *	fSPar

PndDipolePar *	fDPar

PndTransPar *	fTPar

PndConstPar *	fCPar

PndMultiFieldPar *	fMPar

Private Member Functions
	PndFieldCreator (const PndFieldCreator &L)

PndFieldCreator &	operator= (const PndFieldCreator &)

	ClassDef (PndFieldCreator, 1)

Detailed Description

Definition at line 20 of file PndFieldCreator.h.

Constructor & Destructor Documentation

PndFieldCreator::PndFieldCreator ( )

Definition at line 31 of file PndFieldCreator.cxx.

         :FairFieldFactory(),
      fFieldPar(0),
      fSPar(0),
      fDPar(0),
      fTPar(0),
      fCPar(0),
      fMPar(0)
     
 {
         fCreator=this;
  
 }

PndFieldCreator::~PndFieldCreator ( )

virtual

Definition at line 58 of file PndFieldCreator.cxx.

59 {

60 }

PndFieldCreator::PndFieldCreator ( const PndFieldCreator & L )

private

Definition at line 45 of file PndFieldCreator.cxx.

         :FairFieldFactory(),
      fFieldPar(L.fFieldPar),
      fSPar(L.fSPar),
      fDPar(L.fDPar),
      fTPar(L.fTPar),
      fCPar(L.fCPar),
      fMPar(L.fMPar)
     
 {
   fCreator = L.fCreator;
 }

Member Function Documentation

PndFieldCreator::ClassDef	(	PndFieldCreator	,
		1
	)

private

FairField * PndFieldCreator::createFairField ( )

virtual

Definition at line 96 of file PndFieldCreator.cxx.

References PndMultiField::AddField(), Bool_t, fCPar, fDPar, fFieldPar, fMPar, fSPar, fTPar, PndMultiFieldPar::GetParArray(), PndFieldPar::GetType(), PndMapPar::GetType(), and PndMultiField::Init().

 {       
         //cout << "PndFieldCreator::createFairField()" <<endl;
     FairField *fMagneticField=0;
         PndMultiField *MField=0;
         Int_t Type=-1;
     Bool_t multi=kFALSE;
         if (fMPar) {
            MField = new PndMultiField(fMPar);
            Type= fMPar->GetType();
         }
         if (Type==-1) {delete MField; MField=0;}
         
         if(MField) {
                 multi=kTRUE;
                 TObjArray *fParArray=fMPar->GetParArray();
                 TIterator *Iter=fParArray->MakeIterator();
                 Iter->Reset();
                 PndMapPar* fPar = NULL;
                 while( (fPar = (PndMapPar*)Iter->Next() ) ) {
                         fPar->Print();
                         if (fPar->GetType()==0){
                                 FairField *fField1 = new PndConstField((PndConstPar*)fPar);
                                 MField->AddField(fField1);
                         }
                         if (fPar->GetType()==1){
                                 FairField *fField2 = new PndFieldMap((PndFieldPar*)fPar);
                                 MField->AddField(fField2);
                         }
                         if (fPar->GetType()==2){
                                 FairField *fField3 = new PndSolenoidMap((PndSolenoidPar*)fPar);
                                 MField->AddField(fField3);
                         }
                         if (fPar->GetType()==3){
                                 FairField *fField4 = new PndDipoleMap((PndDipolePar*)fPar);
                                 MField->AddField(fField4);
                         }
                         if (fPar->GetType()==4){
                                 FairField *fField5 = new PndTransMap((PndTransPar*)fPar);
                                 MField->AddField(fField5);
                         }
                 }
         }
 
         if (fCPar) {
            FairField *fField1 = new PndConstField(fCPar);
            Type= fCPar->GetType();
            if (Type==-1) {delete fField1; fField1=0;}
            if(fField1)fMagneticField=fField1;   
         }
         if(fFieldPar){
            FairField *fField2 = new PndFieldMap(fFieldPar);
            Type= fFieldPar->GetType();
            if (Type==-1){delete fField2; fField2=0;}
            if(fField2)fMagneticField=fField2;   
     }
         if(fSPar){
            FairField *fField3 = new PndSolenoidMap(fSPar);
            Type= fSPar->GetType();
            if (Type==-1) {delete fField3; fField3=0;}
            if(fField3)fMagneticField=fField3;
         }
         if(fDPar){
            FairField *fField4 = new PndDipoleMap(fDPar);
            Type= fDPar->GetType();
            if (Type==-1) {delete fField4; fField4=0;}
            if(fField4)fMagneticField=fField4;   
     }
         if(fTPar){
            FairField *fField5 = new PndTransMap(fTPar);
            Type= fTPar->GetType();
            if (Type==-1){delete fField5; fField5=0;}
            if(fField5)fMagneticField=fField5;   
     }
         
         if (multi) {
                 MField->Init();
                 return MField;
         }else{
         if(fMagneticField){
                 fMagneticField->Init();  
                 }
                 return fMagneticField;
         }
 }

PndFieldCreator& PndFieldCreator::operator= ( const PndFieldCreator & )

inlineprivate

Definition at line 29 of file PndFieldCreator.h.

29 {return *this;};

void PndFieldCreator::SetParm ( )

virtual

Definition at line 61 of file PndFieldCreator.cxx.

References fCPar, fDPar, fFieldPar, fMPar, fSPar, fTPar, par, and Run().

 {
  
 //  cout << "PndFieldCreator::SetParm()" <<endl;
   FairRun *Run = FairRun::Instance();
   FairRuntimeDb *RunDB = Run->GetRuntimeDb();
   
   FairBaseParSet* par=(FairBaseParSet*)(RunDB->getContainer("FairBaseParSet"));
  
   TObjArray *contList= par->GetContList();
   TObject *obj=0;
   if (contList) {
           obj=contList->FindObject("PndMultiFieldPar");
   } 
 
   cout << "PndFieldCreator::SetParm() " << obj  <<endl;
 
         
   if (obj) {
          fMPar = (PndMultiFieldPar*)RunDB->getContainer("PndMultiFieldPar");
   }else if (contList->FindObject("PndFieldPar")) {
           fFieldPar = (PndFieldPar*) RunDB->getContainer("PndFieldPar");
   }else if (contList->FindObject("PndSolenoidPar")) {
           fSPar = (PndSolenoidPar*) RunDB->getContainer("PndSolenoidPar");
   }else if (contList->FindObject("PndDipolePar")) {
           fDPar = (PndDipolePar*) RunDB->getContainer("PndDipolePar");
   }else if (contList->FindObject("PndTransPar")) {
           fTPar = (PndTransPar*) RunDB->getContainer("PndTransPar");
   }else if (contList->FindObject("PndConstPar")) {
           fCPar = (PndConstPar*) RunDB->getContainer("PndConstPar");
   }
         
  
 }