Message: Issue with Replica Not Logged In (login)
 Next-in-Thread Next-in-Thread
 Next-in-Forum Next-in-Forum

None Issue with Replica 

Forum: Geometry
Date: 04 Apr, 2016
From: <telimuzamil001@gmail.com>

Hi all,
 I am replicating an RPC. Its is like as,

RPCDetectorConstruction::RPCDetectorConstruction() {

// Detector dimensions

  //Shielding outside the RPC
  x_Shield_in= 40*cm;
  y_Shield_in= 40*cm;
  z_Shield_in= 38*cm;

  x_Shield_out= 44*cm;
  y_Shield_out= 44*cm;
  z_Shield_out= 40*cm;

  //World
  fWorldLength = 15*x_Shield_out;
  HalfWorldLength = 0.5*fWorldLength;

  //Gas chamber
  gas_gap= 2*mm;

  //Plates forming the chamber
  x_plate= 30*cm;
  y_plate= 30*cm;
  thickness_plate= 2*mm;

  //Coating
  x_coat= 28*cm;
  y_coat= 28*cm;
  thickness_coat= 0.002*mm;

  //Mylar
  thickness_mylar= 0.1*mm;

  //Pickup strips
  width_CuStrip= 2.8*cm;
  thickness_CuStrip= 0.2*mm;
  NofStrips= 10;

  //Honeycomb
  thickness_HC= 10*mm;

  //Al
  thickness_Al= 0.5*mm;

  //Edge spacers
  thickness_eSpacer= 2*mm;
  width_eSpacer= 8*mm;

  //Button spacers
  thickness_bSpacer= gas_gap;
  radius_bSpacer= 0.5*cm;
  NofBSpacers= 5;

//Electric field

  G4double fieldvalue= 50*kilovolt/cm;
  G4ThreeVector fieldVector = G4ThreeVector (0.0,0.0,fieldvalue);

// G4bool allLocal = true;

  RPCElectricFieldSetup* fEmFieldSetup = new RPCElectricFieldSetup(fieldVector, logicChamber);

// G4FieldManager* localFieldManager ;

// G4UniformElectricField* myField = new G4UniformElectricField (G4ThreeVector(0.0, fieldvalue, 0.0));

// RPCElectricFieldSetup* fEmFieldSetup = new RPCElectricFieldSetup; // RPCElectricFieldSetup* fEmFieldSetup = new RPCElectricFieldSetup(fieldVector,LogicalVolumeWithField);

// logicChamber->SetFieldManager(myField, allLocal);

/* G4UniformElectricField* myfield = new G4UniformElectricField(G4ThreeVector(0,9000 *kilovolt/cm, 0));

G4FieldManager *pFieldMgr;

G4MagIntegratorStepper* pStepper;

G4ChordFinder* pChordFinder;

G4EqMagElectricField* fEquation = new G4EqMagElectricField(myfield);

G4MagInt_Driver* pIntgrDriver;

G4TransportationManager* pTransportMgr = G4TransportationManager::GetTransportationManager();

G4PropagatorInField* pFieldPropagator;

pFieldPropagator = pTransportMgr -> GetPropagatorInField();

pStepper = new G4ClassicalRK4(fEquation, 8);

pFieldMgr = pTransportMgr -> GetFieldManager();

pFieldMgr -> SetFieldChangesEnergy(true);

pFieldMgr -> SetDetectorField(myfield);

pIntgrDriver = new G4MagInt_Driver(0.01 *mm, pStepper, pStepper -> GetNumberOfVariables());

pChordFinder = new G4ChordFinder(pIntgrDriver);

pFieldMgr -> SetChordFinder(pChordFinder);

*/

}

