PndMultiField Class Reference

#include <PndMultiField.h>

Inheritance diagram for PndMultiField:

Public Member Functions
	PndMultiField ()
	PndMultiField (TString Map, Double_t BeamMom=-1.)
	PndMultiField (PndMultiFieldPar *fieldPar)
virtual	~PndMultiField ()
void	Init ()
void	AddField (FairField *field)
TObjArray *	GetFieldList ()
void	FillParContainer ()
virtual void	Print ()
void	GetFieldValue (const Double_t point[3], Double_t *bField)

Protected Attributes
TObjArray *	fMaps
Int_t	fNoOfMaps
std::map< PndRegion *, FairField * >	fFieldMaps
std::map< PndRegion *, FairField * >::iterator	fMapIter
Double_t	fBeamMom

Private Member Functions
	PndMultiField (const PndMultiField &field)
PndMultiField &	operator= (const PndMultiField &)

Detailed Description

Definition at line 23 of file PndMultiField.h.

Constructor & Destructor Documentation

PndMultiField::PndMultiField

(

)

Default constructor

Definition at line 36 of file PndMultiField.cxx.

 : fMaps(new TObjArray(10)), fNoOfMaps(0), fFieldMaps(), fMapIter(), fBeamMom(0.)
{
      fType = 5;
}

PndMultiField::PndMultiField	(	TString	Map,
		Double_t	BeamMom = -1.
	)

Definition at line 44 of file PndMultiField.cxx.

References AddField(), fBeamMom, fRun, map_d1, map_d2, map_s1, map_s2, map_s3, map_s4, and map_t.

 : fMaps(new TObjArray(10)), fNoOfMaps(0), fFieldMaps(), fMapIter(), fBeamMom(BeamMom)
{
    fType = 5;
    if (BeamMom<0.)
        {
          FairRunSim *fRun= FairRunSim::Instance();
          if(fRun) fBeamMom= fRun->GetBeamMom();
        }
    
        Map.ToUpper();
        
        if (Map=="FULL") {
                
                PndTransMap *map_t= new PndTransMap("TransMap", "R", fBeamMom);
                PndDipoleMap *map_d1= new PndDipoleMap("DipoleMap1", "R", fBeamMom);
                PndDipoleMap *map_d2= new PndDipoleMap("DipoleMap2", "R", fBeamMom);
                PndSolenoidMap *map_s1= new PndSolenoidMap("SolenoidMap1", "R");
                PndSolenoidMap *map_s2= new PndSolenoidMap("SolenoidMap2", "R");
                PndSolenoidMap *map_s3= new PndSolenoidMap("SolenoidMap3", "R");
                PndSolenoidMap *map_s4= new PndSolenoidMap("SolenoidMap4", "R");
                
                AddField(map_t);
                AddField(map_d1);
                AddField(map_d2);
                AddField(map_s1);
                AddField(map_s2);
                AddField(map_s3);
                AddField(map_s4);
        
        }
  
        else if (Map=="AUTO") {
                PndDipoleMap *map_d1= new PndDipoleMap("DipoleMap1", "R", fBeamMom);
                PndDipoleMap *map_d2= new PndDipoleMap("DipoleMap2", "R", fBeamMom);

                PndTransMap *map_t;
                PndSolenoidMap *map_s1;
                PndSolenoidMap *map_s2;
                PndSolenoidMap *map_s3;
                PndSolenoidMap *map_s4;

                if(fBeamMom >= 3.0) {
                    map_t= new PndTransMap("TransMap", "R", fBeamMom);
                    map_s1= new PndSolenoidMap("SolenoidMap1", "R");
                    map_s2= new PndSolenoidMap("SolenoidMap2", "R");
                    map_s3= new PndSolenoidMap("SolenoidMap3", "R");
                    map_s4= new PndSolenoidMap("SolenoidMap4", "R");
                }
                else {
                   map_t= new PndTransMap("TransMap_Half", "R", fBeamMom);
                    map_s1= new PndSolenoidMap("SolenoidMap_Half1", "R");
                    map_s2= new PndSolenoidMap("SolenoidMap_Half2", "R");
                    map_s3= new PndSolenoidMap("SolenoidMap_Half3", "R");
                    map_s4= new PndSolenoidMap("SolenoidMap_Half4", "R");
                }
    
                AddField(map_t);
                AddField(map_d1);
                AddField(map_d2);
                AddField(map_s1);
                AddField(map_s2);
                AddField(map_s3);
                AddField(map_s4);
        }               

        else if (Map=="HALF") {         
                PndTransMap *map_t= new PndTransMap("TransMap_Half", "R", fBeamMom);
                PndDipoleMap *map_d1= new PndDipoleMap("DipoleMap1", "R", fBeamMom);
                PndDipoleMap *map_d2= new PndDipoleMap("DipoleMap2", "R", fBeamMom);
                PndSolenoidMap *map_s1= new PndSolenoidMap("SolenoidMap_Half1", "R");
                PndSolenoidMap *map_s2= new PndSolenoidMap("SolenoidMap_Half2", "R");
                PndSolenoidMap *map_s3= new PndSolenoidMap("SolenoidMap_Half3", "R");
                PndSolenoidMap *map_s4= new PndSolenoidMap("SolenoidMap_Half4", "R");
                
                AddField(map_t);
                AddField(map_d1);
                AddField(map_d2);
                AddField(map_s1);
                AddField(map_s2);
                AddField(map_s3);
                AddField(map_s4);
        
        }
        
        
        else if (Map=="DIPOLE") {
                PndDipoleMap *map_d1= new PndDipoleMap("DipoleMap1", "R", fBeamMom);
                PndDipoleMap *map_d2= new PndDipoleMap("DipoleMap2", "R", fBeamMom);
                
                AddField(map_d1);
                AddField(map_d2);
                
        }else if (Map=="SOLENOID") {
                
                PndSolenoidMap *map_s1= new PndSolenoidMap("SolenoidMap1", "R");
                PndSolenoidMap *map_s2= new PndSolenoidMap("SolenoidMap2", "R");
                PndSolenoidMap *map_s3= new PndSolenoidMap("SolenoidMap3", "R");
                PndSolenoidMap *map_s4= new PndSolenoidMap("SolenoidMap4", "R");
                
                AddField(map_s1);
                AddField(map_s2);
                AddField(map_s3);
                AddField(map_s4);
        }
        else if (Map=="SOLENOID_HALF") {
                

                PndSolenoidMap *map_s1= new PndSolenoidMap("SolenoidMap_Half1", "R");
                PndSolenoidMap *map_s2= new PndSolenoidMap("SolenoidMap_Half2", "R");
                PndSolenoidMap *map_s3= new PndSolenoidMap("SolenoidMap_Half3", "R");
                PndSolenoidMap *map_s4= new PndSolenoidMap("SolenoidMap_Half4", "R");

                AddField(map_s1);
                AddField(map_s2);
                AddField(map_s3);
                AddField(map_s4);
        }

        

}

