boost::shared_ptr<SparseMatrix> NpdmSpinOps::build_compound_operator( bool is_fermion, int sign,
boost::shared_ptr<SparseMatrix> lhsOp,
boost::shared_ptr<SparseMatrix> rhsOp,
int ispin, std::vector<int> indices, bool transpose )
{
// Initialize new operator
boost::shared_ptr<SparseMatrix> newOp (new Cre);
assert( lhsOp->get_orbs().size() + rhsOp->get_orbs().size() == indices.size() );
newOp->set_orbs() = indices;
newOp->set_initialised() = true;
newOp->set_fermion() = is_fermion;
if (sign == 1) newOp->set_deltaQuantum( 1, ( lhsOp->get_deltaQuantum(0) + rhsOp->get_deltaQuantum(0) ).at(ispin) );
else newOp->set_deltaQuantum( 1, ( lhsOp->get_deltaQuantum(0) - rhsOp->get_deltaQuantum(0) ).at(ispin) );
//cout << "Building compound operator.......................................................\n";
//cout << "2*lhs spin = " << lhsOp->get_deltaQuantum().get_s() << std::endl;
//cout << "2*rhs spin = " << rhsOp->get_deltaQuantum().get_s() << std::endl;
//cout << "2*total spin = " << newOp->get_deltaQuantum().get_s() << std::endl;
newOp->allocate( spinBlock_->get_stateInfo() );
if (transpose) {
// Build compound operator as product of LHS and TRANSPOSE( RHS )
operatorfunctions::Product(spinBlock_, *lhsOp, Transposeview(*rhsOp), *newOp, 1.0 );
}
else {
// Build compound operator as product of LHS and RHS
operatorfunctions::Product(spinBlock_, *lhsOp, *rhsOp, *newOp, 1.0 );
}
//cout << *newOp;
//cout << "Done Building compound operator.......................................................\n";
return newOp;
}
BoundaryOperator<BasisFunctionType, ResultType>
laplace3dSingleLayerBoundaryOperator(
const shared_ptr<const Context<BasisFunctionType, ResultType> >& context,
const shared_ptr<const Space<BasisFunctionType> >& domain,
const shared_ptr<const Space<BasisFunctionType> >& range,
const shared_ptr<const Space<BasisFunctionType> >& dualToRange,
const std::string& label,
int symmetry)
{
const AssemblyOptions& assemblyOptions = context->assemblyOptions();
if (assemblyOptions.assemblyMode() == AssemblyOptions::ACA &&
assemblyOptions.acaOptions().mode == AcaOptions::LOCAL_ASSEMBLY)
return laplace3dSyntheticBoundaryOperator(
&laplace3dSingleLayerBoundaryOperator<BasisFunctionType, ResultType>,
context, domain, range, dualToRange, label, symmetry,
// maximum synthese symmetry (if spaces match)
(boost::is_complex<BasisFunctionType>() ? 0 : SYMMETRIC) | HERMITIAN);
typedef typename ScalarTraits<BasisFunctionType>::RealType KernelType;
typedef typename ScalarTraits<BasisFunctionType>::RealType CoordinateType;
typedef Fiber::Laplace3dSingleLayerPotentialKernelFunctor<KernelType>
KernelFunctor;
typedef Fiber::ScalarFunctionValueFunctor<CoordinateType>
TransformationFunctor;
typedef Fiber::SimpleTestScalarKernelTrialIntegrandFunctorExt<
BasisFunctionType, KernelType, ResultType, 1> IntegrandFunctor;
typedef GeneralElementarySingularIntegralOperator<
BasisFunctionType, KernelType, ResultType> Op;
shared_ptr<Fiber::TestKernelTrialIntegral<
BasisFunctionType, KernelType, ResultType> > integral;
if (shouldUseBlasInQuadrature(assemblyOptions, *domain, *dualToRange))
integral.reset(new Fiber::TypicalTestScalarKernelTrialIntegral<
BasisFunctionType, KernelType, ResultType>());
else
integral.reset(new Fiber::DefaultTestKernelTrialIntegral<IntegrandFunctor>(
IntegrandFunctor()));
shared_ptr<Op> newOp(new Op(
domain, range, dualToRange, label, symmetry,
KernelFunctor(),
TransformationFunctor(),
TransformationFunctor(),
integral));
return BoundaryOperator<BasisFunctionType, ResultType>(context, newOp);
}
static AIExpType_t *Primary( pc_token_list **list )
{
pc_token_list *current = *list;
AIExpType_t *tree = nullptr;
if ( isUnaryOp( opTypeFromToken( ¤t->token ) ) )
{
AIExpType_t *t;
AIOp_t *op = newOp( current );
*list = current->next;
t = ReadConditionExpression( list, op->opType );
if ( !t )
{
Log::Warn( "Missing right operand for %s on line %d", opTypeToString( op->opType ), current->token.line );
FreeOp( op );
return nullptr;
}
tree = makeExpression( op, t, nullptr );
}
else if ( current->token.string[0] == '(' )
{
*list = current->next;
tree = ReadConditionExpression( list, OP_NONE );
if ( !expectToken( ")", list, true ) )
{
return nullptr;
}
}
else if ( current->token.type == tokenType_t::TT_NUMBER )
{
tree = ( AIExpType_t * ) newValueLiteral( list );
}
else if ( current->token.type == tokenType_t::TT_NAME )
{
tree = ( AIExpType_t * ) newValueFunc( list );
}
else
{
Log::Warn( "token %s on line %d is not valid", current->token.string, current->token.line );
}
return tree;
}
static AIExpType_t *ReadConditionExpression( pc_token_list **list, AIOpType_t op2 )
{
AIExpType_t *t;
AIOpType_t op;
if ( !*list )
{
Log::Warn( "Unexpected end of file" );
return nullptr;
}
t = Primary( list );
if ( !t )
{
return nullptr;
}
op = opTypeFromToken( &(*list)->token );
while ( isBinaryOp( op ) && opCompare( op, op2 ) >= 0 )
{
AIExpType_t *t1;
pc_token_list *prev = *list;
AIOp_t *exp = newOp( *list );
*list = (*list)->next;
t1 = ReadConditionExpression( list, op );
if ( !t1 )
{
Log::Warn( "Missing right operand for %s on line %d", opTypeToString( op ), prev->token.line );
FreeExpression( t );
FreeOp( exp );
return nullptr;
}
t = makeExpression( exp, t, t1 );
op = opTypeFromToken( &(*list)->token );
}
return t;
}
BoundaryOperator<BasisFunctionType, ResultType>
laplace3dPeriodicDoubleLayerBoundaryOperator(
const shared_ptr<const Context<BasisFunctionType, ResultType> >& context,
const shared_ptr<const Space<BasisFunctionType> >& domain,
const shared_ptr<const Space<BasisFunctionType> >& range,
const shared_ptr<const Space<BasisFunctionType> >& dualToRange,
const std::string& label,
int symmetry)
{
const AssemblyOptions& assemblyOptions = context->assemblyOptions();
if (assemblyOptions.assemblyMode() == AssemblyOptions::ACA &&
assemblyOptions.acaOptions().mode == AcaOptions::LOCAL_ASSEMBLY)
return laplace3dPeriodicSyntheticBoundaryOperator(
&laplace3dPeriodicDoubleLayerBoundaryOperator<BasisFunctionType, ResultType>,
context, domain, range, dualToRange, label, symmetry,
NO_SYMMETRY);
typedef typename ScalarTraits<BasisFunctionType>::RealType KernelType;
typedef typename ScalarTraits<BasisFunctionType>::RealType CoordinateType;
typedef Fiber::Laplace3dPeriodicDoubleLayerPotentialKernelFunctor<KernelType>
KernelFunctor;
typedef Fiber::ScalarFunctionValueFunctor<CoordinateType>
TransformationFunctor;
typedef Fiber::SimpleTestScalarKernelTrialIntegrandFunctorExt<
BasisFunctionType, KernelType, ResultType, 1> IntegrandFunctor;
typedef GeneralElementarySingularIntegralOperator<
BasisFunctionType, KernelType, ResultType> Op;
shared_ptr<Op> newOp(new Op(
domain, range, dualToRange, label, symmetry,
KernelFunctor(),
TransformationFunctor(),
TransformationFunctor(),
IntegrandFunctor()));
return BoundaryOperator<BasisFunctionType, ResultType>(context, newOp);
}
