CexmcSetup Class Reference

#include <CexmcSetup.hh>

Inheritance diagram for CexmcSetup:

Collaboration diagram for CexmcSetup:

Classes
struct	CalorimeterGeometryData

Public Types
enum	SpecialVolumeType { Monitor, VetoCounter, Calorimeter, Target }

Public Member Functions
	CexmcSetup (const G4String &gdmlFile="default.gdml", G4bool validateGDMLFile=true)
G4VPhysicalVolume *	Construct (void)
const G4AffineTransform &	GetTargetTransform (void) const
const G4AffineTransform &	GetCalorimeterLeftTransform (void) const
const G4AffineTransform &	GetCalorimeterRightTransform (void) const
void	ConvertToCrystalGeometry (const G4ThreeVector &src, G4int &row, G4int &column, G4ThreeVector &dst) const
const CalorimeterGeometryData &	GetCalorimeterGeometry (void) const
const G4LogicalVolume *	GetVolume (SpecialVolumeType volume) const
G4bool	IsRightDetector (const G4VPhysicalVolume *pVolume) const
G4bool	IsRightCalorimeter (const G4VPhysicalVolume *pVolume) const
Public Member Functions inherited from G4VUserDetectorConstruction
	G4VUserDetectorConstruction ()
virtual	~G4VUserDetectorConstruction ()
virtual void	ConstructSDandField ()
virtual void	CloneSD ()
virtual void	CloneF ()
void	RegisterParallelWorld (G4VUserParallelWorld *)
G4int	ConstructParallelGeometries ()
void	ConstructParallelSD ()
G4int	GetNumberOfParallelWorld () const
G4VUserParallelWorld *	GetParallelWorld (G4int i) const

Private Member Functions
void	SetupSpecialVolumes (const G4GDMLParser &gdmlParser)
void	ReadTransforms (const G4GDMLParser &gdmlParser)
void	ReadCalorimeterGeometryData (const G4LogicalVolume *lVolume)
void	ReadRightDetectors (void)

Static Private Member Functions
static void	AssertAndAsignDetectorRole (CexmcDetectorRole &detectorRole, CexmcDetectorRole value)
static void	RotateMatrix (const G4ThreeVector &pos, G4RotationMatrix &rm)

Private Attributes
G4VPhysicalVolume *	world
G4String	gdmlFile
G4bool	validateGDMLFile
G4bool	calorimeterRegionInitialized
G4bool	calorimeterGeometryDataInitialized
G4LogicalVolume *	monitorVolume
G4LogicalVolume *	vetoCounterVolume
G4LogicalVolume *	calorimeterVolume
G4LogicalVolume *	targetVolume
G4VPhysicalVolume *	rightVetoCounter
G4VPhysicalVolume *	rightCalorimeter
G4AffineTransform	targetTransform
G4AffineTransform	calorimeterLeftTransform
G4AffineTransform	calorimeterRightTransform
CalorimeterGeometryData	calorimeterGeometry

Additional Inherited Members
Protected Member Functions inherited from G4VUserDetectorConstruction
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)
void	SetSensitiveDetector (G4LogicalVolume *logVol, G4VSensitiveDetector *aSD)

Detailed Description

Definition at line 59 of file CexmcSetup.hh.

Member Enumeration Documentation

SpecialVolumeType

enum CexmcSetup::SpecialVolumeType

Enumerator
Monitor
VetoCounter
Calorimeter
Target

Definition at line 62 of file CexmcSetup.hh.

        {
            Monitor,
            VetoCounter,
            Calorimeter,
            Target
        };

Constructor & Destructor Documentation

CexmcSetup()

CexmcSetup::CexmcSetup ( const G4String &  gdmlFile = "default.gdml", G4bool  validateGDMLFile = true  )

explicit

Definition at line 71 of file CexmcSetup.cc.

                                                                             :
    world( 0 ), gdmlFile( gdmlFile ), validateGDMLFile( validateGDMLFile ),
    calorimeterRegionInitialized( false ),
    calorimeterGeometryDataInitialized( false ), monitorVolume( NULL ),
    vetoCounterVolume( NULL ), calorimeterVolume( NULL ), targetVolume( NULL ),
    rightVetoCounter( NULL ), rightCalorimeter( NULL )
{
}