PndMultiField::PndMultiField

(

PndMultiFieldPar *

fieldPar

)

Constructor from PndFieldPar

Definition at line 173 of file PndMultiField.cxx.

References PndMultiFieldPar::GetParArray().

 : fMaps( new TObjArray(10)), fNoOfMaps(0), fFieldMaps(), fMapIter(), fBeamMom(0.)
{
   fType = 5;
   TObjArray *fArray= fieldPar->GetParArray();
   if(fArray->IsEmpty()) fType=-1;

}

PndMultiField::~PndMultiField ( )

virtual

Destructor

Definition at line 190 of file PndMultiField.cxx.

References fMaps.

                              {
        
        //printf("PndMultiField::~PndMultiField() \n");
        fMaps->Delete();
        delete fMaps;
        
}

PndMultiField::PndMultiField ( const PndMultiField &  field )

private

Definition at line 183 of file PndMultiField.cxx.

                                                       : FairField(), fMaps(field.fMaps), fNoOfMaps(field.fNoOfMaps), fFieldMaps(field.fFieldMaps), fMapIter(field.fMapIter), fBeamMom(field.fBeamMom)
{
  fType = field.fType;
}

Member Function Documentation

void PndMultiField::AddField

(

FairField *

field

)

Adding a field to the collection

Definition at line 199 of file PndMultiField.cxx.

References fMaps, and fNoOfMaps.

Referenced by PndFieldCreator::createFairField(), emc(), gem_urqmd_sim(), PndMultiField(), QAmacro_mdt_1(), run0AllSysDPMbkg(), run_sim(), run_sim_tpcmvd(), runGeaneTestSimBox(), runGemSim(), runLumi0DPMbkg(), runLumiSimBox(), runMC(), runsim(), sim_emc_test(), sim_gg(), sim_muo_test(), and visualize_fieldmaps().

                                            {
        
   if(field){
      fMaps->AddLast(field);    
      fNoOfMaps++;
   }

}

void PndMultiField::FillParContainer

(

)

Definition at line 239 of file PndMultiField.cxx.