RPCDetectorConstruction::~RPCDetectorConstruction() { //if(fEmFieldSetup) delete fEmFieldSetup; }

G4VPhysicalVolume * RPCDetectorConstruction::Construct() {

// ----------Material Definition---------- G4int nofLayers = 10; G4double layerThickness = gas_gap + 2*(thickness_plate + thickness_coat + thickness_mylar + thickness_CuStrip + thickness_HC); G4double Shield_outThickness = nofLayers*layerThickness;

  G4double a, z;
  G4double density, temperature, pressure;
  G4int nel, natoms;

  // Vacuum
  galactic = new G4Material ("Galactic", z=1., a=1.01*g/mole, density= CLHEP::universe_mean_density, kStateGas, temperature=0.1*kelvin, pressure=1.e-19*pascal);

  G4NistManager* mat = G4NistManager::Instance();  
  mat->SetVerbose(1);

  G4Element* Ar =  mat->FindOrBuildElement("Ar");
  G4Element* S  =  mat->FindOrBuildElement("S");
  G4Element* F  =  mat->FindOrBuildElement("F");
  SF6 =  new G4Material("SF6",density = 0.006164*g/cm3, nel=2);
  SF6->AddElement(S, natoms=1);
  SF6->AddElement(F, natoms=6);

  G4Material* Butane =   mat->FindOrBuildMaterial("G4_BUTANE");
  G4Material* Freon =   mat->FindOrBuildMaterial("G4_FREON-13B1");

  Iron =  mat->FindOrBuildMaterial("G4_Fe");
  Copper =  mat->FindOrBuildMaterial("G4_Cu");
  Aluminium =  mat->FindOrBuildMaterial("G4_Al");
  CoatMaterial = mat->FindOrBuildMaterial("G4_GRAPHITE");
  MylarMaterial = mat->FindOrBuildMaterial("G4_MYLAR");
  HoneyCombMaterial =  mat->FindOrBuildMaterial("G4_POLYETHYLENE");
  Air = mat->FindOrBuildMaterial("G4_AIR");
//  SiO2 = mat->FindOrBuildMaterial("G4_SILICON_DIOXIDE");

  // Bakelite (Phenolic resin material, CHO)

  G4Element* C = new G4Element("Carbon", "C", z=6., a=12.01*g/mole);
  G4Element* H = new G4Element("Hydrogen", "H", z=1., a=1.01*g/mole);
  G4Element* O = new G4Element("Oxygen", "O", z=8., a=16.00*g/mole);

  Bakelite = new G4Material ("Bakelite", density=1.25*g/cm3, nel=3);
/*
// another way to form Bakelite
  Bakelite->AddElement(C, natoms=1);
  Bakelite->AddElement(H, natoms=1);
  Bakelite->AddElement(O, natoms=1);
*/
  Bakelite->AddElement(C, 77.5*perCent);
  Bakelite->AddElement(H, 5.7*perCent);
  Bakelite->AddElement(O, 16.8*perCent);

// Polycarbonate

  G4Material* polycarbonate = new G4Material("Polycarbonate", density= 1.2*g/cm3, nel=3);
  polycarbonate->AddElement(H, 5.5491*perCent);
  polycarbonate->AddElement(C, 75.5751*perCent);
  polycarbonate->AddElement(O, 18.8758*perCent);

// Gas mixture within RPC
  gas_mixture = new G4Material("RPC gas mixture", density=0.00418*g/cm3, nel=3);
  gas_mixture->AddMaterial(Freon, 37.5*perCent);
  gas_mixture->AddMaterial(Butane, 7.5*perCent);
  gas_mixture->AddElement(Ar, 55*perCent);

// gas_mixture->AddMaterial(SF6, 0.34*perCent);

// Print all the materials defined

// G4cout<<G4endl<<"The Materials defined are: "<<G4endl<<G4endl; // G4cout<<*(G4Material::GetMaterialTable())<<G4endl<<G4endl;

// -----------Definitions of solids, logical volumes and physical volumes-----------

 // Clean old geometry, if any
  //
  G4GeometryManager::GetInstance()->OpenGeometry();
  G4PhysicalVolumeStore::GetInstance()->Clean();
  G4LogicalVolumeStore::GetInstance()->Clean();
  G4SolidStore::GetInstance()->Clean();

  // Option to switch on/off checking of volumes overlaps
  G4bool checkOverlaps = true;

// World:

  G4GeometryManager::GetInstance()->SetWorldMaximumExtent(fWorldLength);
//  G4cout<<"Computed Tolerance = "<<G4GeometryTolerance::GetInstance()->GetSurfaceTolerance()/mm<<" mm"<<G4endl;

  WorldMaterial = galactic;

  solidWorld = new G4Box("World", HalfWorldLength, HalfWorldLength, HalfWorldLength);
  logicWorld = new G4LogicalVolume(solidWorld, WorldMaterial, "World", 0, 0, 0);
  physiWorld = new G4PVPlacement(0, G4ThreeVector(), logicWorld, "World", 0, false, 0, checkOverlaps);

  solidLayer = new G4Box("Layer", 0.5*x_Shield_out, 0.5*y_Shield_out, 0.5*layerThickness); 

  logicLayer = new G4LogicalVolume(solidLayer, WorldMaterial, "Layer", 0, 0, 0);         

  physiLayer = new G4PVReplica( "Layer", logicLayer, logicShield, kZAxis, nofLayers, layerThickness, 0);    

// RPC gas chamber

  ChamberMaterial = gas_mixture;

  solidChamber = new G4Box("Gas_Chamber", 0.5*(x_plate-2*width_eSpacer), 0.5*(y_plate-2*width_eSpacer), 0.5*gas_gap);
//  logicChamber = new G4LogicalVolume(solidChamber, ChamberMaterial, "Gas_Chamber", myField, 0, 0);
  logicChamber = new G4LogicalVolume(solidChamber, ChamberMaterial, "Gas_Chamber", 0, 0, 0);
  physiChamber = new G4PVPlacement(0, G4ThreeVector(0,0,0), logicChamber, "Gas_Chamber", logicLayer, false, 0, checkOverlaps);

  G4Region* regChamber1 = new G4Region("region_GasChamber");
  logicChamber->SetRegion(regChamber1);
  regChamber1->AddRootLogicalVolume(logicChamber);

// The two plates forming the gas chamber:

  PlateMaterial = Bakelite;

  solidPlate = new G4Box("Plate", 0.5*x_plate, 0.5*y_plate, 0.5*thickness_plate);
  logicPlate = new G4LogicalVolume(solidPlate, PlateMaterial, "Plate", 0, 0, 0);

  physiPlate_down = new G4PVPlacement(0, G4ThreeVector(0, 0, -0.5*(gas_gap + thickness_plate)), logicPlate, "Plate_down", logicLayer, false, 0, checkOverlaps);
  physiPlate_up = new G4PVPlacement(0, G4ThreeVector(0, 0, 0.5*(gas_gap + thickness_plate)), logicPlate, "Plate_up", logicLayer, false, 0, checkOverlaps);

  G4Region* regChamber2 = new G4Region("region_BakelitePlate");
  logicPlate->SetRegion(regChamber2);
  regChamber2->AddRootLogicalVolume(logicPlate);

// Coating on the plates to provide uniform electric field:

  solidCoat = new G4Box("Coat", 0.5*x_coat, 0.5*y_coat, 0.5*thickness_coat);
  logicCoat = new G4LogicalVolume(solidCoat, CoatMaterial, "Coat", 0, 0, 0);

  physiCoat_down = new G4PVPlacement(0, G4ThreeVector(0, 0, -0.5*(gas_gap + 2*thickness_plate + thickness_coat)), logicCoat, "Coat_down", logicLayer, false, 0, checkOverlaps);
  physiCoat_up = new G4PVPlacement(0, G4ThreeVector(0, 0, 0.5*(gas_gap + 2*thickness_plate + thickness_coat)), logicCoat, "Coat_up", logicLayer, false, 0, checkOverlaps);

// Mylar sheet to isolate H.V. intereference with the Pickup signal

  solidMylar = new G4Box ("Mylar", 0.5*x_plate, 0.5*y_plate, 0.5*thickness_mylar);
  logicMylar = new G4LogicalVolume (solidMylar, MylarMaterial, "Mylar", 0, 0, 0);

  physiMylar_down = new G4PVPlacement (0, G4ThreeVector(0, 0, -0.5*(gas_gap + 2*thickness_plate + 2*thickness_coat + thickness_mylar)), logicMylar, "Mylar_down", logicLayer, false, 0, checkOverlaps);
  physiMylar_up = new G4PVPlacement (0, G4ThreeVector(0, 0, 0.5*(gas_gap + 2*thickness_plate + 2*thickness_coat + thickness_mylar)), logicMylar, "Mylar_up", logicLayer, false, 0, checkOverlaps);

// Pick up panel (Cu strip + Honeycomb + Al)

  // Cu Strips

  G4RotationMatrix* rot1 = new G4RotationMatrix;
  rot1->rotateZ(M_PI/2.*rad);

  solidCuStrip = new G4Box ("Copper_strip", 0.5*width_CuStrip, 0.5*y_plate, 0.5*thickness_CuStrip);
  logicCuStrip = new G4LogicalVolume (solidCuStrip, Copper, "CopperStrip", 0, 0, 0);

  for(G4int ii=0; ii<NofStrips; ii++)
	{
	physiCuStrip_down[ii] = new G4PVPlacement (rot1, G4ThreeVector(0, (width_CuStrip/2-15*cm+3*ii*cm), -0.5*(gas_gap + 2*thickness_plate + 2*thickness_coat + 2*thickness_mylar + thickness_CuStrip)), logicCuStrip, "Copper_strip_down", logicLayer, false, 0, checkOverlaps);
	}

  for(G4int jj=0; jj<NofStrips; jj++)
	{
	physiCuStrip_up[jj] = new G4PVPlacement (0, G4ThreeVector((width_CuStrip/2-15*cm+3*jj*cm), 0, 0.5*(gas_gap + 2*thickness_plate + 2*thickness_coat + 2*thickness_mylar + thickness_CuStrip)), logicCuStrip, "Copper_strip_up", logicLayer, false, 0, checkOverlaps);
	}

  // Honey comb

  solidHoneyComb = new G4Box ("HoneyComb", 0.5*x_plate, 0.5*y_plate, 0.5*thickness_HC);
  logicHoneyComb = new G4LogicalVolume (solidHoneyComb, HoneyCombMaterial, "HoneyComb", 0, 0, 0);

  physiHoneyComb_down = new G4PVPlacement (0, G4ThreeVector(0, 0, -0.5*(gas_gap + 2*(thickness_plate + thickness_coat + thickness_mylar + thickness_CuStrip) + thickness_HC)), logicHoneyComb, "HoneyComb_down", logicLayer, false, 0, checkOverlaps);
  physiHoneyComb_up = new G4PVPlacement (0, G4ThreeVector(0, 0, 0.5*(gas_gap + 2*(thickness_plate + thickness_coat + thickness_mylar + thickness_CuStrip) + thickness_HC)), logicHoneyComb, "HoneyComb_up", logicLayer, false, 0, checkOverlaps);

  G4Region* regChamber3 = new G4Region("region_HoneyComb");
  logicHoneyComb->SetRegion(regChamber3);
  regChamber3->AddRootLogicalVolume(logicHoneyComb);

  // Al

  solidAl = new G4Box ("Aluminium", 0.5*x_plate, 0.5*y_plate, 0.5*thickness_Al);
  logicAl = new G4LogicalVolume (solidAl, Aluminium, "Aluminium_plate", 0, 0, 0);

  physiAl_down = new G4PVPlacement (0, G4ThreeVector(0, 0, -0.5*(gas_gap + 2*(thickness_plate + thickness_coat + thickness_mylar + thickness_CuStrip + thickness_HC) + thickness_Al)), logicAl, "Aluminium_plate_down", logicLayer, false, 0, checkOverlaps);
  physiAl_up = new G4PVPlacement (0, G4ThreeVector(0, 0, 0.5*(gas_gap + 2*(thickness_plate + thickness_coat + thickness_mylar + thickness_CuStrip + thickness_HC) + thickness_Al)), logicAl, "Aluminium_plate_up", logicLayer, false, 0, checkOverlaps);

  G4Region* regChamber4 = new G4Region("region_AlSheet");
  logicAl->SetRegion(regChamber4);
  regChamber4->AddRootLogicalVolume(logicAl);

// Spacers

  SpacerMaterial = polycarbonate;

  // Edge spacers:

  solidESpacer = new G4Box("EdgeSpacer", 0.5*x_plate, 0.5*width_eSpacer, 0.5*thickness_eSpacer);
  logicESpacer = new G4LogicalVolume(solidESpacer, SpacerMaterial, "EdgeSpacer", 0, 0, 0);

  physiESpacer_front = new G4PVPlacement(0, G4ThreeVector(0,-0.5*(y_plate-width_eSpacer),0), logicESpacer, "EdgeSpacer_front", logicLayer, false, 0, checkOverlaps);
  physiESpacer_back = new G4PVPlacement(0, G4ThreeVector(0,0.5*(y_plate-width_eSpacer),0), logicESpacer, "EdgeSpacer_back", logicLayer, false, 0, checkOverlaps);

  solidESpacer_short = new G4Box("EdgeSpacer_short", 0.5*width_eSpacer, 0.5*(y_plate-2*width_eSpacer), 0.5*thickness_eSpacer);
  logicESpacer_short = new G4LogicalVolume(solidESpacer_short, SpacerMaterial, "EdgeSpacer_short", 0, 0, 0);

  physiESpacer_left = new G4PVPlacement(0, G4ThreeVector(-0.5*(x_plate-width_eSpacer),0,0), logicESpacer_short, "EdgeSpacer_left", logicLayer, false, 0, checkOverlaps);
  physiESpacer_right = new G4PVPlacement(0, G4ThreeVector(0.5*(x_plate-width_eSpacer),0,0), logicESpacer_short, "EdgeSpacer_right", logicLayer, false, 0, checkOverlaps);

  // Button spacers:

  solidBSpacer = new G4Tubs ("ButtonSpacer", 0, radius_bSpacer, 0.5*thickness_bSpacer, 0, CLHEP::twopi);
  logicBSpacer = new G4LogicalVolume (solidBSpacer, SpacerMaterial, "ButtonSpacer", 0, 0, 0);

  xpos_button[0]= 0; xpos_button[1]= -7; xpos_button[2]= -7; xpos_button[3]= 7; xpos_button[4]= 7;
  ypos_button[0]= 0; ypos_button[1]= -7; ypos_button[2]= 7; ypos_button[3]= 7; ypos_button[4]= -7;

  for(G4int i=0; i<NofBSpacers; i++)
	{
//	G4cout<<"Button position[x]: "<<xpos_button[i]<<G4endl;
//	G4cout<<"Button position[y]: "<<ypos_button[i]<<G4endl;
	physiBSpacer[i] = new G4PVPlacement (0, G4ThreeVector(xpos_button[i]*cm, ypos_button[i]*cm, 0), logicBSpacer, "ButtonSpacer", logicLayer, false, 0, 0);
	}

// Shielding box to keep temperature constant

  ShieldMaterial = Aluminium;
  G4ThreeVector positionShield = G4ThreeVector(0, 0, 0);

  solidShield_out = new G4Box("Shield_out", 0.5*x_Shield_out, 0.5*y_Shield_out, 0.5*Shield_outThickness);
  solidShield_in = new G4Box("Shield_in", 0.5*x_Shield_in, 0.5*y_Shield_in, 0.5*z_Shield_in);
  solidShield = new G4SubtractionSolid ("Shield", solidShield_out, solidShield_in);

  logicShield = new G4LogicalVolume(solidShield, ShieldMaterial, "Shield", 0, 0, 0);
  physiShield = new G4PVPlacement(0, positionShield, logicShield, "Shield", logicWorld, false, 0, checkOverlaps);

  G4Region* regChamber5 = new G4Region("region_Shield");
  logicShield->SetRegion(regChamber5);
  regChamber5->AddRootLogicalVolume(logicShield);

 // Layer
  //

  // Set scoring volume to stepping action 
  // (where we will account energy deposit)
  //
  RPCSteppingAction* steppingAction = RPCSteppingAction::Instance(); 
  steppingAction->SetVolume(logicChamber);

/* // Sensitive detectors

  G4SDManager* SDman = G4SDManager::GetSDMpointer();

  G4String trackerChamberSDname = "RPC/ChamberSD";
  RPCChamberSD* aTrackerSD = new RPCChamberSD( trackerChamberSDname );
  SDman->AddNewDetector( aTrackerSD );
  logicChamber->SetSensitiveDetector( aTrackerSD );
//  logicCuStrip->SetSensitiveDetector( aTrackerSD );
*/

// --------------Visualization Attributes--------------

  G4VisAttributes * BoxVisAtt = new G4VisAttributes(G4Colour(1.0,1.0,1.0));
  logicWorld->SetVisAttributes(BoxVisAtt);  
/*  
  G4VisAttributes * Shield_VisAtt = new G4VisAttributes( G4Colour(0.5,0.5,0.5) );
  logicShield->SetVisAttributes(Shield_VisAtt);  
*/
  G4VisAttributes* ChamberVisAtt = new G4VisAttributes( G4Colour(1.0,1.0,0.0) );
  logicChamber->SetVisAttributes(ChamberVisAtt);

  G4VisAttributes * Plate_VisAtt = new G4VisAttributes( G4Colour(0.5,0.5,0.5) );
  G4VisAttributes * Coat_VisAtt = new G4VisAttributes( G4Colour(0.5,0.5,0.) );
  G4VisAttributes * Spacer_VisAtt = new G4VisAttributes( G4Colour(1.,0.,1.) );

  logicPlate->SetVisAttributes(Plate_VisAtt);
  logicCoat->SetVisAttributes(Coat_VisAtt);
  logicESpacer->SetVisAttributes(Spacer_VisAtt);
  logicESpacer_short->SetVisAttributes(Spacer_VisAtt);
  logicBSpacer->SetVisAttributes(Spacer_VisAtt);
//  logicCuStrip->SetVisAttributes(Spacer_VisAtt);

// User Limits

// Sets a maximum step length in RPC active region, with G4StepLimiter

  G4double maxStep = 0.5*gas_gap;
  stepLimit = new G4UserLimits(maxStep);
  logicChamber->SetUserLimits(stepLimit);

  return physiWorld;
}

void RPCDetectorConstruction::SetMaxStep(G4double maxStep)
{
  if ((stepLimit)&&(maxStep>0.)) stepLimit->SetMaxAllowedStep(maxStep);
}

I am able to do make. But on final run I get the error as, *** Break *** segmentation violation

===========================================================

There was a crash.

This is the entire stack trace of all threads:

===========================================================

#0 0x00007f4f2ea38b4c in __libc_waitpid (pid=8655, stat_loc=stat_loc

entry=0x7ffeca352040, options=options

entry=0) at ../sysdeps/unix/sysv/linux/waitpid.c:31