Member Function Documentation

AssertAndAsignDetectorRole()

void CexmcSetup::AssertAndAsignDetectorRole ( CexmcDetectorRole &  detectorRole, CexmcDetectorRole  value  )

staticprivate

Definition at line 474 of file CexmcSetup.cc.

{
    if ( detectorRole != CexmcNumberOfDetectorRoles && detectorRole != value )
        throw CexmcException( CexmcMultipleDetectorRoles );

    detectorRole = value;
}

Here is the caller graph for this function:

Construct()

G4VPhysicalVolume * CexmcSetup::Construct ( void  )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 81 of file CexmcSetup.cc.

{
    if ( world )
        return world;

    G4GDMLParser  gdmlParser;

    gdmlParser.Read( gdmlFile, validateGDMLFile );
    world = gdmlParser.GetWorldVolume();

    SetupSpecialVolumes( gdmlParser );

    ReadTransforms( gdmlParser );

    ReadRightDetectors();

    CexmcRunManager *  runManager( static_cast< CexmcRunManager * >(
                                            G4RunManager::GetRunManager() ) );

    runManager->SetupConstructionHook();

    const CexmcPhysicsManager *  physicsManager(
            dynamic_cast< const CexmcPhysicsManager * >(
                                        runManager->GetUserPhysicsList() ) );

    if ( ! physicsManager )
        throw CexmcException( CexmcWeirdException );

    CexmcPhysicsManager *        thePhysicsManager(
            const_cast< CexmcPhysicsManager * >( physicsManager ) );
    thePhysicsManager->SetupConstructionHook( this );

    return world;
}

Here is the call graph for this function:

ConvertToCrystalGeometry()

void CexmcSetup::ConvertToCrystalGeometry	(	const G4ThreeVector &	src,
		G4int &	row,
		G4int &	column,
		G4ThreeVector &	dst
	)		const

Definition at line 417 of file CexmcSetup.cc.