References fRun, Par, rtdb, and PndMultiFieldPar::SetParameters().

                                     {  
// for (Int_t n=0; n<=fNoOfMaps; n++){
//      FairField *fieldMap = dynamic_cast<FairField *>(fMaps->At(n));
//      if(fieldMap) fieldMap->FillParContainer();
//  }
  FairRun *fRun=FairRun::Instance();    
  FairRuntimeDb *rtdb=fRun->GetRuntimeDb();
  //Bool_t kParameterMerged=kTRUE;
  PndMultiFieldPar* Par = (PndMultiFieldPar*) rtdb->getContainer("PndMultiFieldPar");
  Par->SetParameters(this);
  Par->setInputVersion(fRun->GetRunId(),1);
  Par->setChanged();
        
        
        
}

TObjArray* PndMultiField::GetFieldList ( )

inline

Definition at line 46 of file PndMultiField.h.

References fMaps.

Referenced by PndFieldPar::SetParameters(), and PndMultiFieldPar::SetParameters().

{return fMaps; }

void PndMultiField::GetFieldValue	(	const Double_t	point[3],
		Double_t *	bField
	)

Get magnetic field. For use of GEANT3

Parameters

point	Coordinates [cm]
bField	(return) Field components [kG]

Definition at line 257 of file PndMultiField.cxx.

References fField, fFieldMaps, fMapIter, and PndRegion::IsInside().

Referenced by DrawField(), MakeHoughParabolaFitwithBfield(), PlotMCTracksPrintBField(), and visualize_fieldmaps().

{
  
   PndRegion *fReg=0;
   FairField *fField=0;
   for (fMapIter=fFieldMaps.begin(); fMapIter!= fFieldMaps.end();fMapIter++ ){
      fReg=fMapIter->first;
      if(fReg->IsInside(point[2])){
         fField=fMapIter->second;
         break;
      }
   }
  if(fField){
    fField->GetBxyz(point, bField);
  }else{
    bField[0] = 0;
    bField[1] = 0;
    bField[2] = 0;

  }
}

void PndMultiField::Init

(

)

Initialisation (read map from file)

Definition at line 209 of file PndMultiField.cxx.

References fFieldMaps, fMaps, fNoOfMaps, PndConstField::GetZmax(), PndFieldMap::GetZmax(), PndConstField::GetZmin(), PndFieldMap::GetZmin(), PndFieldMap::Init(), and n.

Referenced by PndFieldCreator::createFairField(), DrawField(), plotTrackCands(), and visualize_fieldmaps().

                         {
   PndConstField *field=0;
   PndFieldMap *fieldMap=0;
   for (Int_t n=0; n<=fNoOfMaps; n++){
      fieldMap = dynamic_cast<PndFieldMap *>(fMaps->At(n));
      field = dynamic_cast<PndConstField *>(fMaps->At(n));
      if(fieldMap){
         fieldMap->Init();
         fFieldMaps.insert( pair<PndRegion*, FairField*>(new PndRegion(fieldMap->GetZmin(),fieldMap->GetZmax()) , fieldMap ));
      }else if(field){
         field->Init();
         fFieldMaps.insert( pair<PndRegion*, FairField*>(new PndRegion(field->GetZmin(),field->GetZmax() ), field ));
      }
   }

}

PndMultiField& PndMultiField::operator= ( const PndMultiField &  )

inlineprivate

Definition at line 61 of file PndMultiField.h.

{return *this;};

void PndMultiField::Print ( )

virtual

Screen output

Definition at line 227 of file PndMultiField.cxx.

References fMaps, fNoOfMaps, and n.

                          {  
        for (Int_t n=0; n<=fNoOfMaps; n++){
                FairField *fieldMap = dynamic_cast<FairField *>(fMaps->At(n));
                if(fieldMap) fieldMap->Print("");
        }
}

Member Data Documentation

Double_t PndMultiField::fBeamMom

protected

Definition at line 69 of file PndMultiField.h.

Referenced by PndMultiField().

std::map<PndRegion*, FairField* > PndMultiField::fFieldMaps

protected

Definition at line 67 of file PndMultiField.h.

Referenced by GetFieldValue(), and Init().

std::map<PndRegion*, FairField* >::iterator PndMultiField::fMapIter

protected

Definition at line 68 of file PndMultiField.h.

Referenced by GetFieldValue().

TObjArray* PndMultiField::fMaps

protected

Definition at line 61 of file PndMultiField.h.

Referenced by AddField(), GetFieldList(), Init(), Print(), and ~PndMultiField().

Int_t PndMultiField::fNoOfMaps

protected

Definition at line 66 of file PndMultiField.h.

Referenced by AddField(), Init(), and Print().

---

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

• PndMultiField.h
• PndMultiField.cxx