#1 0x00007f4f2e9be2e2 in do_system (line=<optimized out>) at ../sysdeps/posix/system.c:148

#2 0x00007f4f32ae8ec3 in TUnixSystem::StackTrace() () from /home/muzamil/products/root/lib/libCore.so

#3 0x00007f4f32aeabcc in TUnixSystem::DispatchSignals(ESignals) () from /home/muzamil/products/root/lib/libCore.so

#4 <signal handler called>

#5 0x00007f4f2c2cd910 in G4PVReplica::G4PVReplica(G4String const&, G4LogicalVolume*, G4LogicalVolume*, EAxis, int, double, double) () from /home/muzamil/products/Geant4/geant4-install/lib/libG4geometry.so

#6 0x00007f4f316dd5cd in RPCDetectorConstruction::Construct (this=0x20a1120) at src/rpcDetectorConstruction.cc:244

#7 0x00007f4f2fccecfc in G4RunManager::InitializeGeometry() () from /home/muzamil/products/Geant4/geant4-install/lib/libG4run.so

#8 0x00007f4f2fccedd1 in G4RunManager::Initialize() () from /home/muzamil/products/Geant4/geant4-install/lib/libG4run.so

#9 0x0000000000405342 in main (argc=1, argv=0x7ffeca354e68) at rpc.cc:95