{
    G4int     nCrystalsInColumn( calorimeterGeometry.nCrystalsInColumn );
    G4int     nCrystalsInRow( calorimeterGeometry.nCrystalsInRow );
    G4double  crystalWidth( calorimeterGeometry.crystalWidth );
    G4double  crystalHeight( calorimeterGeometry.crystalHeight );

    row = G4int( ( src.y() + crystalHeight * nCrystalsInColumn / 2 ) /
                 crystalHeight );
    column = G4int( ( src.x() + crystalWidth * nCrystalsInRow / 2 ) /
                    crystalWidth );
    G4double   xInCalorimeterOffset(
                    ( G4double( column ) - G4double( nCrystalsInRow ) / 2 ) *
                                            crystalWidth + crystalWidth / 2 );
    G4double   yInCalorimeterOffset(
                    ( G4double( row ) - G4double( nCrystalsInColumn ) / 2 ) *
                                            crystalHeight + crystalHeight / 2 );
    dst.setX( src.x() - xInCalorimeterOffset );
    dst.setY( src.y() - yInCalorimeterOffset );
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCalorimeterGeometry()

const CexmcSetup::CalorimeterGeometryData & CexmcSetup::GetCalorimeterGeometry ( void  ) const

inline

Definition at line 182 of file CexmcSetup.hh.

{
    return calorimeterGeometry;
}

Here is the caller graph for this function:

GetCalorimeterLeftTransform()

const G4AffineTransform & CexmcSetup::GetCalorimeterLeftTransform ( void  ) const

inline

Definition at line 167 of file CexmcSetup.hh.

{
    return calorimeterLeftTransform;
}

Here is the caller graph for this function:

GetCalorimeterRightTransform()

const G4AffineTransform & CexmcSetup::GetCalorimeterRightTransform ( void  ) const

inline

Definition at line 174 of file CexmcSetup.hh.

{
    return calorimeterRightTransform;
}

Here is the caller graph for this function:

GetTargetTransform()

const G4AffineTransform & CexmcSetup::GetTargetTransform ( void  ) const

inline

Definition at line 161 of file CexmcSetup.hh.

{
    return targetTransform;
}

Here is the caller graph for this function:

GetVolume()

const G4LogicalVolume * CexmcSetup::GetVolume ( SpecialVolumeType  volume ) const

inline

Definition at line 188 of file CexmcSetup.hh.

{
    switch ( volume )
    {
    case Monitor :
        return monitorVolume;
    case VetoCounter :
        return vetoCounterVolume;
    case Calorimeter :
        return calorimeterVolume;
    case Target :
        return targetVolume;
    default :
        return NULL;
    }
}

Here is the caller graph for this function:

IsRightCalorimeter()

G4bool CexmcSetup::IsRightCalorimeter ( const G4VPhysicalVolume *  pVolume ) const

inline

Definition at line 217 of file CexmcSetup.hh.

{
    if ( pVolume == rightCalorimeter )
        return true;

    return false;
}

Here is the caller graph for this function:

IsRightDetector()

G4bool CexmcSetup::IsRightDetector ( const G4VPhysicalVolume *  pVolume ) const

inline

Definition at line 207 of file CexmcSetup.hh.

{
    if ( pVolume == rightVetoCounter || pVolume == rightCalorimeter )
        return true;

    return false;
}

Here is the caller graph for this function:

ReadCalorimeterGeometryData()

void CexmcSetup::ReadCalorimeterGeometryData ( const G4LogicalVolume *  lVolume )

private

Definition at line 363 of file CexmcSetup.cc.

{
    if ( lVolume->GetNoDaughters() == 0 )
        throw CexmcException( CexmcIncompatibleGeometry );

    G4VPhysicalVolume *  pVolume( lVolume->GetDaughter( 0 ) );
    EAxis                axis;
    G4double             width;
    G4double             offset;
    G4bool               consuming;

    if ( ! pVolume )
        throw CexmcException( CexmcIncompatibleGeometry );

    if ( pVolume->IsReplicated() )
    {
        pVolume->GetReplicationData( axis,
                                     calorimeterGeometry.nCrystalsInColumn,
                                     width, offset, consuming );
    }

    lVolume = pVolume->GetLogicalVolume();

    if ( lVolume->GetNoDaughters() == 0 )
        throw CexmcException( CexmcIncompatibleGeometry );

    pVolume = lVolume->GetDaughter( 0 );

    if ( ! pVolume )
        throw CexmcException( CexmcIncompatibleGeometry );

    if ( pVolume->IsReplicated() )
    {
        pVolume->GetReplicationData( axis, calorimeterGeometry.nCrystalsInRow,
                                     width, offset, consuming );
    }

    lVolume = pVolume->GetLogicalVolume();

    /* NB: this is not necessarily a crystal itself as far as crystals can be
     * wrapped in paper and other materials, but this is what reconstructor and
     * digitizers really need */
    G4Box *  crystalBox( dynamic_cast< G4Box * >( lVolume->GetSolid() ) );

    if ( ! crystalBox )
        throw CexmcException( CexmcIncompatibleGeometry );

    calorimeterGeometry.crystalWidth = crystalBox->GetXHalfLength() * 2;
    calorimeterGeometry.crystalHeight = crystalBox->GetYHalfLength() * 2;
    calorimeterGeometry.crystalLength = crystalBox->GetZHalfLength() * 2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadRightDetectors()

void CexmcSetup::ReadRightDetectors ( void  )

private

Definition at line 440 of file CexmcSetup.cc.

{
    G4PhysicalVolumeStore *  pvs( G4PhysicalVolumeStore::GetInstance() );

    for ( std::vector< G4VPhysicalVolume * >::const_iterator  k( pvs->begin() );
                                                        k != pvs->end(); ++k )
    {
        /* FIXME: it would be more reasonable to find detectors from volumes
         * tagged with 'EnergyDepositDetector' or 'TrackPointsDetector', and not
         * from volumes tagged with 'SpecialVolume' as it is done here. However
         * in case of calorimeters the role of detectors are played by crystal
         * volumes, not the calorimeters themselves, but only calorimeters can
         * hold information about their left or right positions! Thus, following
         * considerations of convenience, right detectors for all detector roles
         * are chosen from volumes tagged with 'SpecialVolume' */
        do
        {
            if ( ( *k )->GetLogicalVolume() == vetoCounterVolume )
            {
                if ( ( *k )->GetName().contains( "Right" ) )
                    rightVetoCounter = *k;
                break;
            }
            if ( ( *k )->GetLogicalVolume() == calorimeterVolume )
            {
                if ( ( *k )->GetName().contains( "Right" ) )
                    rightCalorimeter = *k;
                break;
            }
        } while ( false );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadTransforms()

void CexmcSetup::ReadTransforms ( const G4GDMLParser &  gdmlParser )

private

Definition at line 337 of file CexmcSetup.cc.

{
    G4ThreeVector     position( gdmlParser.GetPosition( "TargetPos" ) );
    G4ThreeVector     rotation( gdmlParser.GetRotation( "TargetRot" ) );
    G4RotationMatrix  rm;

    RotateMatrix( rotation, rm );
    targetTransform.SetNetTranslation( position );
    targetTransform.SetNetRotation( rm );

    position = gdmlParser.GetPosition( "CalorimeterLeftPos" );
    rotation = gdmlParser.GetRotation( "CalorimeterLeftRot" );
    rm = G4RotationMatrix();
    RotateMatrix( rotation, rm );
    calorimeterLeftTransform.SetNetTranslation( position );
    calorimeterLeftTransform.SetNetRotation( rm );

    position = gdmlParser.GetPosition( "CalorimeterRightPos" );
    rotation = gdmlParser.GetRotation( "CalorimeterRightRot" );
    rm = G4RotationMatrix();
    RotateMatrix( rotation, rm );
    calorimeterRightTransform.SetNetTranslation( position );
    calorimeterRightTransform.SetNetRotation( rm );
}

Here is the call graph for this function:

Here is the caller graph for this function:

RotateMatrix()

void CexmcSetup::RotateMatrix ( const G4ThreeVector &  pos, G4RotationMatrix &  rm  )

staticprivate

Definition at line 484 of file CexmcSetup.cc.

{
    rm.rotateX( rot.x() );
    rm.rotateY( rot.y() );
    rm.rotateZ( rot.z() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetupSpecialVolumes()

void CexmcSetup::SetupSpecialVolumes ( const G4GDMLParser &  gdmlParser )

private

Definition at line 117 of file CexmcSetup.cc.

{
    G4MultiFunctionalDetector *   detector[ CexmcNumberOfDetectorRoles ] =
                                                                    { NULL };
    const G4LogicalVolumeStore *  lvs( G4LogicalVolumeStore::GetInstance() );

    for ( std::vector< G4LogicalVolume * >::const_iterator
                        lvIter( lvs->begin() ); lvIter != lvs->end(); ++lvIter )
    {
        G4String           volumeName( G4String( ( *lvIter )->GetName() ) );
        G4GDMLAuxListType  auxInfo( gdmlParser.GetVolumeAuxiliaryInformation(
                                                                    *lvIter ) );
        CexmcDetectorRole  curDetectorRole( CexmcNumberOfDetectorRoles );

        for ( G4GDMLAuxListType::const_iterator  pair( auxInfo.begin() );
                                              pair != auxInfo.end(); ++pair )
        {
            CexmcPrimitiveScorer *  scorer( NULL );
            G4String                detectorName( "uninitialized" );
            do
            {
                if ( pair->type == "EnergyDepositDetector" )
                {
                    do
                    {
                        if ( pair->value == "MonitorRole" )
                        {
                            AssertAndAsignDetectorRole( curDetectorRole,
                                                CexmcMonitorDetectorRole );
                            scorer = new CexmcSimpleEnergyDeposit(
                                    CexmcDetectorTypeName[ CexmcEDDetector ] );
                            break;
                        }
                        if ( pair->value == "VetoCounterRole" )
                        {
                            AssertAndAsignDetectorRole( curDetectorRole,
                                                CexmcVetoCounterDetectorRole );
                            scorer = new CexmcEnergyDepositInLeftRightSet(
                                    CexmcDetectorTypeName[ CexmcEDDetector ],
                                    this );
                            break;
                        }
                        if ( pair->value == "CalorimeterRole" )
                        {
                            AssertAndAsignDetectorRole( curDetectorRole,
                                                CexmcCalorimeterDetectorRole );
                            scorer = new CexmcEnergyDepositInCalorimeter(
                                    CexmcDetectorTypeName[ CexmcEDDetector ],
                                    this );
                            break;
                        }
                    } while ( false );
                    detectorName = CexmcDetectorRoleName[ curDetectorRole ];
                    G4cout << CEXMC_LINE_START "ED Scorer of detector role '" <<
                               detectorName << "' in volume '" << volumeName <<
                               "'" << G4endl;
                    break;
                }
                if ( pair->type == "TrackPointsDetector" )
                {
                    do
                    {
                        if ( pair->value == "MonitorRole" )
                        {
                            AssertAndAsignDetectorRole( curDetectorRole,
                                                CexmcMonitorDetectorRole );
                            scorer = new CexmcTrackPoints(
                                    CexmcDetectorTypeName[ CexmcTPDetector ] );
                            break;
                        }
                        if ( pair->value == "VetoCounterRole"  )
                        {
                            AssertAndAsignDetectorRole( curDetectorRole,
                                                CexmcVetoCounterDetectorRole );
                            scorer = new CexmcTrackPointsInLeftRightSet(
                                    CexmcDetectorTypeName[ CexmcTPDetector ],
                                    this );
                            break;
                        }
                        if ( pair->value == "CalorimeterRole" )
                        {
                            AssertAndAsignDetectorRole( curDetectorRole,
                                                CexmcCalorimeterDetectorRole );
                            scorer = new CexmcTrackPointsInCalorimeter(
                                    CexmcDetectorTypeName[ CexmcTPDetector ],
                                    this );
                            break;
                        }
                        if ( pair->value == "TargetRole" )
                        {
                            AssertAndAsignDetectorRole( curDetectorRole,
                                                CexmcTargetDetectorRole );
                            scorer = new CexmcTrackPoints(
                                    CexmcDetectorTypeName[ CexmcTPDetector ] );
                            break;
                        }
                    } while ( false );
                    detectorName = CexmcDetectorRoleName[ curDetectorRole ];
                    G4cout << CEXMC_LINE_START "TP Scorer of detector role '" <<
                               detectorName << "' in volume '" << volumeName <<
                               "'" << G4endl;
                    if ( scorer )
                    {
                        CexmcTrackPointsFilter *  filter(
                                 new CexmcTrackPointsFilter( "trackPoints" ) );
                        scorer->SetFilter( filter );
                    }
                    break;
                }
                if ( pair->type == "SensitiveRegion" )
                {
                    do
                    {
                        if ( pair->value == "CalorimeterRegion" )
                        {
                            G4Region *  region( NULL );
                            if ( calorimeterRegionInitialized )
                            {
                                region = G4RegionStore::GetInstance()->
                                        GetRegion( CexmcCalorimeterRegionName );
                            }
                            else
                            {
                                region = new G4Region(
                                                CexmcCalorimeterRegionName );
                                G4ProductionCuts *  cuts(
                                                        new G4ProductionCuts );
                                G4double  defaultProductionCut( 1.0 * mm );
                                const G4VUserPhysicsList *  physicsList(
                                            G4RunManager::GetRunManager()->
                                                        GetUserPhysicsList() );
                                if ( physicsList )
                                    defaultProductionCut =
                                            physicsList->GetDefaultCutValue();
                                cuts->SetProductionCut( defaultProductionCut );
                                region->SetProductionCuts( cuts );
                                calorimeterRegionInitialized = true;
                            }
                            region->AddRootLogicalVolume( *lvIter );
                            break;
                        }
                    } while ( false );
                    G4cout << CEXMC_LINE_START "Sensitive Region for logical "
                               "volume '" << volumeName << "' registered" <<
                               G4endl;
                    break;
                }
                if ( pair->type == "SpecialVolume" )
                {
                    do
                    {
                        if ( pair->value == "Monitor" )
                        {
                            monitorVolume = *lvIter;
                            G4cout << CEXMC_LINE_START "Monitor volume '";
                            break;
                        }
                        if ( pair->value == "VetoCounter" )
                        {
                            vetoCounterVolume = *lvIter;
                            G4cout << CEXMC_LINE_START "VetoCounter volume '";
                            break;
                        }
                        if ( pair->value == "Calorimeter" )
                        {
                            calorimeterVolume = *lvIter;
                            G4cout << CEXMC_LINE_START "Calorimeter volume '";
                            ReadCalorimeterGeometryData( *lvIter );
                            calorimeterGeometryDataInitialized = true;
                            break;
                        }
                        if ( pair->value == "Target" )
                        {
                            targetVolume = *lvIter;
                            G4cout << CEXMC_LINE_START "Target volume '";
                            break;
                        }
                    } while ( false );
                    G4cout << volumeName << "' registered" << G4endl;
                    break;
                }
            }
            while ( false );

            if ( scorer )
            {
                /* curDetectorRole must be intact when scorer is not NULL */
                if ( ! detector[ curDetectorRole ] )
                {
                    detector[ curDetectorRole ] =
                                new G4MultiFunctionalDetector( detectorName );
                }
                detector[ curDetectorRole ]->RegisterPrimitive( scorer );
                /* now that scorer has initialized pointer to its detector, its
                 * messenger's path shall be properly initialized as well */
                scorer->InitializeMessenger();
                /* NB: logical volumes in GDML file may not have multiple
                 * detector roles: for example volume Monitor may have only one
                 * role MonitorRole. This restriction arises from that fact that
                 * a logical volume may contain only one sensitive detector. */
                ( *lvIter )->SetSensitiveDetector(
                                                detector[ curDetectorRole ] );
            }
        }
    }

    if ( ! calorimeterRegionInitialized )
        throw CexmcException( CexmcCalorimeterRegionNotInitialized );

    if ( ! calorimeterGeometryDataInitialized )
        throw CexmcException( CexmcCalorimeterGeometryDataNotInitialized );

    for ( G4int  i( 0 ); i < CexmcNumberOfDetectorRoles; ++i )
    {
        if ( detector[ i ] )
            G4SDManager::GetSDMpointer()->AddNewDetector( detector[ i ] );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

calorimeterGeometry

CalorimeterGeometryData CexmcSetup::calorimeterGeometry

private

Definition at line 157 of file CexmcSetup.hh.

calorimeterGeometryDataInitialized

G4bool CexmcSetup::calorimeterGeometryDataInitialized

private

Definition at line 137 of file CexmcSetup.hh.

calorimeterLeftTransform

G4AffineTransform CexmcSetup::calorimeterLeftTransform

private

Definition at line 153 of file CexmcSetup.hh.

calorimeterRegionInitialized

G4bool CexmcSetup::calorimeterRegionInitialized

private

Definition at line 135 of file CexmcSetup.hh.

calorimeterRightTransform

G4AffineTransform CexmcSetup::calorimeterRightTransform

private

Definition at line 155 of file CexmcSetup.hh.

calorimeterVolume

G4LogicalVolume* CexmcSetup::calorimeterVolume

private

Definition at line 143 of file CexmcSetup.hh.

gdmlFile

G4String CexmcSetup::gdmlFile

private

Definition at line 131 of file CexmcSetup.hh.

monitorVolume

G4LogicalVolume* CexmcSetup::monitorVolume

private

Definition at line 139 of file CexmcSetup.hh.

rightCalorimeter

G4VPhysicalVolume* CexmcSetup::rightCalorimeter

private

Definition at line 149 of file CexmcSetup.hh.

rightVetoCounter

G4VPhysicalVolume* CexmcSetup::rightVetoCounter

private

Definition at line 147 of file CexmcSetup.hh.

targetTransform

G4AffineTransform CexmcSetup::targetTransform

private

Definition at line 151 of file CexmcSetup.hh.

targetVolume

G4LogicalVolume* CexmcSetup::targetVolume

private

Definition at line 145 of file CexmcSetup.hh.

validateGDMLFile

G4bool CexmcSetup::validateGDMLFile

private

Definition at line 133 of file CexmcSetup.hh.

vetoCounterVolume

G4LogicalVolume* CexmcSetup::vetoCounterVolume

private

Definition at line 141 of file CexmcSetup.hh.

world

G4VPhysicalVolume* CexmcSetup::world

private

Definition at line 129 of file CexmcSetup.hh.

---

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

• CexmcSetup.hh
• CexmcSetup.cc