G4ChannelingECHARM Class Reference

#include <G4ChannelingECHARM.hh>

Public Member Functions
	G4ChannelingECHARM (const G4String &, G4double)
	~G4ChannelingECHARM ()
G4double	GetEC (G4ThreeVector &)
virtual void	ReadFromECHARM (const G4String &, G4double)
G4double	GetMax ()
G4double	GetMin ()
G4double	GetMaxMin ()
G4double	GetIntSp (G4int index)

Detailed Description

Definition at line 34 of file G4ChannelingECHARM.hh.

Constructor & Destructor Documentation

G4ChannelingECHARM()

G4ChannelingECHARM::G4ChannelingECHARM	(	const G4String &	fileName,
		G4double	vConversion )

Definition at line 32 of file G4ChannelingECHARM.cc.

                                                                                   :
fVectorEC(0),
fDistances{0.,0.,0.},
fPoints{0,0,0},
fMaximum(-DBL_MAX),
fMinimum(DBL_MAX){
    fDistances[0] = 0;
    fDistances[1] = 0;
    fDistances[2] = 0;
    fPoints[0] = 0;
    fPoints[1] = 0;
    fPoints[2] = 0;
    fVectorEC2D = 0;
    ReadFromECHARM(fileName,vConversion);
}

~G4ChannelingECHARM()

G4ChannelingECHARM::~G4ChannelingECHARM

(

)

Definition at line 49 of file G4ChannelingECHARM.cc.

                                       {
     delete(fVectorEC);
     delete(fVectorEC2D);
}

Member Function Documentation

GetEC()

G4double G4ChannelingECHARM::GetEC

(

G4ThreeVector &

vPosition

)

Definition at line 56 of file G4ChannelingECHARM.cc.

                                                          {
    G4double vX = vPosition.x();
    if (vX < 0.0) {
        vX += ((int( - vX / fDistances[0]) + 1.0 ) * fDistances[0]);
    }
    else if( vX > fDistances[0] ){
        vX -= ( int( vX / fDistances[0]) * fDistances[0] );
    }
    if(fPoints[1]==1){
        return fVectorEC->Value(vX);
    }
    else{
        G4double vY = vPosition.y();
        if (vY < 0.0) {
            vY += ((int( - vY / fDistances[1]) + 1.0 ) * fDistances[1]);
        }
        else if( vY > fDistances[1] ){
            vY -= ( int( vY / fDistances[1]) * fDistances[1] );
        }
        return fVectorEC2D->Value((vX),(vY));
    }
}

GetIntSp()

G4double G4ChannelingECHARM::GetIntSp ( G4int index )

inline

Definition at line 49 of file G4ChannelingECHARM.hh.

{return fDistances[index];};

GetMax()

G4double G4ChannelingECHARM::GetMax ( )

inline

Definition at line 45 of file G4ChannelingECHARM.hh.

{return fMaximum;};

GetMaxMin()

G4double G4ChannelingECHARM::GetMaxMin ( )

inline

Definition at line 47 of file G4ChannelingECHARM.hh.

{return std::fabs(fMaximum-fMinimum);};

GetMin()

G4double G4ChannelingECHARM::GetMin ( )

inline

Definition at line 46 of file G4ChannelingECHARM.hh.

{return fMinimum;};

ReadFromECHARM()

void G4ChannelingECHARM::ReadFromECHARM ( const G4String & filename, G4double vConversion )

virtual

Definition at line 81 of file G4ChannelingECHARM.cc.

                                                             {
    std::ifstream vFileIn;
    vFileIn.open(filename);
    
    vFileIn >> fPoints[0] >> fPoints[1] >> fPoints[2];
    vFileIn >> fDistances[0] >> fDistances[1] >> fDistances[2];
 
    fDistances[0] *= CLHEP::meter;
    fDistances[1] *= CLHEP::meter;
    fDistances[2] *= CLHEP::meter;
    fMaximum = -DBL_MAX;
    fMinimum = +DBL_MAX;
 
    if(fPoints[1]<1){
        G4ExceptionDescription ed;
        ed << "No Points not found !" << G4endl;
        G4Exception("G4ChannelingECHARM::ReadFromECHARM(...)",
                  "G4ChannelingECHARM",
                  FatalException,
                  ed);
        return;
    }
    else if(fPoints[1]==1){
        fVectorEC = new G4PhysicsLinearVector(0,fDistances[0],fPoints[0]);
    }
    else{
        fVectorEC2D = new G4Physics2DVector(fPoints[0],fPoints[1]);
    }
    G4double stepX = fDistances[0]/fPoints[0];
    G4double stepY = fDistances[1]/fPoints[1];
    for(G4int i1=0;i1<fPoints[1]; i1++){
        if(fPoints[1]>1){
            fVectorEC2D->PutY(i1,i1*stepY);
        }
        for(G4int i0=0;i0<fPoints[0]; i0++){
        double vTempX;
        vFileIn >> vTempX;
 
        vTempX *= vConversion;
        if(vTempX > fMaximum) {fMaximum = vTempX;}
        if(vTempX < fMinimum) {fMinimum = vTempX;}
        if(fPoints[1]==1){
            fVectorEC->PutValue(i0,vTempX);
        }
        else{
            fVectorEC2D->PutValue(i0,i1,vTempX);
            fVectorEC2D->PutX(i0,i0*stepX);
        }
    }
    }
    G4cout << "G4ChannelingECHARM::ReadFromECHARM() - " << vConversion << " " << fPoints[0] << " " << fDistances[0] << " " << fPoints[1] << " " << fDistances[1] << " " << fMinimum << " " << fMaximum << G4endl;
 
    vFileIn.close();
    
}

Referenced by G4ChannelingECHARM().

---

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

• G4ChannelingECHARM.hh
• G4ChannelingECHARM.cc