===========================================================

The lines below might hint at the cause of the crash.

If they do not help you then please submit a bug report at

http://root.cern.ch/bugs . Please post the ENTIRE stack trace

from above as an attachment in addition to anything else

that might help us fixing this issue.

#5 0x00007f4f2c2cd910 in G4PVReplica::G4PVReplica(G4String const&, G4LogicalVolume*, G4LogicalVolume*, EAxis, int, double, double) () from /home/muzamil/products/Geant4/geant4-install/lib/libG4geometry.so

#6 0x00007f4f316dd5cd in RPCDetectorConstruction::Construct (this=0x20a1120) at src/rpcDetectorConstruction.cc:244

#7 0x00007f4f2fccecfc in G4RunManager::InitializeGeometry() () from /home/muzamil/products/Geant4/geant4-install/lib/libG4run.so

#8 0x00007f4f2fccedd1 in G4RunManager::Initialize() () from /home/muzamil/products/Geant4/geant4-install/lib/libG4run.so

#9 0x0000000000405342 in main (argc=1, argv=0x7ffeca354e68) at rpc.cc:95

Please help me to sort this out. I am very much frustrated.

Inline Depth:
 1 1
 All All
Outline Depth:
 1 1
 2 2
 All All
Add message: (add)

1 Feedback: Re: Issue with Replica   (Gabriele Cosmo - 05 Apr, 2016)
 Add Message Add Message
to: "Issue with Replica"

 Subscribe Subscribe

This site runs SLAC HyperNews version 1.11-slac-98, derived from the original HyperNews


[ Geant 4 Home | Geant 4 HyperNews | Search | Request New Forum | Feedback ]